fix(server): preserve event API requirements

bun.lock

@@ -277,6 +277,7 @@
         "@opencode-ai/effect-sqlite-node": "workspace:*",
         "@opencode-ai/llm": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
+        "@opencode-ai/schema": "workspace:*",
         "@openrouter/ai-sdk-provider": "2.9.0",
         "@opentelemetry/api": "1.9.0",
         "@opentelemetry/context-async-hooks": "2.6.1",
@@ -480,6 +481,7 @@
       "name": "@opencode-ai/llm",
       "version": "1.17.9",
       "dependencies": {
+        "@opencode-ai/schema": "workspace:*",
         "@smithy/eventstream-codec": "4.2.14",
         "@smithy/util-utf8": "4.2.2",
         "aws4fetch": "1.0.20",
@@ -651,6 +653,17 @@
         "@opentui/solid",
       ],
     },
+    "packages/schema": {
+      "name": "@opencode-ai/schema",
+      "dependencies": {
+        "effect": "catalog:",
+      },
+      "devDependencies": {
+        "@tsconfig/bun": "catalog:",
+        "@types/bun": "catalog:",
+        "@typescript/native-preview": "catalog:",
+      },
+    },
     "packages/script": {
       "name": "@opencode-ai/script",
       "dependencies": {
@@ -1804,6 +1817,8 @@
 
     "@opencode-ai/plugin": ["@opencode-ai/plugin@workspace:packages/plugin"],
 
+    "@opencode-ai/schema": ["@opencode-ai/schema@workspace:packages/schema"],
+
     "@opencode-ai/script": ["@opencode-ai/script@workspace:packages/script"],
 
     "@opencode-ai/sdk": ["@opencode-ai/sdk@workspace:packages/sdk/js"],

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-oWSGu+SP66Aquy/0Vaq7Bgp8404ZdOWbQX+O7h3jxHU=",
-    "aarch64-linux": "sha256-UsS0+c+GwtIukmWwQeFbY/3Oaz3t4Q7C6cFMGkmlyAY=",
-    "aarch64-darwin": "sha256-CArz92ewPmXO+ORFCBkCH8LzMpU/DjyaO4ic7QL0UpI=",
-    "x86_64-darwin": "sha256-rhnz9gmG6L06wIzfMhTaXDDEf6IbMD32CavqwXoqcUs="
+    "x86_64-linux": "sha256-/fq73Jr1mTysaKS0u7VUuwhFzz9tIlYw+9qyW5pA7es=",
+    "aarch64-linux": "sha256-iomnsCjOvab+v7+ebHoyg/Q7YtQegkln1+RTkb/tLn8=",
+    "aarch64-darwin": "sha256-7Uaxm1YlhblvtrVSFXPAx2zVjhYmhkjGkCA78bqs6Xg=",
+    "x86_64-darwin": "sha256-yJbe3TC8wlQJvQP7IwI+9USpsAjlwX7m5Jqa/7dW7bQ="
   }
 }

packages/app/src/components/dialog-select-directory-v2.tsx

@@ -19,6 +19,7 @@ import {
   pickerMode,
   preloadTreeDirectories,
   cleanPickerInput,
+  createPriorityTaskQueue,
   createDirectorySearch,
   currentPickerSuggestions,
   displayPickerPath,
@@ -55,6 +56,7 @@ export function DialogSelectDirectoryV2(props: DialogSelectDirectoryV2Props) {
   const [error, setError] = createSignal(false)
   const [rootValid, setRootValid] = createSignal(false)
   const listings = new Map<string, Promise<Array<{ name: string; type: "file" | "directory" }> | undefined>>()
+  const loads = createPriorityTaskQueue<Array<{ name: string; type: "file" | "directory" }> | undefined>(3)
   const advanced = new Set<string>()
   let tree: FileTree | undefined
   let container: HTMLDivElement | undefined
@@ -102,16 +104,21 @@ export function DialogSelectDirectoryV2(props: DialogSelectDirectoryV2Props) {
   })
   const currentSuggestions = createMemo(() => currentPickerSuggestions(suggestions(), input()))
 
-  async function load(path: string, generation: number, preload = true) {
+  async function load(path: string, generation: number, eager = false) {
     const key = path.replace(/\/+$/, "")
     setError(false)
     const absolute = absoluteTreePath(root(), key)
+    const existing = listings.get(key)
+    if (existing && !eager) loads.promote(`${generation}:${key}`)
     const request =
-      listings.get(key) ??
-      sdk.client.file
-        .list({ directory: absolute, path: "" })
-        .then((result) => result.data ?? [])
-        .catch(() => undefined)
+      existing ??
+      loads.schedule(`${generation}:${key}`, eager ? "background" : "user", () => {
+        if (!activeTreeNavigation(generation, navigation)) return Promise.resolve(undefined)
+        return sdk.client.file
+          .list({ directory: absolute, path: "" })
+          .then((result) => result.data ?? [])
+          .catch(() => undefined)
+      })
     listings.set(key, request)
     const nodes = await request
     if (!activeTreeNavigation(generation, navigation)) return false
@@ -121,8 +128,8 @@ export function DialogSelectDirectoryV2(props: DialogSelectDirectoryV2Props) {
       return false
     }
     tree?.batch(policy.entries(key, nodes).map((item) => ({ type: "add", path: item })))
-    if (preload && advanceTreePreload(advanced, key)) {
-      void Promise.all(preloadTreeDirectories(key, nodes).map((directory) => load(directory, generation, false)))
+    if (!eager && advanceTreePreload(advanced, key)) {
+      for (const directory of preloadTreeDirectories(key, nodes)) void load(directory, generation, true)
     }
     return true
   }

packages/app/src/components/directory-picker-domain.test.ts

@@ -15,6 +15,7 @@ import {
   treePathWithin,
   currentPickerSuggestions,
   createDirectorySearch,
+  createPriorityTaskQueue,
   displayPickerPath,
   pickerParent,
   pickerRoot,
@@ -168,6 +169,41 @@ test("advances preloading once for every expanded directory", () => {
   expect(advanceTreePreload(advanced, "repos/")).toBeTrue()
 })
 
+test("limits background tasks and prioritizes newly requested work", async () => {
+  const queue = createPriorityTaskQueue<void>(2)
+  const first = Promise.withResolvers<void>()
+  const second = Promise.withResolvers<void>()
+  const started: string[] = []
+  let active = 0
+  let maximum = 0
+  const task = (name: string, blocker?: Promise<void>) => async () => {
+    started.push(name)
+    active++
+    maximum = Math.max(maximum, active)
+    await blocker
+    active--
+  }
+
+  const running = [
+    queue.schedule("first", "background", task("first", first.promise)),
+    queue.schedule("second", "background", task("second", second.promise)),
+    queue.schedule("preload", "background", task("preload")),
+    queue.schedule("opened", "user", task("opened")),
+  ]
+  await Promise.resolve()
+  expect(started).toEqual(["first", "second"])
+
+  first.resolve()
+  await running[0]
+  await Promise.resolve()
+  expect(started).toEqual(["first", "second", "opened"])
+
+  second.resolve()
+  await Promise.all(running)
+  expect(started).toEqual(["first", "second", "opened", "preload"])
+  expect(maximum).toBe(2)
+})
+
 test("clamps bridged tree wheel scrolling", () => {
   expect(nextTreeScrollTop(100, 40, 500, 200)).toBe(140)
   expect(nextTreeScrollTop(10, -40, 500, 200)).toBe(0)

packages/app/src/components/directory-picker-domain.ts

@@ -138,6 +138,79 @@ export function activeTreeNavigation(request: number, current: number) {
   return request === current
 }
 
+export function createPriorityTaskQueue<T>(concurrency: number) {
+  type Job = {
+    key: string
+    priority: "user" | "background"
+    promise: Promise<T>
+    run: () => void
+  }
+
+  const jobs = new Map<string, Job>()
+  const user: Job[] = []
+  const background: Job[] = []
+  let active = 0
+
+  const drain = () => {
+    while (active < concurrency) {
+      const job = user.pop() ?? background.shift()
+      if (!job) return
+      active++
+      job.run()
+    }
+  }
+
+  const schedule = (key: string, priority: Job["priority"], task: () => Promise<T>) => {
+    const existing = jobs.get(key)
+    if (existing) {
+      if (priority === "user") promote(key)
+      return existing.promise
+    }
+
+    const deferred = Promise.withResolvers<T>()
+    const job: Job = {
+      key,
+      priority,
+      promise: deferred.promise,
+      run: () => {
+        const complete = () => {
+          active--
+          jobs.delete(key)
+          drain()
+        }
+        Promise.resolve()
+          .then(task)
+          .then(
+            (value) => {
+              complete()
+              deferred.resolve(value)
+            },
+            (error) => {
+              complete()
+              deferred.reject(error)
+            },
+          )
+      },
+    }
+    jobs.set(key, job)
+    ;(priority === "user" ? user : background).push(job)
+    drain()
+    return job.promise
+  }
+
+  const promote = (key: string) => {
+    const job = jobs.get(key)
+    if (!job || job.priority === "user") return
+    const index = background.indexOf(job)
+    if (index === -1) return
+    background.splice(index, 1)
+    job.priority = "user"
+    user.push(job)
+  }
+
+  return { schedule, promote }
+}
+
 export function nextTreeScrollTop(current: number, delta: number, scrollHeight: number, clientHeight: number) {
   return Math.min(Math.max(0, scrollHeight - clientHeight), Math.max(0, current + delta))
 }

packages/app/src/components/titlebar.tsx

@@ -41,6 +41,8 @@ import { tabHref, useTabs } from "@/context/tabs"
 import "./titlebar.css"
 import { useServerSDK } from "@/context/server-sdk"
 import { Session } from "@opencode-ai/sdk/v2"
+import { base64Encode } from "@opencode-ai/core/util/encode"
+import { createTabPromptState } from "@/context/prompt"
 
 type TauriDesktopWindow = {
   startDragging?: () => Promise<void>
@@ -419,22 +421,6 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                     if (next) tabs.select(next)
                   },
                 },
-                ...Array.from({ length: 9 }, (_, i) => {
-                  const index = i
-                  const number = index + 1
-                  return {
-                    id: `tab.${number}`,
-                    category: "tab",
-                    title: "",
-                    keybind: `mod+${number}`,
-                    disabled: layout.projects.list().length <= index,
-                    hidden: true,
-                    onSelect: () => {
-                      const tab = tabsStore[index]
-                      if (tab) tabs.select(tab)
-                    },
-                  }
-                }),
               ].filter((v) => v !== undefined)
             })
 
@@ -498,6 +484,7 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                       <For each={tabsStore}>
                         {(tab, i) => {
                           let ref!: HTMLDivElement
+                          useTabShortcut(i, () => tabs.select(tab))
 
                           const divider = () =>
                             i() !== 0 && (
@@ -523,13 +510,18 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                             )
                           }
 
+                          const sdk = createMemo(() => {
+                            const conn = server.list.find((s) => ServerConnection.key(s) === tab.server)
+                            if (!conn) return null
+                            const { sdk } = global.createServerCtx(conn)
+                            return sdk
+                          })
                           const [session] = createResource(
                             () => {
                               const id = tab.sessionId
-                              const conn = server.list.find((s) => ServerConnection.key(s) === tab.server)
-                              if (!conn) return null
-                              const { sdk } = global.createServerCtx(conn)
-                              return { id, sdk }
+                              const _sdk = sdk()
+                              if (!_sdk) return null
+                              return { id, sdk: _sdk }
                             },
                             ({ id, sdk }) =>
                               sdk.client.session
@@ -538,6 +530,18 @@ export function Titlebar(props: { update?: TitlebarUpdate }) {
                                 .catch(() => undefined),
                           )
 
+                          createEffect(() => {
+                            if (tab.type !== "session") return
+                            const _sdk = sdk()
+                            if (!_sdk) return
+                            const sess = session()
+                            if (!sess) return
+                            createTabPromptState(tabs, tab, _sdk.scope, {
+                              dir: base64Encode(sess.directory),
+                              id: sess.id,
+                            })
+                          })
+
                           return (
                             <>
                               {divider()}
@@ -835,6 +839,26 @@ function TitlebarUpdateIconButton(props: { state: TitlebarUpdatePillState }) {
   )
 }
 
+function useTabShortcut(index: () => number, onSelect: () => void) {
+  const command = useCommand()
+
+  command.register(() => {
+    const number = index() + 1
+    if (number > 9) return []
+
+    return [
+      {
+        id: `tab.${number}`,
+        category: "tab",
+        title: "",
+        keybind: `mod+${number}`,
+        hidden: true,
+        onSelect,
+      },
+    ]
+  })
+}
+
 function TabNavItem(props: {
   ref?: HTMLDivElement
   href: string
@@ -863,7 +887,7 @@ function TabNavItem(props: {
   return (
     <div
       ref={props.ref}
-      class="group relative flex h-7 min-w-24 max-w-60 flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
+      class="group relative flex h-7 w-56 shrink-0 flex-row items-center gap-1.5 overflow-hidden whitespace-nowrap rounded-[6px] bg-[var(--tab-bg)] px-1.5 [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-background-bg-layer-02)]"
       data-active={props.active}
       onMouseDown={(event) => {
         if (event.button !== 1) return
@@ -937,7 +961,7 @@ function DraftTabItem(props: {
     <div
       ref={props.ref}
       data-active={props.active}
-      class="group relative shrink-0 flex h-7 max-w-60 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--tab-bg)] pl-1.5 pr-8 whitespace-nowrap [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-overlay-simple-overlay-pressed)] focus-within:outline focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-[var(--v2-border-border-focus)]"
+      class="group relative flex h-7 w-56 shrink-0 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--tab-bg)] pl-1.5 pr-8 whitespace-nowrap [--tab-bg:var(--v2-background-bg-deep)] hover:[--tab-bg:var(--v2-background-bg-layer-02)] data-[active='true']:[--tab-bg:var(--v2-overlay-simple-overlay-pressed)] focus-within:outline focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-[var(--v2-border-border-focus)]"
       onMouseDown={(event) => {
         if (event.button !== 1) return
         closeTab(event)
@@ -982,7 +1006,7 @@ function NewSessionTabItem(props: { ref?: HTMLDivElement; href: string; title: s
   return (
     <div
       ref={props.ref}
-      class="group relative shrink-0 flex h-7 max-w-60 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--v2-overlay-simple-overlay-pressed)] pl-1.5 pr-8 whitespace-nowrap focus-within:outline focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-[var(--v2-border-border-focus)]"
+      class="group relative flex h-7 w-56 shrink-0 flex-row items-center gap-1.5 overflow-hidden rounded-[6px] bg-[var(--v2-overlay-simple-overlay-pressed)] pl-1.5 pr-8 whitespace-nowrap focus-within:outline focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-[var(--v2-border-border-focus)]"
       onMouseDown={(event) => {
         if (event.button !== 1) return
         closeTab(event)

packages/app/src/context/prompt.tsx

@@ -8,6 +8,10 @@ import { Persist, persisted } from "@/utils/persist"
 import { useServerSDK } from "./server-sdk"
 import type { ServerScope } from "@/utils/server-scope"
 import { useSDK } from "./sdk"
+import { useTabs, type Tab } from "./tabs"
+import { useServer } from "./server"
+import { requireServerKey } from "@/utils/session-route"
+import { useSettings } from "./settings"
 
 interface PartBase {
   content: string
@@ -258,14 +262,23 @@ export function createPromptState() {
   }
 }
 
+export const createTabPromptState = (
+  tabs: ReturnType<typeof useTabs>,
+  tab: Tab,
+  ...args: Parameters<typeof createPromptSession>
+) => tabs.state(tab, "prompt", () => createPromptSession(...args))
+
 export const { use: usePrompt, provider: PromptProvider } = createSimpleContext({
   name: "Prompt",
   gate: false,
   init: () => {
-    const params = useParams()
+    const params = useParams<{ serverKey?: string; id?: string }>()
     const sdk = useSDK()
     const [search] = useSearchParams<{ draftId?: string }>()
     const serverSDK = useServerSDK()
+    const server = useServer()
+    const tabs = useTabs()
+    const settings = useSettings()
     const cache = new Map<string, PromptCacheEntry>()
 
     const disposeAll = () => {
@@ -288,7 +301,25 @@ export const { use: usePrompt, provider: PromptProvider } = createSimpleContext(
     }
 
     const owner = getOwner()
+    const tab = createMemo<Tab | undefined>(() => {
+      if (!settings.general.newLayoutDesigns()) return
+      if (search.draftId) {
+        return tabs.store.find((item) => item.type === "draft" && item.draftID === search.draftId)
+      }
+      if (!params.id) return
+      const serverKey = params.serverKey ? requireServerKey(params.serverKey) : server.key
+      return (
+        tabs.store.find(
+          (item) => item.type === "session" && item.server === serverKey && item.sessionId === params.id,
+        ) ?? { type: "session", server: serverKey, sessionId: params.id }
+      )
+    })
     const load = (scope: Scope) => {
+      const current = tab()
+      if (current) {
+        return createTabPromptState(tabs, current, serverSDK().scope, scope)
+      }
+
       const key = scopeKey(scope)
       const existing = cache.get(key)
       if (existing) {

packages/app/src/context/tab-memory.ts

@@ -0,0 +1,33 @@
+import { createRoot, type Owner } from "solid-js"
+
+type Entry = {
+  value: unknown
+  dispose: VoidFunction
+}
+
+export function createTabMemory(owner: Owner | null) {
+  const entries = new Map<string, Map<string, Entry>>()
+
+  const remove = (key: string) => {
+    const state = entries.get(key)
+    if (!state) return
+    for (const entry of state.values()) entry.dispose()
+    entries.delete(key)
+  }
+
+  return {
+    ensure<T>(key: string, name: string, init: () => T) {
+      const state = entries.get(key) ?? new Map<string, Entry>()
+      if (!entries.has(key)) entries.set(key, state)
+      const existing = state.get(name)
+      if (existing) return existing.value as T
+      const entry = createRoot((dispose) => ({ value: init(), dispose }), owner)
+      state.set(name, entry)
+      return entry.value
+    },
+    remove,
+    dispose() {
+      for (const key of entries.keys()) remove(key)
+    },
+  }
+}

packages/app/src/context/tabs.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test"
+import { createRoot, getOwner, onCleanup } from "solid-js"
+import { createTabMemory } from "./tab-memory"
+
+describe("tab memory", () => {
+  test("keeps state until its tab is removed", () => {
+    createRoot((dispose) => {
+      const memory = createTabMemory(getOwner())
+      let disposed = 0
+      const first = memory.ensure("tab", "prompt", () => {
+        onCleanup(() => disposed++)
+        return { value: "prompt" }
+      })
+
+      expect(memory.ensure("tab", "prompt", () => ({ value: "other" }))).toBe(first)
+      expect(memory.ensure("other", "prompt", () => ({ value: "other" }))).not.toBe(first)
+
+      memory.remove("tab")
+      expect(disposed).toBe(1)
+      expect(memory.ensure("tab", "prompt", () => ({ value: "new" }))).not.toBe(first)
+      dispose()
+    })
+  })
+})

packages/app/src/context/tabs.tsx

@@ -3,12 +3,13 @@ import { createSimpleContext } from "@opencode-ai/ui/context"
 import { createStore, produce } from "solid-js/store"
 import { Persist, persisted, removePersisted, draftPersistedKeys } from "@/utils/persist"
 import { ServerConnection, useServer } from "./server"
-import { createEffect, startTransition } from "solid-js"
+import { createEffect, getOwner, onCleanup, startTransition } from "solid-js"
 import { useLocation, useNavigate, useParams } from "@solidjs/router"
 import { usePlatform } from "./platform"
 import { uuid } from "@/utils/uuid"
 import { SessionTabsRemovedDetail } from "@/components/titlebar-session-events"
 import { sessionHref } from "@/utils/session-route"
+import { createTabMemory } from "./tab-memory"
 
 export type SessionTab = {
   type: "session"
@@ -66,6 +67,7 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
     const params = useParams()
     const navigate = useNavigate()
     const location = useLocation()
+    const memory = createTabMemory(getOwner())
 
     const closing = new Set<string>()
     let recentWrite = 0
@@ -89,11 +91,18 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
       for (const key of draftPersistedKeys()) removePersisted(Persist.draft(draftID, key), platform)
     }
 
+    onCleanup(memory.dispose)
+
     createEffect(() => {
       if (!ready() || !recentReady()) return
       const servers = new Set(server.list.map(ServerConnection.key))
       const next = store.filter((tab) => servers.has(tab.server))
-      if (next.length !== store.length) setStore(() => next)
+      if (next.length !== store.length) {
+        for (const tab of store) {
+          if (!servers.has(tab.server)) memory.remove(tabKey(tab))
+        }
+        setStore(() => next)
+      }
       if (recent.key && !next.some((tab) => tabKey(tab) === recent.key)) setRecentKey(undefined)
     })
 
@@ -151,6 +160,7 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
           if (recent.key === `draft:${draftID}`) setRecentKey(tabKey(next))
           if (active) navigateTab(next)
         })
+        memory.remove(`draft:${draftID}`)
         removeDraftPersisted(draftID)
       },
       removeTab: (index: number) => {
@@ -170,12 +180,14 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
           if (nextTab) navigateTab(nextTab)
           else navigate("/")
         }).finally(() => closing.delete(key))
+        memory.remove(key)
         if (draftID) removeDraftPersisted(draftID)
       },
       removeServer(key: ServerConnection.Key) {
         const drafts = store.flatMap((tab) => (tab.type === "draft" && tab.server === key ? [tab.draftID] : []))
         const removed = store.filter((tab) => tab.server === key).map(tabKey)
         setStore((tabs) => tabs.filter((tab) => tab.server !== key))
+        for (const key of removed) memory.remove(key)
         if (recent.key && removed.includes(recent.key)) setRecentKey(undefined)
         for (const draftID of drafts) removeDraftPersisted(draftID)
         if (server.key === key) navigate("/")
@@ -227,6 +239,7 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
           )
           if (recent.key && removed.includes(recent.key)) setRecentKey(undefined)
         })
+        for (const key of removed) memory.remove(key)
       },
       select: navigateTab,
       remember(tab: Tab) {
@@ -246,6 +259,9 @@ export const { use: useTabs, provider: TabsProvider } = createSimpleContext({
         }
         navigate("/")
       },
+      state<T>(tab: Tab, name: string, init: () => T) {
+        return memory.ensure(tabKey(tab), name, init)
+      },
     }
 
     return { ...actions, store, ready, recentReady }

packages/app/test-browser/prompt-persistence.test.ts

@@ -20,6 +20,8 @@ beforeAll(async () => {
   mock.module("@solidjs/router", () => ({
     useParams: () => ({}),
     useSearchParams: () => [{}],
+    useLocation: () => ({ pathname: "", query: {} }),
+    useNavigate: () => () => undefined,
   }))
   mock.module("@opencode-ai/ui/context", () => ({
     createSimpleContext: () => ({

packages/core/package.json

@@ -91,6 +91,7 @@
     "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
     "@opencode-ai/effect-sqlite-node": "workspace:*",
     "@opencode-ai/llm": "workspace:*",
+    "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/context-async-hooks": "2.6.1",

packages/core/src/agent.ts

@@ -1,46 +1,17 @@
 export * as AgentV2 from "./agent"
 
-import { Array, Context, Effect, Layer, Schema, Scope, Types } from "effect"
-import { ModelV2 } from "./model"
-import { PermissionSchema } from "./permission/schema"
-import { ProviderV2 } from "./provider"
-import { PositiveInt } from "./schema"
+import { Array, Context, Effect, Layer, Types } from "effect"
+import { Agent } from "@opencode-ai/schema/agent"
 import { State } from "./state"
 
-export const ID = Schema.String.pipe(Schema.brand("AgentV2.ID"))
+export const ID = Agent.ID
 export type ID = typeof ID.Type
 export const defaultID = ID.make("build")
 
-export const Color = Schema.Union([
-  Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
-  Schema.Literals(["primary", "secondary", "accent", "success", "warning", "error", "info"]),
-])
+export const Color = Agent.Color
 
-export class Info extends Schema.Class<Info>("AgentV2.Info")({
-  id: ID,
-  model: ModelV2.Ref.pipe(Schema.optional),
-  request: ProviderV2.Request,
-  system: Schema.String.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  mode: Schema.Literals(["subagent", "primary", "all"]),
-  hidden: Schema.Boolean,
-  color: Color.pipe(Schema.optional),
-  steps: PositiveInt.pipe(Schema.optional),
-  permissions: PermissionSchema.Ruleset,
-}) {
-  static empty(id: ID) {
-    return new Info({
-      id,
-      request: {
-        headers: {},
-        body: {},
-      },
-      mode: "all",
-      hidden: false,
-      permissions: [],
-    })
-  }
-}
+export const Info = Agent.Info
+export type Info = Agent.Info
 
 export interface Selection {
   readonly id: ID

packages/core/src/catalog.ts

@@ -73,7 +73,7 @@ export const layer = Layer.effect(
       if (provider.disabled) return false
       if (typeof provider.request.body.apiKey === "string") return true
       if (integration?.connections.length) return true
-      return !integration
+      return provider.integrationID === undefined && !integration
     }
 
     const projectModel = (model: ModelV2.Info, provider: ProviderV2.Info) => {
@@ -89,7 +89,7 @@ export const layer = Layer.effect(
         ...ModelRequest.merge({ ...provider.request, generation: {}, options: {} }, model.request),
         variant: model.request.variant,
       }
-      return new ModelV2.Info({
+      return ModelV2.Info.make({
         ...model,
         api,
         request,
@@ -184,7 +184,7 @@ export const layer = Layer.effect(
         available: Effect.fn("CatalogV2.provider.available")(function* () {
           const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]))
           return (yield* result.provider.all()).filter((provider) =>
-            available(provider, active.get(Integration.ID.make(provider.id))),
+            available(provider, active.get(provider.integrationID ?? Integration.ID.make(provider.id))),
           )
         }),
       },

packages/core/src/command.ts

@@ -1,17 +1,11 @@
 export * as CommandV2 from "./command"
 
-import { Context, Effect, Layer, Schema, Types } from "effect"
-import { ModelV2 } from "./model"
+import { Context, Effect, Layer, Types } from "effect"
+import { Command } from "@opencode-ai/schema/command"
 import { State } from "./state"
 
-export class Info extends Schema.Class<Info>("CommandV2.Info")({
-  name: Schema.String,
-  template: Schema.String,
-  description: Schema.String.pipe(Schema.optional),
-  agent: Schema.String.pipe(Schema.optional),
-  model: ModelV2.Ref.pipe(Schema.optional),
-  subtask: Schema.Boolean.pipe(Schema.optional),
-}) {}
+export const Info = Command.Info
+export type Info = Command.Info
 
 export type Data = {
   commands: Map<string, Types.DeepMutable<Info>>
@@ -40,7 +34,7 @@ export const layer = Layer.effect(
         list: () => Array.from(draft.commands.values()) as Info[],
         get: (name) => draft.commands.get(name),
         update: (name, update) => {
-          const current = draft.commands.get(name) ?? (new Info({ name, template: "" }) as Types.DeepMutable<Info>)
+          const current = draft.commands.get(name) ?? ({ name, template: "" } as Types.DeepMutable<Info>)
           if (!draft.commands.has(name)) draft.commands.set(name, current)
           update(current)
           current.name = name

packages/core/src/config.ts

@@ -3,10 +3,10 @@ export * as Config from "./config"
 import path from "path"
 import { type ParseError, parse } from "jsonc-parser"
 import { Context, Effect, Layer, Option, Schema } from "effect"
+import { Permission } from "@opencode-ai/schema/permission"
 import { FSUtil } from "./fs-util"
 import { Global } from "./global"
 import { Location } from "./location"
-import { PermissionSchema } from "./permission/schema"
 import { Policy } from "./policy"
 import { AbsolutePath } from "./schema"
 import { ConfigAgent } from "./config/agent"
@@ -56,7 +56,7 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   username: Schema.String.pipe(Schema.optional).annotate({
     description: "Username displayed in conversations and used for telemetry identity",
   }),
-  permissions: PermissionSchema.Ruleset.pipe(Schema.optional).annotate({
+  permissions: Permission.Ruleset.pipe(Schema.optional).annotate({
     description: "Ordered tool permission rules applied to agent tool use",
   }),
   agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(Schema.optional).annotate({

packages/core/src/config/agent.ts

@@ -1,7 +1,7 @@
 export * as ConfigAgent from "./agent"
 
 import { Schema } from "effect"
-import { PermissionSchema } from "../permission/schema"
+import { Permission } from "@opencode-ai/schema/permission"
 import { ConfigProvider } from "./provider"
 import { PositiveInt } from "../schema"
 
@@ -21,5 +21,5 @@ export class Info extends Schema.Class<Info>("ConfigV2.Agent")({
   color: Color.pipe(Schema.optional),
   steps: PositiveInt.pipe(Schema.optional),
   disabled: Schema.Boolean.pipe(Schema.optional),
-  permissions: PermissionSchema.Ruleset.pipe(Schema.optional),
+  permissions: Permission.Ruleset.pipe(Schema.optional),
 }) {}

packages/core/src/config/plugin/reference.ts

@@ -28,7 +28,7 @@ export const Plugin = define({
             entries.set(
               name,
               local(entry)
-                ? new Reference.LocalSource({
+                ? Reference.LocalSource.make({
                     type: "local",
                     path: AbsolutePath.make(
                       localPath(directory, global.home, typeof entry === "string" ? entry : entry.path),
@@ -36,7 +36,7 @@ export const Plugin = define({
                     description: typeof entry === "string" ? undefined : entry.description,
                     hidden: typeof entry === "string" ? undefined : entry.hidden,
                   })
-                : new Reference.GitSource({
+                : Reference.GitSource.make({
                     type: "git",
                     repository: typeof entry === "string" ? entry : entry.repository,
                     branch: typeof entry === "string" ? undefined : entry.branch,

packages/core/src/config/plugin/skill.ts

@@ -22,20 +22,23 @@ export const Plugin = define({
         const items = entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
         for (const directory of directories) {
           draft.source(
-            new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
+            SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
           )
           draft.source(
-            new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }),
+            SkillV2.DirectorySource.make({
+              type: "directory",
+              path: AbsolutePath.make(path.join(directory, "skills")),
+            }),
           )
         }
         for (const item of items) {
           if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
-            draft.source(new SkillV2.UrlSource({ type: "url", url: item }))
+            draft.source(SkillV2.UrlSource.make({ type: "url", url: item }))
             continue
           }
           const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
           draft.source(
-            new SkillV2.DirectorySource({
+            SkillV2.DirectorySource.make({
               type: "directory",
               path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
             }),

packages/core/src/credential.ts

@@ -2,41 +2,26 @@ export * as Credential from "./credential"
 
 import { asc, eq } from "drizzle-orm"
 import { Context, Effect, Layer, Schema } from "effect"
+import { Credential } from "@opencode-ai/schema/credential"
+import { Integration } from "@opencode-ai/schema/integration"
 import { Database } from "./database/database"
-import { IntegrationSchema } from "./integration/schema"
-import { NonNegativeInt, withStatics } from "./schema"
-import { Identifier } from "./util/identifier"
 import { CredentialTable } from "./credential/sql"
 
-export const ID = Schema.String.pipe(
-  Schema.brand("Credential.ID"),
-  withStatics((schema) => ({ create: () => schema.make("cred_" + Identifier.ascending()) })),
-)
-export type ID = typeof ID.Type
+export const ID = Credential.ID
+export type ID = Credential.ID
 
-export class OAuth extends Schema.Class<OAuth>("Credential.OAuth")({
-  type: Schema.Literal("oauth"),
-  methodID: IntegrationSchema.MethodID,
-  refresh: Schema.String,
-  access: Schema.String,
-  expires: NonNegativeInt,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
+export const OAuth = Credential.OAuth
+export type OAuth = Credential.OAuth
 
-export class Key extends Schema.Class<Key>("Credential.Key")({
-  type: Schema.Literal("key"),
-  key: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
+export const Key = Credential.Key
+export type Key = Credential.Key
 
-export const Value = Schema.Union([OAuth, Key])
-  .pipe(Schema.toTaggedUnion("type"))
-  .annotate({ identifier: "Credential.Value" })
-export type Value = Schema.Schema.Type<typeof Value>
+export const Value = Credential.Value
+export type Value = Credential.Value
 
 export class Info extends Schema.Class<Info>("Credential.Info")({
   id: ID,
-  integrationID: IntegrationSchema.ID,
+  integrationID: Integration.ID,
   label: Schema.String,
   value: Value,
 }) {}
@@ -45,12 +30,12 @@ export interface Interface {
   /** Returns every stored credential. */
   readonly all: () => Effect.Effect<Info[]>
   /** Returns stored credentials belonging to one integration. */
-  readonly list: (integrationID: IntegrationSchema.ID) => Effect.Effect<Info[]>
+  readonly list: (integrationID: Integration.ID) => Effect.Effect<Info[]>
   /** Returns one stored credential by ID. */
   readonly get: (id: ID) => Effect.Effect<Info | undefined>
   /** Replaces any credential for an integration and returns the new record. */
   readonly create: (input: {
-    readonly integrationID: IntegrationSchema.ID
+    readonly integrationID: Integration.ID
     readonly value: Value
     readonly label?: string
   }) => Effect.Effect<Info>

packages/core/src/credential/sql.ts

@@ -1,11 +1,10 @@
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core"
 import { Timestamps } from "../database/schema.sql"
-import type { IntegrationSchema } from "../integration/schema"
 import type { Credential } from "../credential"
 
 export const CredentialTable = sqliteTable("credential", {
   id: text().$type<Credential.ID>().primaryKey(),
-  integration_id: text().$type<IntegrationSchema.ID>(),
+  integration_id: text().$type<Credential.Info["integrationID"]>(),
   label: text().notNull(),
   value: text({ mode: "json" }).$type<Credential.Value>().notNull(),
   connector_id: text(),

packages/core/src/event-manifest.ts

@@ -0,0 +1,9 @@
+export * as EventManifest from "./event-manifest"
+
+import { Event } from "@opencode-ai/schema/event"
+import { SessionEvent } from "@opencode-ai/schema/session-event"
+import { SessionV1 } from "@opencode-ai/schema/session-v1"
+
+export const Definitions = Event.inventory(...SessionV1.Events, ...SessionEvent.Definitions)
+export const Latest = Event.latest(Definitions)
+export const Durable = Event.durable(Definitions)

packages/core/src/event.ts

@@ -1,47 +1,19 @@
 export * as EventV2 from "./event"
 
 import { Cause, Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
+import { Event } from "@opencode-ai/schema/event"
+import type { Data, Definition, Payload } from "@opencode-ai/schema/event"
 import { and, asc, eq, gt } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
-import { externalID, type ExternalID, withStatics } from "./schema"
-import { Identifier } from "./util/identifier"
 import { LayerNode } from "./effect/layer-node"
 import { isDeepStrictEqual } from "node:util"
+import { EventManifest } from "./event-manifest"
 
-export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(
-  Schema.brand("Event.ID"),
-  withStatics((schema) => ({
-    create: () => schema.make("evt_" + Identifier.ascending()),
-    fromExternal: (input: ExternalID) => schema.make(externalID("evt", input)),
-  })),
-)
-export type ID = typeof ID.Type
-
-export type Definition<Type extends string = string, DataSchema extends Schema.Top = Schema.Top> = {
-  readonly type: Type
-  readonly durable?: {
-    readonly version: number
-    readonly aggregate: string
-  }
-  readonly data: DataSchema
-}
-
-export type Data<D extends Definition> = Schema.Schema.Type<D["data"]>
-
-export type Payload<D extends Definition = Definition> = {
-  readonly id: ID
-  readonly type: D["type"]
-  readonly data: Data<D>
-  readonly durable?: {
-    readonly aggregateID: string
-    readonly seq: number
-    readonly version: number
-  }
-  readonly location?: Location.Ref
-  readonly metadata?: Record<string, unknown>
-}
+export const ID = Event.ID
+export type ID = import("@opencode-ai/schema/event").ID
+export type { Data, Definition, Payload } from "@opencode-ai/schema/event"
 
 export type Subscriber<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
 export type Unsubscribe = Effect.Effect<void>
@@ -75,52 +47,8 @@ export class InvalidDurableEventError extends Schema.TaggedErrorClass<InvalidDur
   },
 ) {}
 
-export function versionedType(type: string, version: number) {
-  return `${type}.${version}`
-}
-
-export const registry = new Map<string, Definition>()
-const durableRegistry = new Map<string, Definition>()
-
-export function define<const Type extends string, Fields extends Schema.Struct.Fields>(input: {
-  readonly type: Type
-  readonly durable?: {
-    readonly version: number
-    readonly aggregate: string
-  }
-  readonly schema: Fields
-}): Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> & Definition<Type, Schema.Struct<Fields>> {
-  const Data = Schema.Struct(input.schema)
-  const Payload = Schema.Struct({
-    id: ID,
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    type: Schema.Literal(input.type),
-    durable: Schema.optional(Schema.Struct({ aggregateID: Schema.String, seq: Schema.Number, version: Schema.Number })),
-    location: Schema.optional(Location.Ref),
-    data: Data,
-  }).annotate({ identifier: input.type })
-
-  const definition = Object.assign(Payload, {
-    type: input.type,
-    ...(input.durable === undefined ? {} : { durable: input.durable }),
-    data: Data,
-  })
-  const existing = registry.get(input.type)
-  if (
-    input.durable === undefined ||
-    existing?.durable === undefined ||
-    input.durable.version >= existing.durable.version
-  ) {
-    registry.set(input.type, definition)
-  }
-  if (input.durable) durableRegistry.set(versionedType(input.type, input.durable.version), definition)
-  return definition as Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> &
-    Definition<Type, Schema.Struct<Fields>>
-}
-
-export function definitions() {
-  return registry.values().toArray()
-}
+export const define = Event.define
+export const versionedType = Event.versionedType
 
 export interface PublishOptions {
   readonly id?: ID
@@ -158,18 +86,21 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Ev
 
 export interface LayerOptions {
   readonly beforeAggregateRead?: (aggregateID: string) => Effect.Effect<void>
+  readonly definitions?: ReadonlyArray<Definition>
 }
 
 export const layerWith = (options?: LayerOptions) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
+      const durableDefinitions = Event.durable([...EventManifest.Definitions, ...(options?.definitions ?? [])])
       const pubsub = {
         all: yield* PubSub.unbounded<Payload>(),
         durable: new Map<string, Set<PubSub.PubSub<void>>>(),
         typed: new Map<string, PubSub.PubSub<Payload>>(),
       }
       const projectors = new Map<string, Subscriber[]>()
+      // Projectors intentionally retain type-only dispatch. Exact type+version dispatch is a separate replay design.
       const listeners = new Array<Subscriber>()
       const { db } = yield* Database.Service
 
@@ -195,6 +126,7 @@ export const layerWith = (options?: LayerOptions) =>
       )
 
       function commitDurableEvent(
+        definition: Definition,
         event: Payload,
         input?: {
           readonly seq: number
@@ -205,7 +137,6 @@ export const layerWith = (options?: LayerOptions) =>
         commit?: (seq: number) => Effect.Effect<void>,
       ) {
         return Effect.gen(function* () {
-          const definition = registry.get(event.type)
           const durable = definition?.durable
           if (durable) {
             const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
@@ -239,9 +170,10 @@ export const layerWith = (options?: LayerOptions) =>
                             .get()
                             .pipe(Effect.orDie)
                           const latest = row?.seq ?? -1
-                          const encoded = Schema.encodeUnknownSync(
-                            definition.data as Schema.Codec<unknown, unknown, never, never>,
-                          )(event.data) as Record<string, unknown>
+                          const encoded = Schema.encodeUnknownSync(definition.data)(event.data) as Record<
+                            string,
+                            unknown
+                          >
                           if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
                             yield* Effect.die(
                               new InvalidDurableEventError({
@@ -357,9 +289,8 @@ export const layerWith = (options?: LayerOptions) =>
         })
       }
 
-      function publishEvent<D extends Definition>(event: Payload<D>, commit?: PublishOptions["commit"]) {
+      function publishEvent<D extends Definition>(definition: D, event: Payload<D>, commit?: PublishOptions["commit"]) {
         return Effect.gen(function* () {
-          const definition = registry.get(event.type)
           if (!definition?.durable && commit)
             return yield* Effect.die(
               new InvalidDurableEventError({
@@ -368,7 +299,7 @@ export const layerWith = (options?: LayerOptions) =>
               }),
             )
           if (definition?.durable) {
-            const committed = yield* commitDurableEvent(event as Payload, undefined, commit)
+            const committed = yield* commitDurableEvent(definition, event as Payload, undefined, commit)
             if (committed) {
               event = {
                 ...event,
@@ -417,6 +348,7 @@ export const layerWith = (options?: LayerOptions) =>
               ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID }
               : undefined)
           return yield* publishEvent(
+            definition,
             {
               id: options?.id ?? ID.create(),
               ...(options?.metadata ? { metadata: options.metadata } : {}),
@@ -434,7 +366,7 @@ export const layerWith = (options?: LayerOptions) =>
         options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },
       ) {
         return Effect.gen(function* () {
-          const definition = durableRegistry.get(event.type)
+          const definition = durableDefinitions.get(event.type)
           if (!definition?.durable) {
             yield* Effect.die(
               new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` }),
@@ -443,11 +375,9 @@ export const layerWith = (options?: LayerOptions) =>
             const payload = {
               id: event.id,
               type: definition.type,
-              data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(
-                event.data,
-              ),
+              data: Schema.decodeUnknownSync(definition.data)(event.data),
             } as Payload
-            const committed = yield* commitDurableEvent(payload, {
+            const committed = yield* commitDurableEvent(definition, payload, {
               seq: event.seq,
               aggregateID: event.aggregateID,
               ownerID: options?.ownerID,
@@ -531,8 +461,8 @@ export const layerWith = (options?: LayerOptions) =>
 
       const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(pubsub.all)
 
-      const decodeSerializedEvent = (event: SerializedEvent): Payload => {
-        const definition = durableRegistry.get(event.type)
+      const decodeSerializedEvent = (event: SerializedEvent) => {
+        const definition = durableDefinitions.get(event.type)
         if (!definition?.durable) {
           throw new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` })
         }
@@ -540,7 +470,7 @@ export const layerWith = (options?: LayerOptions) =>
           id: event.id,
           type: definition.type,
           durable: { aggregateID: event.aggregateID, seq: event.seq, version: definition.durable.version },
-          data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(event.data),
+          data: Schema.decodeUnknownSync(definition.data)(event.data),
         }
       }
 

packages/core/src/filesystem.ts

@@ -7,8 +7,8 @@ import { FSUtil } from "./fs-util"
 import { Location } from "./location"
 import { PositiveInt, RelativePath } from "./schema"
 import { FileSystemSearch } from "./filesystem/search"
-import { Entry, Match } from "./filesystem/schema"
-export { Entry, Match, Submatch } from "./filesystem/schema"
+import { Entry, Match } from "@opencode-ai/schema/filesystem"
+export { Entry, Match, Submatch } from "@opencode-ai/schema/filesystem"
 
 export const ReadInput = Schema.Struct({
   path: RelativePath,
@@ -108,10 +108,9 @@ const baseLayer = Layer.effect(
                 const absolute = path.join(target.absolute, item.name)
                 const relative = path.relative(target.directory, absolute)
                 return [
-                  new Entry({
+                  Entry.make({
                     path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
                     type: item.type,
-                    mime: item.type === "directory" ? "application/x-directory" : FSUtil.mimeType(absolute),
                   }),
                 ]
               })

packages/core/src/filesystem/schema.ts

@@ -1,23 +0,0 @@
-import { Schema } from "effect"
-import { NonNegativeInt, PositiveInt, RelativePath } from "../schema"
-
-export class Entry extends Schema.Class<Entry>("FileSystem.Entry")({
-  path: RelativePath,
-  type: Schema.Literals(["file", "directory"]),
-  mime: Schema.String,
-}) {}
-
-export const Submatch = Schema.Struct({
-  text: Schema.String,
-  start: NonNegativeInt,
-  end: NonNegativeInt,
-})
-export type Submatch = typeof Submatch.Type
-
-export class Match extends Schema.Class<Match>("FileSystem.Match")({
-  entry: Entry,
-  line: PositiveInt,
-  offset: NonNegativeInt,
-  text: Schema.String,
-  submatches: Schema.Array(Submatch),
-}) {}

packages/core/src/filesystem/search.ts

@@ -59,12 +59,11 @@ export const ripgrepLayer = Layer.effect(
             })
             .pipe(
               Effect.map((result) =>
-                result.map(
-                  (entry) =>
-                    new FileSystem.Entry({
-                      ...entry,
-                      path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
-                    }),
+                result.map((entry) =>
+                  FileSystem.Entry.make({
+                    ...entry,
+                    path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
+                  }),
                 ),
               ),
               Effect.orDie,
@@ -85,15 +84,14 @@ export const ripgrepLayer = Layer.effect(
             })
             .pipe(
               Effect.map((result) =>
-                result.map(
-                  (match) =>
-                    new FileSystem.Match({
-                      ...match,
-                      entry: new FileSystem.Entry({
-                        ...match.entry,
-                        path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, match.entry.path))),
-                      }),
+                result.map((match) =>
+                  FileSystem.Match.make({
+                    ...match,
+                    entry: FileSystem.Entry.make({
+                      ...match.entry,
+                      path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, match.entry.path))),
                     }),
+                  }),
                 ),
               ),
               Effect.orDie,
@@ -110,12 +108,9 @@ export const ripgrepLayer = Layer.effect(
           return fuzzysort.go(input.query, items, { limit: input.limit ?? 50 }).map((item) => {
             const relative = item.target
             const type = relative.endsWith(path.sep) ? ("directory" as const) : ("file" as const)
-            const clean = type === "directory" ? relative.slice(0, -path.sep.length) : relative
-            const absolute = path.resolve(location.directory, clean)
-            return new FileSystem.Entry({
+            return FileSystem.Entry.make({
               path: RelativePath.make(relative),
               type,
-              mime: type === "directory" ? "application/x-directory" : FSUtil.mimeType(absolute),
             })
           })
         }),
@@ -148,14 +143,12 @@ export const fffLayer = Layer.effect(
             pageSize: input.limit,
           })
           if (!found.ok) throw found.error
-          return found.value.items.map((item) => {
-            const absolute = path.resolve(location.directory, item.relativePath)
-            return new FileSystem.Entry({
+          return found.value.items.map((item) =>
+            FileSystem.Entry.make({
               path: RelativePath.make(item.relativePath.replaceAll("\\", "/")),
               type: "file",
-              mime: FSUtil.mimeType(absolute),
-            })
-          })
+            }),
+          )
         }),
       grep: (input) =>
         Effect.sync(() => {
@@ -169,11 +162,10 @@ export const fffLayer = Layer.effect(
           if (!found.ok) throw found.error
           return found.value.items.map((match) => {
             const bytes = Buffer.from(match.lineContent)
-            return new FileSystem.Match({
-              entry: new FileSystem.Entry({
+            return FileSystem.Match.make({
+              entry: FileSystem.Entry.make({
                 path: RelativePath.make(match.relativePath.replaceAll("\\", "/")),
                 type: "file",
-                mime: FSUtil.mimeType(match.relativePath),
               }),
               line: match.lineNumber,
               offset: match.byteOffset,
@@ -220,11 +212,9 @@ export const fffLayer = Layer.effect(
             .sort((a, b) => b.score - a.score || a.path.length - b.path.length)
             .map((item) => {
               const relative = item.path.replaceAll("\\", "/").replace(/\/$/, "")
-              const absolute = path.resolve(location.directory, relative)
-              return new FileSystem.Entry({
+              return FileSystem.Entry.make({
                 path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
                 type: item.type,
-                mime: item.type === "directory" ? "application/x-directory" : FSUtil.mimeType(absolute),
               })
             })
         }),

packages/core/src/fs-util.ts

@@ -14,7 +14,12 @@ export namespace FSUtil {
   export class FileSystemError extends Schema.TaggedErrorClass<FileSystemError>()("FileSystemError", {
     method: Schema.String,
     cause: Schema.optional(Schema.Defect()),
-  }) {}
+  }) {
+    override get message() {
+      const detail = this.cause instanceof Error ? this.cause.message : this.cause && String(this.cause)
+      return `Filesystem operation failed: ${this.method}${detail ? `: ${detail}` : ""}`
+    }
+  }
 
   export type Error = PlatformError | FileSystemError
 

packages/core/src/id/id.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from "crypto"
+import { create as createIdentifier } from "@opencode-ai/schema/identifier"
 
 const prefixes = {
   job: "job",
@@ -13,12 +13,6 @@ const prefixes = {
   workspace: "wrk",
 } as const
 
-const LENGTH = 26
-
-// State for monotonic ID generation
-let lastTimestamp = 0
-let counter = 0
-
 export function ascending(prefix: keyof typeof prefixes, given?: string) {
   return generateID(prefix, "ascending", given)
 }
@@ -38,35 +32,8 @@ function generateID(prefix: keyof typeof prefixes, direction: "descending" | "as
   return given
 }
 
-function randomBase62(length: number): string {
-  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-  let result = ""
-  const bytes = randomBytes(length)
-  for (let i = 0; i < length; i++) {
-    result += chars[bytes[i] % 62]
-  }
-  return result
-}
-
 export function create(prefix: string, direction: "descending" | "ascending", timestamp?: number): string {
-  const currentTimestamp = timestamp ?? Date.now()
-
-  if (currentTimestamp !== lastTimestamp) {
-    lastTimestamp = currentTimestamp
-    counter = 0
-  }
-  counter++
-
-  let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-  now = direction === "descending" ? ~now : now
-
-  const timeBytes = Buffer.alloc(6)
-  for (let i = 0; i < 6; i++) {
-    timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-  }
-
-  return prefix + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
+  return prefix + "_" + createIdentifier(direction === "descending", timestamp)
 }
 
 /** Extract timestamp from an ascending ID. Does not work with descending IDs. */

packages/core/src/integration.ts

@@ -14,19 +14,19 @@ import {
   SynchronizedRef,
   Types,
 } from "effect"
+import { Integration } from "@opencode-ai/schema/integration"
 import { Credential } from "./credential"
-import { IntegrationSchema } from "./integration/schema"
 import { withStatics } from "./schema"
 import { State } from "./state"
 import { Identifier } from "./util/identifier"
 import { EventV2 } from "./event"
 import { IntegrationConnection } from "./integration/connection"
 
-export const ID = IntegrationSchema.ID
-export type ID = IntegrationSchema.ID
+export const ID = Integration.ID
+export type ID = Integration.ID
 
-export const MethodID = IntegrationSchema.MethodID
-export type MethodID = IntegrationSchema.MethodID
+export const MethodID = Integration.MethodID
+export type MethodID = Integration.MethodID
 
 export const AttemptID = Schema.String.pipe(
   Schema.brand("Integration.AttemptID"),
@@ -34,64 +34,29 @@ export const AttemptID = Schema.String.pipe(
 )
 export type AttemptID = typeof AttemptID.Type
 
-export const When = Schema.Struct({
-  key: Schema.String,
-  op: Schema.Literals(["eq", "neq"]),
-  value: Schema.String,
-}).annotate({ identifier: "Integration.When" })
-export type When = typeof When.Type
+export const When = Integration.When
+export type When = Integration.When
 
-export const TextPrompt = Schema.Struct({
-  type: Schema.Literal("text"),
-  key: Schema.String,
-  message: Schema.String,
-  placeholder: Schema.optional(Schema.String),
-  when: Schema.optional(When),
-}).annotate({ identifier: "Integration.TextPrompt" })
-export type TextPrompt = typeof TextPrompt.Type
+export const TextPrompt = Integration.TextPrompt
+export type TextPrompt = Integration.TextPrompt
 
-export const SelectPrompt = Schema.Struct({
-  type: Schema.Literal("select"),
-  key: Schema.String,
-  message: Schema.String,
-  options: Schema.mutable(
-    Schema.Array(
-      Schema.Struct({
-        label: Schema.String,
-        value: Schema.String,
-        hint: Schema.optional(Schema.String),
-      }),
-    ),
-  ),
-  when: Schema.optional(When),
-}).annotate({ identifier: "Integration.SelectPrompt" })
-export type SelectPrompt = typeof SelectPrompt.Type
+export const SelectPrompt = Integration.SelectPrompt
+export type SelectPrompt = Integration.SelectPrompt
 
-export const Prompt = Schema.Union([TextPrompt, SelectPrompt]).pipe(Schema.toTaggedUnion("type"))
-export type Prompt = typeof Prompt.Type
+export const Prompt = Integration.Prompt
+export type Prompt = Integration.Prompt
 
-export const OAuthMethod = Schema.Struct({
-  id: MethodID,
-  type: Schema.Literal("oauth"),
-  label: Schema.String,
-  prompts: Schema.optional(Schema.mutable(Schema.Array(Prompt))),
-}).annotate({ identifier: "Integration.OAuthMethod" })
-export type OAuthMethod = typeof OAuthMethod.Type
+export const OAuthMethod = Integration.OAuthMethod
+export type OAuthMethod = Integration.OAuthMethod
 
-export const KeyMethod = Schema.Struct({
-  type: Schema.Literal("key"),
-  label: Schema.optional(Schema.String),
-}).annotate({ identifier: "Integration.KeyMethod" })
-export type KeyMethod = typeof KeyMethod.Type
+export const KeyMethod = Integration.KeyMethod
+export type KeyMethod = Integration.KeyMethod
 
-export const EnvMethod = Schema.Struct({
-  type: Schema.Literal("env"),
-  names: Schema.mutable(Schema.Array(Schema.String)),
-}).annotate({ identifier: "Integration.EnvMethod" })
-export type EnvMethod = typeof EnvMethod.Type
+export const EnvMethod = Integration.EnvMethod
+export type EnvMethod = Integration.EnvMethod
 
-export const Method = Schema.Union([OAuthMethod, KeyMethod, EnvMethod]).pipe(Schema.toTaggedUnion("type"))
-export type Method = typeof Method.Type
+export const Method = Integration.Method
+export type Method = Integration.Method
 
 export class Info extends Schema.Class<Info>("Integration.Info")({
   id: ID,
@@ -100,7 +65,8 @@ export class Info extends Schema.Class<Info>("Integration.Info")({
   connections: Schema.mutable(Schema.Array(IntegrationConnection.Info)),
 }) {}
 
-export type Inputs = Readonly<{ [key: string]: string }>
+export const Inputs = Integration.Inputs
+export type Inputs = Integration.Inputs
 
 export type OAuthAuthorization = {
   readonly url: string
@@ -108,11 +74,11 @@ export type OAuthAuthorization = {
 } & (
   | {
       readonly mode: "auto"
-      readonly callback: Effect.Effect<Credential.Value, unknown>
+      readonly callback: Effect.Effect<Credential.OAuth, unknown>
     }
   | {
       readonly mode: "code"
-      readonly callback: (code: string) => Effect.Effect<Credential.Value, unknown>
+      readonly callback: (code: string) => Effect.Effect<Credential.OAuth, unknown>
     }
 )
 
@@ -121,6 +87,7 @@ export interface OAuthImplementation {
   readonly method: OAuthMethod
   readonly authorize: (inputs: Inputs) => Effect.Effect<OAuthAuthorization, unknown, Scope.Scope>
   readonly refresh?: (credential: Credential.OAuth) => Effect.Effect<Credential.OAuth, unknown>
+  readonly label?: (credential: Credential.OAuth) => string | undefined
 }
 
 export interface KeyImplementation {
@@ -135,10 +102,6 @@ export interface EnvImplementation {
 
 export type Implementation = OAuthImplementation | KeyImplementation | EnvImplementation
 
-function isOAuthImplementation(implementation: Implementation): implementation is OAuthImplementation {
-  return implementation.method.type === "oauth"
-}
-
 export class Attempt extends Schema.Class<Attempt>("Integration.Attempt")({
   attemptID: AttemptID,
   url: Schema.String,
@@ -178,12 +141,14 @@ export const Event = {
     type: "integration.updated",
     schema: {},
   }),
+  ConnectionUpdated: EventV2.define({
+    type: "integration.connection.updated",
+    schema: { integrationID: ID },
+  }),
 }
 
-export type Ref = {
-  id: ID
-  name: string
-}
+export const Ref = Integration.Ref
+export type Ref = Integration.Ref
 
 type Entry = {
   ref: Types.DeepMutable<Ref>
@@ -215,7 +180,11 @@ export interface Interface extends State.Transformable<Draft> {
   readonly list: () => Effect.Effect<Info[]>
   readonly connection: {
     /** Returns the active connection for one integration. */
-    readonly forIntegration: (id: ID) => Effect.Effect<IntegrationConnection.Info | undefined>
+    readonly active: (id: ID) => Effect.Effect<IntegrationConnection.Info | undefined>
+    /** Resolves a connection into usable credential material. */
+    readonly resolve: (
+      connection: IntegrationConnection.Info,
+    ) => Effect.Effect<Credential.Value | undefined, AuthorizationError>
     /** Runs a key method and stores the resulting credential. */
     readonly key: (input: {
       /** Integration receiving the credential. */
@@ -385,7 +354,7 @@ export const locationLayer = Layer.effect(
       return error instanceof Error ? error.message : String(error)
     }
 
-    const settle = Effect.fnUntraced(function* (attemptID: AttemptID, exit: Exit.Exit<Credential.Value, unknown>) {
+    const settle = Effect.fnUntraced(function* (attemptID: AttemptID, exit: Exit.Exit<Credential.OAuth, unknown>) {
       const now = yield* Clock.currentTimeMillis
       const result = yield* SynchronizedRef.modify(attempts, (current) => {
         const attempt = current.get(attemptID)
@@ -397,14 +366,13 @@ export const locationLayer = Layer.effect(
       })
       if (!result) return
       if (Exit.isSuccess(exit)) {
+        const implementation = state.get().integrations.get(result.integrationID)?.implementations.get(result.methodID)
         yield* credentials.create({
           integrationID: result.integrationID,
-          label: result.label,
-          value:
-            exit.value.type === "oauth"
-              ? new Credential.OAuth({ ...exit.value, methodID: result.methodID })
-              : exit.value,
+          label: result.label ?? implementation?.label?.(exit.value),
+          value: exit.value,
         })
+        yield* events.publish(Event.ConnectionUpdated, { integrationID: result.integrationID })
         yield* events.publish(Event.Updated, {})
       }
       yield* close(result.scope)
@@ -445,10 +413,29 @@ export const locationLayer = Layer.effect(
         ).toSorted((a, b) => a.name.localeCompare(b.name))
       }),
       connection: {
-        forIntegration: Effect.fn("Integration.connection.forIntegration")(function* (id) {
+        active: Effect.fn("Integration.connection.active")(function* (id) {
           const entry = state.get().integrations.get(id)
           return resolveConnections(entry, yield* credentials.list(id))[0]
         }),
+        resolve: Effect.fn("Integration.connection.resolve")(function* (connection) {
+          if (connection.type === "env") {
+            const key = process.env[connection.name]
+            return key ? Credential.Key.make({ type: "key", key }) : undefined
+          }
+          const credential = yield* credentials.get(connection.id)
+          if (!credential) return undefined
+          if (credential.value.type === "key") return credential.value
+          const implementation = state
+            .get()
+            .integrations.get(credential.integrationID)
+            ?.implementations.get(credential.value.methodID)
+          if (!implementation?.refresh) return credential.value
+          const now = yield* Clock.currentTimeMillis
+          if (credential.value.expires > now + Duration.toMillis(Duration.minutes(5))) return credential.value
+          const value = yield* authorize(implementation.refresh(credential.value))
+          yield* credentials.update(credential.id, { value })
+          return value
+        }),
         key: Effect.fn("Integration.connection.key")(function* (input) {
           const method = state
             .get()
@@ -458,8 +445,9 @@ export const locationLayer = Layer.effect(
           yield* credentials.create({
             integrationID: input.integrationID,
             label: input.label,
-            value: new Credential.Key({ type: "key", key: input.key }),
+            value: Credential.Key.make({ type: "key", key: input.key }),
           })
+          yield* events.publish(Event.ConnectionUpdated, { integrationID: input.integrationID })
           yield* events.publish(Event.Updated, {})
         }),
         oauth: Effect.fn("Integration.connection.oauth")(function* (input) {
@@ -503,11 +491,19 @@ export const locationLayer = Layer.effect(
           })
         }),
         update: Effect.fn("Integration.connection.update")(function* (credentialID, updates) {
+          const credential = yield* credentials.get(credentialID)
           yield* credentials.update(credentialID, updates)
+          if (credential) {
+            yield* events.publish(Event.ConnectionUpdated, { integrationID: credential.integrationID })
+          }
           yield* events.publish(Event.Updated, {})
         }),
         remove: Effect.fn("Integration.connection.remove")(function* (credentialID) {
+          const credential = yield* credentials.get(credentialID)
           yield* credentials.remove(credentialID)
+          if (credential) {
+            yield* events.publish(Event.ConnectionUpdated, { integrationID: credential.integrationID })
+          }
           yield* events.publish(Event.Updated, {})
         }),
       },

packages/core/src/integration/connection.ts

@@ -1,22 +1,12 @@
 export * as IntegrationConnection from "./connection"
 
-import { Schema } from "effect"
-import { Credential } from "../credential"
+import { Connection } from "@opencode-ai/schema/connection"
 
-export const CredentialInfo = Schema.Struct({
-  type: Schema.Literal("credential"),
-  id: Credential.ID,
-  label: Schema.String,
-}).annotate({ identifier: "Connection.CredentialInfo" })
-export type CredentialInfo = typeof CredentialInfo.Type
+export const CredentialInfo = Connection.CredentialInfo
+export type CredentialInfo = Connection.CredentialInfo
 
-export const EnvInfo = Schema.Struct({
-  type: Schema.Literal("env"),
-  name: Schema.String,
-}).annotate({ identifier: "Connection.EnvInfo" })
-export type EnvInfo = typeof EnvInfo.Type
+export const EnvInfo = Connection.EnvInfo
+export type EnvInfo = Connection.EnvInfo
 
-export const Info = Schema.Union([CredentialInfo, EnvInfo])
-  .pipe(Schema.toTaggedUnion("type"))
-  .annotate({ identifier: "Connection.Info" })
-export type Info = typeof Info.Type
+export const Info = Connection.Info
+export type Info = Connection.Info

packages/core/src/integration/schema.ts

@@ -1,9 +0,0 @@
-export * as IntegrationSchema from "./schema"
-
-import { Schema } from "effect"
-
-export const ID = Schema.String.pipe(Schema.brand("Integration.ID"))
-export type ID = typeof ID.Type
-
-export const MethodID = Schema.String.pipe(Schema.brand("Integration.MethodID"))
-export type MethodID = typeof MethodID.Type

packages/core/src/location.ts

@@ -1,14 +1,12 @@
 import { Context, Effect, Layer, Schema } from "effect"
+import { Ref } from "@opencode-ai/schema/location"
 import { Project } from "./project"
 import { AbsolutePath, optionalOmitUndefined } from "./schema"
 import { WorkspaceV2 } from "./workspace"
 
 export * as Location from "./location"
 
-export class Ref extends Schema.Class<Ref>("Location.Ref")({
-  directory: AbsolutePath,
-  workspaceID: Schema.optional(WorkspaceV2.ID).pipe(Schema.withConstructorDefault(Effect.succeed(undefined))),
-}) {}
+export { Ref }
 
 export class Info extends Schema.Class<Info>("Location.Info")({
   directory: AbsolutePath,

packages/core/src/model-request.ts

@@ -1,34 +1,12 @@
 export * as ModelRequest from "./model-request"
 
-import { Effect, Schema } from "effect"
+import { ModelRequest } from "@opencode-ai/schema/model-request"
 
-export const Generation = Schema.Struct({
-  maxTokens: Schema.Number.pipe(Schema.optional),
-  temperature: Schema.Number.pipe(Schema.optional),
-  topP: Schema.Number.pipe(Schema.optional),
-  topK: Schema.Number.pipe(Schema.optional),
-  frequencyPenalty: Schema.Number.pipe(Schema.optional),
-  presencePenalty: Schema.Number.pipe(Schema.optional),
-  seed: Schema.Number.pipe(Schema.optional),
-  stop: Schema.String.pipe(Schema.Array, Schema.mutable, Schema.optional),
-})
-export type Generation = typeof Generation.Type
+export const Generation = ModelRequest.Generation
+export type Generation = ModelRequest.Generation
 
-export const Request = Schema.Struct({
-  headers: Schema.Record(Schema.String, Schema.String),
-  body: Schema.Record(Schema.String, Schema.Any),
-  generation: Generation.pipe(
-    Schema.optionalKey,
-    Schema.withConstructorDefault(Effect.succeed({})),
-    Schema.withDecodingDefaultKey(Effect.succeed({})),
-  ),
-  options: Schema.Record(Schema.String, Schema.Any).pipe(
-    Schema.optionalKey,
-    Schema.withConstructorDefault(Effect.succeed({})),
-    Schema.withDecodingDefaultKey(Effect.succeed({})),
-  ),
-})
-export type Request = typeof Request.Type
+export const Request = ModelRequest.Request
+export type Request = ModelRequest.Request
 
 interface MutableRequest {
   headers: Record<string, string>

packages/core/src/model.ts

@@ -1,119 +1,30 @@
-import { Schema, Types } from "effect"
+import { Types } from "effect"
+import { Model } from "@opencode-ai/schema/model"
 import { ProviderV2 } from "./provider"
-import { ModelRequest } from "./model-request"
 
-export const ID = Schema.String.pipe(Schema.brand("ModelV2.ID"))
+export const ID = Model.ID
 export type ID = typeof ID.Type
 
-export const VariantID = Schema.String.pipe(Schema.brand("VariantID"))
+export const VariantID = Model.VariantID
 export type VariantID = typeof VariantID.Type
 
 // Grouping of models, eg claude opus, claude sonnet
-export const Family = Schema.String.pipe(Schema.brand("Family"))
-export type Family = typeof Family.Type
+export const Family = Model.Family
+export type Family = Model.Family
 
-export const Capabilities = Schema.Struct({
-  tools: Schema.Boolean,
-  // mime patterns, image, audio, video/*, text/*
-  input: Schema.String.pipe(Schema.Array, Schema.mutable),
-  output: Schema.String.pipe(Schema.Array, Schema.mutable),
-})
-export type Capabilities = typeof Capabilities.Type
+export const Capabilities = Model.Capabilities
+export type Capabilities = Model.Capabilities
 
-export const Cost = Schema.Struct({
-  tier: Schema.Struct({
-    type: Schema.Literal("context"),
-    size: Schema.Int,
-  }).pipe(Schema.optional),
-  input: Schema.Finite,
-  output: Schema.Finite,
-  cache: Schema.Struct({
-    read: Schema.Finite,
-    write: Schema.Finite,
-  }),
-})
+export const Cost = Model.Cost
 
-export const Ref = Schema.Struct({
-  id: ID,
-  providerID: ProviderV2.ID,
-  variant: VariantID.pipe(Schema.optional),
-})
+export const Ref = Model.Ref
 export type Ref = typeof Ref.Type
 
-export const Api = Schema.Union([
-  Schema.Struct({
-    id: ID,
-    ...ProviderV2.AISDK.fields,
-  }),
-  Schema.Struct({
-    id: ID,
-    ...ProviderV2.Native.fields,
-  }),
-]).pipe(Schema.toTaggedUnion("type"))
-export type Api = typeof Api.Type
+export const Api = Model.Api
+export type Api = Model.Api
 
-export class Info extends Schema.Class<Info>("ModelV2.Info")({
-  id: ID,
-  providerID: ProviderV2.ID,
-  family: Family.pipe(Schema.optional),
-  name: Schema.String,
-  api: Api,
-  capabilities: Capabilities,
-  request: Schema.Struct({
-    ...ModelRequest.Request.fields,
-    variant: Schema.String.pipe(Schema.optional),
-  }),
-  variants: Schema.Struct({
-    id: VariantID,
-    ...ModelRequest.Request.fields,
-  }).pipe(Schema.Array, Schema.mutable),
-  time: Schema.Struct({
-    released: Schema.Finite,
-  }),
-  cost: Cost.pipe(Schema.Array, Schema.mutable),
-  status: Schema.Literals(["alpha", "beta", "deprecated", "active"]),
-  enabled: Schema.Boolean,
-  limit: Schema.Struct({
-    context: Schema.Int,
-    input: Schema.Int.pipe(Schema.optional),
-    output: Schema.Int,
-  }),
-}) {
-  static empty(providerID: ProviderV2.ID, modelID: ID): Info {
-    return new Info({
-      id: modelID,
-      providerID,
-      name: modelID,
-      api: {
-        id: modelID,
-        type: "native",
-        settings: {},
-      },
-      capabilities: {
-        tools: false,
-        input: [],
-        output: [],
-      },
-      request: {
-        headers: {},
-        body: {},
-        generation: {},
-        options: {},
-      },
-      variants: [],
-      time: {
-        released: 0,
-      },
-      cost: [],
-      status: "active",
-      enabled: true,
-      limit: {
-        context: 0,
-        output: 0,
-      },
-    })
-  }
-}
+export const Info = Model.Info
+export type Info = Model.Info
 
 export type MutableInfo = Omit<Types.DeepMutable<Info>, "api"> & {
   api: ProviderV2.MutableApi<Api>

packages/core/src/permission.ts

@@ -1,6 +1,7 @@
 export * as PermissionV2 from "./permission"
 
 import { Context, Deferred, Effect as EffectRuntime, Layer, Schema } from "effect"
+import { Permission } from "@opencode-ai/schema/permission"
 import { EventV2 } from "./event"
 import { Location } from "./location"
 import { AgentV2 } from "./agent"
@@ -9,14 +10,10 @@ import { SessionStore } from "./session/store"
 import { withStatics } from "./schema"
 import { Identifier } from "./util/identifier"
 import { Wildcard } from "./util/wildcard"
-import { PermissionSchema } from "./permission/schema"
 import { PermissionSaved } from "./permission/saved"
 
-export { Effect, Rule, Ruleset } from "./permission/schema"
-type Effect = PermissionSchema.Effect
-type Rule = PermissionSchema.Rule
-type Ruleset = PermissionSchema.Ruleset
-const missingAgentPermissions: Ruleset = [{ action: "*", resource: "*", effect: "deny" }]
+export { Effect, Rule, Ruleset } from "@opencode-ai/schema/permission"
+const missingAgentPermissions: Permission.Ruleset = [{ action: "*", resource: "*", effect: "deny" }]
 
 export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(
   Schema.brand("PermissionV2.ID"),
@@ -67,7 +64,7 @@ export type ReplyInput = typeof ReplyInput.Type
 
 export const AskResult = Schema.Struct({
   id: ID,
-  effect: PermissionSchema.Effect,
+  effect: Permission.Effect,
 }).annotate({ identifier: "PermissionV2.AskResult" })
 export type AskResult = typeof AskResult.Type
 
@@ -90,7 +87,7 @@ export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("P
 }) {}
 
 export class DeniedError extends Schema.TaggedErrorClass<DeniedError>()("PermissionV2.DeniedError", {
-  rules: PermissionSchema.Ruleset,
+  rules: Permission.Ruleset,
 }) {}
 
 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("PermissionV2.NotFoundError", {
@@ -99,7 +96,7 @@ export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Per
 
 export type Error = DeniedError | RejectedError | CorrectedError
 
-export function evaluate(action: string, resource: string, ...rulesets: Ruleset[]): Rule {
+export function evaluate(action: string, resource: string, ...rulesets: Permission.Ruleset[]): Permission.Rule {
   return (
     rulesets
       .flat()
@@ -111,7 +108,7 @@ export function evaluate(action: string, resource: string, ...rulesets: Ruleset[
   )
 }
 
-export function merge(...rulesets: Ruleset[]): Ruleset {
+export function merge(...rulesets: Permission.Ruleset[]): Permission.Ruleset {
   return rulesets.flat()
 }
 
@@ -156,7 +153,7 @@ export const layer = Layer.effect(
 
     const savedRules = EffectRuntime.fnUntraced(function* () {
       return (yield* saved.list({ projectID: location.project.id })).map(
-        (item): Rule => ({ action: item.action, resource: item.resource, effect: "allow" }),
+        (item): Permission.Rule => ({ action: item.action, resource: item.resource, effect: "allow" }),
       )
     })
 
@@ -170,11 +167,11 @@ export const layer = Layer.effect(
       return agent?.permissions ?? missingAgentPermissions
     })
 
-    function denied(input: AssertInput, rules: Ruleset) {
+    function denied(input: AssertInput, rules: Permission.Ruleset) {
       return input.resources.some((resource) => evaluate(input.action, resource, rules).effect === "deny")
     }
 
-    function relevant(input: AssertInput, rules: Ruleset) {
+    function relevant(input: AssertInput, rules: Permission.Ruleset) {
       return rules.filter((rule) => Wildcard.match(input.action, rule.action))
     }
 
@@ -183,7 +180,7 @@ export const layer = Layer.effect(
       if (denied(input, rules)) return { effect: "deny" as const, rules }
       const all = [...rules, ...(yield* savedRules())]
       const effects = input.resources.map((resource) => evaluate(input.action, resource, all).effect)
-      const effect: Effect = effects.includes("deny") ? "deny" : effects.includes("ask") ? "ask" : "allow"
+      const effect: Permission.Effect = effects.includes("deny") ? "deny" : effects.includes("ask") ? "ask" : "allow"
       return { effect, rules: all }
     })
 

packages/core/src/plugin/host.ts

@@ -6,6 +6,7 @@ import { AgentV2 } from "../agent"
 import { AISDK } from "../aisdk"
 import { Catalog } from "../catalog"
 import { CommandV2 } from "../command"
+import { Credential } from "../credential"
 import { Integration } from "../integration"
 import { ModelV2 } from "../model"
 import { PluginV2 } from "../plugin"
@@ -97,6 +98,13 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
     },
     integration: {
       reload: integration.reload,
+      connection: {
+        active: (id) => integration.connection.active(Integration.ID.make(id)),
+        resolve: (connection) =>
+          integration.connection.resolve(
+            connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection,
+          ),
+      },
       transform: (callback) =>
         integration.transform((draft) =>
           callback({
@@ -107,6 +115,59 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
             method: {
               list: (id) => draft.method.list(Integration.ID.make(id)),
               update: (input) => {
+                if ("authorize" in input) {
+                  const methodID = Integration.MethodID.make(input.method.id)
+                  const refresh = input.refresh
+                  draft.method.update({
+                    integrationID: Integration.ID.make(input.integrationID),
+                    method: { ...input.method, id: methodID },
+                    authorize: (inputs) =>
+                      input.authorize(inputs).pipe(
+                        Effect.map((authorization) => {
+                          if (authorization.mode === "auto") {
+                            return {
+                              ...authorization,
+                              callback: authorization.callback.pipe(
+                                Effect.map((credential) =>
+                                  Credential.OAuth.make({
+                                    ...credential,
+                                    methodID: Integration.MethodID.make(credential.methodID),
+                                  }),
+                                ),
+                              ),
+                            }
+                          }
+                          return {
+                            ...authorization,
+                            callback: (code: string) =>
+                              authorization.callback(code).pipe(
+                                Effect.map((credential) =>
+                                  Credential.OAuth.make({
+                                    ...credential,
+                                    methodID: Integration.MethodID.make(credential.methodID),
+                                  }),
+                                ),
+                              ),
+                          }
+                        }),
+                      ),
+                    ...(refresh
+                      ? {
+                          refresh: (value: Credential.OAuth) =>
+                            refresh(value).pipe(
+                              Effect.map((next) =>
+                                Credential.OAuth.make({
+                                  ...next,
+                                  methodID: Integration.MethodID.make(next.methodID),
+                                }),
+                              ),
+                            ),
+                        }
+                      : {}),
+                    ...(input.label ? { label: input.label } : {}),
+                  })
+                  return
+                }
                 if (input.method.type === "env") {
                   draft.method.update({
                     integrationID: Integration.ID.make(input.integrationID),

packages/core/src/plugin/internal.ts

@@ -23,6 +23,7 @@ import { Npm } from "../npm"
 import { PluginV2 } from "../plugin"
 import { Reference } from "../reference"
 import { SkillV2 } from "../skill"
+import { FetchHttpClient, HttpClient } from "effect/unstable/http"
 import { AgentPlugin } from "./agent"
 import { CommandPlugin } from "./command"
 import { ModelsDevPlugin } from "./models-dev"
@@ -38,6 +39,7 @@ export type Requirements =
   | FileSystem.Service
   | FSUtil.Service
   | Global.Service
+  | HttpClient.HttpClient
   | Integration.Service
   | Location.Service
   | ModelsDev.Service
@@ -69,6 +71,7 @@ export const locationLayer = Layer.effectDiscard(
     const fs = yield* FSUtil.Service
     const filesystem = yield* FileSystem.Service
     const global = yield* Global.Service
+    const http = yield* HttpClient.HttpClient
     const skill = yield* SkillV2.Service
     const reference = yield* Reference.Service
     const add = <R>(input: Plugin<R>) => {
@@ -90,6 +93,7 @@ export const locationLayer = Layer.effectDiscard(
               Effect.provideService(FSUtil.Service, fs),
               Effect.provideService(FileSystem.Service, filesystem),
               Effect.provideService(Global.Service, global),
+              Effect.provideService(HttpClient.HttpClient, http),
               Effect.provideService(SkillV2.Service, skill),
               Effect.provideService(Reference.Service, reference),
             ),
@@ -115,4 +119,5 @@ export const locationLayer = Layer.effectDiscard(
   Layer.provideMerge(PluginV2.locationLayer),
   Layer.provideMerge(Config.locationLayer),
   Layer.provideMerge(FileSystem.locationLayer),
+  Layer.provideMerge(FetchHttpClient.layer),
 )

packages/core/src/plugin/promise.ts

@@ -65,6 +65,10 @@ export function fromPromise(plugin: Plugin) {
           integration: {
             transform: transform(host.integration),
             reload: () => run(host.integration.reload()),
+            connection: {
+              active: (id) => Effect.runPromiseWith(context)(host.integration.connection.active(id)),
+              resolve: (connection) => Effect.runPromiseWith(context)(host.integration.connection.resolve(connection)),
+            },
           },
           plugin: {
             add: (input) => {

packages/core/src/plugin/provider/openai-auth.ts

@@ -1,257 +0,0 @@
-import { createServer } from "node:http"
-import { Deferred, Effect } from "effect"
-import { Integration } from "../../integration"
-import { Credential } from "../../credential"
-import { InstallationVersion } from "../../installation/version"
-
-const clientID = "app_EMoamEEZ73f0CkXaXp7hrann"
-const issuer = "https://auth.openai.com"
-const callbackPort = 1455
-const pollingSafetyMargin = 3000
-
-type Pkce = {
-  verifier: string
-  challenge: string
-}
-
-type TokenResponse = {
-  id_token: string
-  access_token: string
-  refresh_token: string
-  expires_in?: number
-}
-
-type Claims = {
-  chatgpt_account_id?: string
-  organizations?: Array<{ id: string }>
-  "https://api.openai.com/auth"?: { chatgpt_account_id?: string }
-}
-
-const browserMethodID = Integration.MethodID.make("chatgpt-browser")
-const headlessMethodID = Integration.MethodID.make("chatgpt-headless")
-
-export const browser = {
-  integrationID: Integration.ID.make("openai"),
-  method: {
-    id: browserMethodID,
-    type: "oauth",
-    label: "ChatGPT Pro/Plus (browser)",
-  },
-  authorize: () =>
-    Effect.gen(function* () {
-      const pkce = yield* Effect.promise(generatePKCE)
-      const state = base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer)
-      const code = yield* Deferred.make<string, Error>()
-      const redirect = `http://localhost:${callbackPort}/auth/callback`
-      const server = createServer((request, response) => {
-        const url = new URL(request.url ?? "/", `http://localhost:${callbackPort}`)
-        if (url.pathname !== "/auth/callback") {
-          response.writeHead(404).end("Not found")
-          return
-        }
-        const error = url.searchParams.get("error_description") ?? url.searchParams.get("error")
-        const value = url.searchParams.get("code")
-        if (error) {
-          Effect.runFork(Deferred.fail(code, new Error(error)))
-          response.writeHead(400, { "Content-Type": "text/html" }).end(errorPage(error))
-          return
-        }
-        if (!value || url.searchParams.get("state") !== state) {
-          const message = value ? "Invalid OAuth state" : "Missing authorization code"
-          Effect.runFork(Deferred.fail(code, new Error(message)))
-          response.writeHead(400, { "Content-Type": "text/html" }).end(errorPage(message))
-          return
-        }
-        Effect.runFork(Deferred.succeed(code, value))
-        response.writeHead(200, { "Content-Type": "text/html" }).end(successPage)
-      })
-      yield* Effect.callback<void, Error>((resume) => {
-        server.once("error", (error) => resume(Effect.fail(error)))
-        server.listen(callbackPort, "localhost", () => resume(Effect.void))
-      })
-      yield* Effect.addFinalizer(() =>
-        Effect.sync(() => {
-          server.close()
-        }),
-      )
-      return {
-        mode: "auto" as const,
-        url: authorizeURL(redirect, pkce, state),
-        instructions: "Complete authorization in your browser. This window will close automatically.",
-        callback: Deferred.await(code).pipe(
-          Effect.flatMap((value) => exchange(value, redirect, pkce)),
-          Effect.map((tokens) => credential(browserMethodID, tokens)),
-        ),
-      }
-    }),
-  refresh: (value) => refresh(value),
-} satisfies Integration.OAuthImplementation
-
-export const headless = {
-  integrationID: Integration.ID.make("openai"),
-  method: {
-    id: headlessMethodID,
-    type: "oauth",
-    label: "ChatGPT Pro/Plus (headless)",
-  },
-  authorize: () =>
-    Effect.gen(function* () {
-      const device = yield* request<{ device_auth_id: string; user_code: string; interval: string }>(
-        `${issuer}/api/accounts/deviceauth/usercode`,
-        {
-          method: "POST",
-          headers: headers("application/json"),
-          body: JSON.stringify({ client_id: clientID }),
-        },
-      )
-      const interval = Math.max(Number.parseInt(device.interval) || 5, 1) * 1000
-      return {
-        mode: "auto" as const,
-        url: `${issuer}/codex/device`,
-        instructions: `Enter code: ${device.user_code}`,
-        callback: Effect.gen(function* () {
-          while (true) {
-            const response = yield* Effect.tryPromise({
-              try: (signal) =>
-                fetch(`${issuer}/api/accounts/deviceauth/token`, {
-                  method: "POST",
-                  headers: headers("application/json"),
-                  body: JSON.stringify({ device_auth_id: device.device_auth_id, user_code: device.user_code }),
-                  signal,
-                }),
-              catch: (cause) => cause,
-            })
-            if (response.ok) {
-              const data = (yield* Effect.promise(() => response.json())) as {
-                authorization_code: string
-                code_verifier: string
-              }
-              return credential(
-                headlessMethodID,
-                yield* exchange(data.authorization_code, `${issuer}/deviceauth/callback`, {
-                  verifier: data.code_verifier,
-                  challenge: "",
-                }),
-              )
-            }
-            if (response.status !== 403 && response.status !== 404) {
-              return yield* Effect.fail(new Error(`Device authorization failed: ${response.status}`))
-            }
-            yield* Effect.sleep(interval + pollingSafetyMargin)
-          }
-        }),
-      }
-    }),
-  refresh: (value) => refresh(value),
-} satisfies Integration.OAuthImplementation
-
-function headers(contentType: string) {
-  return { "Content-Type": contentType, "User-Agent": `opencode/${InstallationVersion}` }
-}
-
-function exchange(code: string, redirect: string, pkce: Pkce) {
-  return request<TokenResponse>(`${issuer}/oauth/token`, {
-    method: "POST",
-    headers: headers("application/x-www-form-urlencoded"),
-    body: new URLSearchParams({
-      grant_type: "authorization_code",
-      code,
-      redirect_uri: redirect,
-      client_id: clientID,
-      code_verifier: pkce.verifier,
-    }).toString(),
-  })
-}
-
-function refresh(value: Credential.OAuth) {
-  return request<TokenResponse>(`${issuer}/oauth/token`, {
-    method: "POST",
-    headers: headers("application/x-www-form-urlencoded"),
-    body: new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: value.refresh,
-      client_id: clientID,
-    }).toString(),
-  }).pipe(
-    Effect.map((tokens) => {
-      const next = credential(value.methodID, tokens)
-      return new Credential.OAuth({
-        ...next,
-        metadata: next.metadata ?? value.metadata,
-      })
-    }),
-  )
-}
-
-function request<A>(url: string, init: RequestInit) {
-  return Effect.tryPromise({
-    try: async (signal) => {
-      const response = await fetch(url, { ...init, signal })
-      if (!response.ok) throw new Error(`Request failed: ${response.status}`)
-      return response.json() as Promise<A>
-    },
-    catch: (cause) => cause,
-  })
-}
-
-function credential(methodID: Integration.MethodID, tokens: TokenResponse) {
-  const accountID = extractAccountID(tokens)
-  return new Credential.OAuth({
-    type: "oauth",
-    methodID,
-    refresh: tokens.refresh_token,
-    access: tokens.access_token,
-    expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
-    metadata: accountID ? { accountID } : undefined,
-  })
-}
-
-async function generatePKCE(): Promise<Pkce> {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
-  const verifier = Array.from(crypto.getRandomValues(new Uint8Array(43)), (byte) => chars[byte % chars.length]).join("")
-  const challenge = base64UrlEncode(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)))
-  return { verifier, challenge }
-}
-
-function base64UrlEncode(buffer: ArrayBuffer) {
-  return Buffer.from(buffer).toString("base64url")
-}
-
-function authorizeURL(redirect: string, pkce: Pkce, state: string) {
-  return `${issuer}/oauth/authorize?${new URLSearchParams({
-    response_type: "code",
-    client_id: clientID,
-    redirect_uri: redirect,
-    scope: "openid profile email offline_access",
-    code_challenge: pkce.challenge,
-    code_challenge_method: "S256",
-    id_token_add_organizations: "true",
-    codex_cli_simplified_flow: "true",
-    state,
-    originator: "opencode",
-  })}`
-}
-
-function extractAccountID(tokens: TokenResponse) {
-  return claim(tokens.id_token) ?? claim(tokens.access_token)
-}
-
-function claim(token: string) {
-  const part = token.split(".")[1]
-  if (!part) return
-  try {
-    const claims = JSON.parse(Buffer.from(part, "base64url").toString()) as Claims
-    return (
-      claims.chatgpt_account_id ??
-      claims["https://api.openai.com/auth"]?.chatgpt_account_id ??
-      claims.organizations?.[0]?.id
-    )
-  } catch {
-    return
-  }
-}
-
-const successPage =
-  "<!doctype html><title>OpenCode</title><h1>Authorization successful</h1><p>You can close this window.</p>"
-const errorPage = (message: string) =>
-  `<!doctype html><title>OpenCode</title><h1>Authorization failed</h1><p>${message.replace(/[&<>"']/g, "")}</p>`

packages/core/src/plugin/provider/openai.ts

@@ -1,15 +1,155 @@
-import { Effect } from "effect"
-import { ModelV2 } from "../../model"
-import { define } from "../internal"
-import { ProviderV2 } from "../../provider"
+import { createServer } from "node:http"
+import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { Deferred, Effect } from "effect"
+import type { Scope } from "effect"
+import { Credential } from "../../credential"
+import { InstallationVersion } from "../../installation/version"
 import { Integration } from "../../integration"
-import { browser, headless } from "./openai-auth"
+import { ModelV2 } from "../../model"
+import { ProviderV2 } from "../../provider"
+import type { PluginInternal } from "../internal"
+
+const clientID = "app_EMoamEEZ73f0CkXaXp7hrann"
+const issuer = "https://auth.openai.com"
+const callbackPort = 1455
+const pollingSafetyMargin = 3000
+const browserMethodID = Integration.MethodID.make("chatgpt-browser")
+const headlessMethodID = Integration.MethodID.make("chatgpt-headless")
+
+type Pkce = {
+  verifier: string
+  challenge: string
+}
+
+type TokenResponse = {
+  id_token: string
+  access_token: string
+  refresh_token: string
+  expires_in?: number
+}
+
+type Claims = {
+  chatgpt_account_id?: string
+  organizations?: Array<{ id: string }>
+  "https://api.openai.com/auth"?: { chatgpt_account_id?: string }
+}
+
+const browser = {
+  integrationID: Integration.ID.make("openai"),
+  method: {
+    id: browserMethodID,
+    type: "oauth",
+    label: "ChatGPT Pro/Plus (browser)",
+  },
+  authorize: () =>
+    Effect.gen(function* () {
+      const pkce = yield* Effect.promise(generatePKCE)
+      const state = base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer)
+      const code = yield* Deferred.make<string, Error>()
+      const redirect = `http://localhost:${callbackPort}/auth/callback`
+      const server = createServer((request, response) => {
+        const url = new URL(request.url ?? "/", `http://localhost:${callbackPort}`)
+        if (url.pathname !== "/auth/callback") {
+          response.writeHead(404).end("Not found")
+          return
+        }
+        const error = url.searchParams.get("error_description") ?? url.searchParams.get("error")
+        const value = url.searchParams.get("code")
+        if (error) {
+          Effect.runFork(Deferred.fail(code, new Error(error)))
+          response.writeHead(400, { "Content-Type": "text/html" }).end(errorPage(error))
+          return
+        }
+        if (!value || url.searchParams.get("state") !== state) {
+          const message = value ? "Invalid OAuth state" : "Missing authorization code"
+          Effect.runFork(Deferred.fail(code, new Error(message)))
+          response.writeHead(400, { "Content-Type": "text/html" }).end(errorPage(message))
+          return
+        }
+        Effect.runFork(Deferred.succeed(code, value))
+        response.writeHead(200, { "Content-Type": "text/html" }).end(successPage)
+      })
+      yield* Effect.callback<void, Error>((resume) => {
+        server.once("error", (error) => resume(Effect.fail(error)))
+        server.listen(callbackPort, "localhost", () => resume(Effect.void))
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(() => server.close()))
+      return {
+        mode: "auto" as const,
+        url: authorizeURL(redirect, pkce, state),
+        instructions: "Complete authorization in your browser. This window will close automatically.",
+        callback: Deferred.await(code).pipe(
+          Effect.flatMap((value) => exchange(value, redirect, pkce)),
+          Effect.map((tokens) => credential(browserMethodID, tokens)),
+        ),
+      }
+    }),
+  refresh: (value) => refresh(browserMethodID, value),
+} satisfies IntegrationOAuthMethodRegistration
+
+const headless = {
+  integrationID: Integration.ID.make("openai"),
+  method: {
+    id: headlessMethodID,
+    type: "oauth",
+    label: "ChatGPT Pro/Plus (headless)",
+  },
+  authorize: () =>
+    Effect.gen(function* () {
+      const device = yield* request<{ device_auth_id: string; user_code: string; interval: string }>(
+        `${issuer}/api/accounts/deviceauth/usercode`,
+        {
+          method: "POST",
+          headers: headers("application/json"),
+          body: JSON.stringify({ client_id: clientID }),
+        },
+      )
+      const interval = Math.max(Number.parseInt(device.interval) || 5, 1) * 1000
+      return {
+        mode: "auto" as const,
+        url: `${issuer}/codex/device`,
+        instructions: `Enter code: ${device.user_code}`,
+        callback: Effect.gen(function* () {
+          while (true) {
+            const response = yield* Effect.tryPromise({
+              try: (signal) =>
+                fetch(`${issuer}/api/accounts/deviceauth/token`, {
+                  method: "POST",
+                  headers: headers("application/json"),
+                  body: JSON.stringify({ device_auth_id: device.device_auth_id, user_code: device.user_code }),
+                  signal,
+                }),
+              catch: (cause) => cause,
+            })
+            if (response.ok) {
+              const data = (yield* Effect.promise(() => response.json())) as {
+                authorization_code: string
+                code_verifier: string
+              }
+              return credential(
+                headlessMethodID,
+                yield* exchange(data.authorization_code, `${issuer}/deviceauth/callback`, {
+                  verifier: data.code_verifier,
+                  challenge: "",
+                }),
+              )
+            }
+            if (response.status !== 403 && response.status !== 404) {
+              return yield* Effect.fail(new Error(`Device authorization failed: ${response.status}`))
+            }
+            yield* Effect.sleep(interval + pollingSafetyMargin)
+          }
+        }),
+      }
+    }),
+  refresh: (value) => refresh(headlessMethodID, value),
+} satisfies IntegrationOAuthMethodRegistration
 
 export const OpenAIPlugin = define({
   id: "openai",
   effect: Effect.fn(function* (ctx) {
-    const integrations = yield* Integration.Service
-    yield* integrations.transform((draft) => {
+    yield* ctx.integration.transform((draft) => {
       draft.method.update(browser)
       draft.method.update(headless)
     })
@@ -41,4 +181,112 @@ export const OpenAIPlugin = define({
       }),
     )
   }),
-})
+} satisfies PluginInternal.Plugin<PluginInternal.Requirements | Scope.Scope>)
+
+function headers(contentType: string) {
+  return { "Content-Type": contentType, "User-Agent": `opencode/${InstallationVersion}` }
+}
+
+function exchange(code: string, redirect: string, pkce: Pkce) {
+  return request<TokenResponse>(`${issuer}/oauth/token`, {
+    method: "POST",
+    headers: headers("application/x-www-form-urlencoded"),
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirect,
+      client_id: clientID,
+      code_verifier: pkce.verifier,
+    }).toString(),
+  })
+}
+
+function refresh(methodID: Integration.MethodID, value: Pick<Credential.OAuth, "refresh" | "metadata">) {
+  return request<TokenResponse>(`${issuer}/oauth/token`, {
+    method: "POST",
+    headers: headers("application/x-www-form-urlencoded"),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: value.refresh,
+      client_id: clientID,
+    }).toString(),
+  }).pipe(
+    Effect.map((tokens) => {
+      const next = credential(methodID, tokens)
+      return Credential.OAuth.make({ ...next, metadata: next.metadata ?? value.metadata })
+    }),
+  )
+}
+
+function request<A>(url: string, init: RequestInit) {
+  return Effect.tryPromise({
+    try: async (signal) => {
+      const response = await fetch(url, { ...init, signal })
+      if (!response.ok) throw new Error(`Request failed: ${response.status}`)
+      return response.json() as Promise<A>
+    },
+    catch: (cause) => cause,
+  })
+}
+
+function credential(methodID: Integration.MethodID, tokens: TokenResponse) {
+  const accountID = extractAccountID(tokens)
+  return Credential.OAuth.make({
+    type: "oauth",
+    methodID,
+    refresh: tokens.refresh_token,
+    access: tokens.access_token,
+    expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+    metadata: accountID ? { accountID } : undefined,
+  })
+}
+
+async function generatePKCE(): Promise<Pkce> {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+  const verifier = Array.from(crypto.getRandomValues(new Uint8Array(43)), (byte) => chars[byte % chars.length]).join("")
+  const challenge = base64UrlEncode(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)))
+  return { verifier, challenge }
+}
+
+function base64UrlEncode(buffer: ArrayBuffer) {
+  return Buffer.from(buffer).toString("base64url")
+}
+
+function authorizeURL(redirect: string, pkce: Pkce, state: string) {
+  return `${issuer}/oauth/authorize?${new URLSearchParams({
+    response_type: "code",
+    client_id: clientID,
+    redirect_uri: redirect,
+    scope: "openid profile email offline_access",
+    code_challenge: pkce.challenge,
+    code_challenge_method: "S256",
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true",
+    state,
+    originator: "opencode",
+  })}`
+}
+
+function extractAccountID(tokens: TokenResponse) {
+  return claim(tokens.id_token) ?? claim(tokens.access_token)
+}
+
+function claim(token: string) {
+  const part = token.split(".")[1]
+  if (!part) return
+  try {
+    const claims = JSON.parse(Buffer.from(part, "base64url").toString()) as Claims
+    return (
+      claims.chatgpt_account_id ??
+      claims["https://api.openai.com/auth"]?.chatgpt_account_id ??
+      claims.organizations?.[0]?.id
+    )
+  } catch {
+    return
+  }
+}
+
+const successPage =
+  "<!doctype html><title>OpenCode</title><h1>Authorization successful</h1><p>You can close this window.</p>"
+const errorPage = (message: string) =>
+  `<!doctype html><title>OpenCode</title><h1>Authorization failed</h1><p>${message.replace(/[&<>"']/g, "")}</p>`

packages/core/src/plugin/provider/opencode.ts

@@ -1,32 +1,314 @@
-import { Effect } from "effect"
-import { define } from "../internal"
-import { ProviderV2 } from "../../provider"
+import { Duration, Effect, Schema, Stream } from "effect"
+import type { Scope } from "effect"
+import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import type { CredentialValue } from "@opencode-ai/sdk/v2/types"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { EventV2 } from "../../event"
+import { Credential } from "../../credential"
 import { Integration } from "../../integration"
+import { ModelV2 } from "../../model"
+import { ModelRequest } from "../../model-request"
+import { ProviderV2 } from "../../provider"
+import { ConfigProviderV1 } from "../../v1/config/provider"
+import { ConfigV1 } from "../../v1/config/config"
 
-export const OpencodePlugin = define({
-  id: "opencode",
-  effect: Effect.fn(function* (ctx) {
-    const integrations = yield* Integration.Service
-    let hasKey = false
-    yield* ctx.catalog.transform(
-      Effect.fn(function* (evt) {
-        const item = evt.provider.get(ProviderV2.ID.opencode)
-        if (!item) return
-        const integration = yield* integrations.get(Integration.ID.make(item.provider.id))
-        hasKey = Boolean(
-          process.env.OPENCODE_API_KEY || integration?.connections.length || item.provider.request.body.apiKey,
-        )
-        evt.provider.update(item.provider.id, (provider) => {
-          if (!hasKey) provider.request.body.apiKey = "public"
-        })
-        if (hasKey) return
-        for (const model of item.models.values()) {
-          if (!model.cost.some((cost) => cost.input > 0)) continue
-          evt.model.update(item.provider.id, model.id, (draft) => {
-            draft.enabled = false
-          })
+const defaultServer = "https://console.opencode.ai"
+const clientID = "opencode-cli"
+const methodID = Integration.MethodID.make("device")
+const RemoteResponse = Schema.Struct({ config: ConfigV1.Info })
+const Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri_complete: Schema.String,
+  expires_in: Schema.Number,
+  interval: Schema.Number,
+})
+const Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.String,
+  expires_in: Schema.Number,
+})
+const TokenPending = Schema.Struct({ error: Schema.String })
+const DeviceToken = Schema.Union([Token, TokenPending])
+const User = Schema.Struct({ id: Schema.String, email: Schema.String })
+const Org = Schema.Struct({ id: Schema.String, name: Schema.String })
+
+function oauth(http: HttpClient.HttpClient) {
+  return {
+    integrationID: Integration.ID.make("opencode"),
+    method: {
+      id: methodID,
+      type: "oauth",
+      label: "OpenCode Console account",
+    },
+    authorize: () =>
+      Effect.gen(function* () {
+        const device = yield* post(http, `${defaultServer}/auth/device/code`, { client_id: clientID }, Device)
+        return {
+          mode: "auto" as const,
+          url: `${defaultServer}${device.verification_uri_complete}`,
+          instructions: `Enter code: ${device.user_code}`,
+          callback: poll(http, defaultServer, device.device_code, Duration.seconds(device.interval)),
         }
       }),
+    refresh: (credential) =>
+      Effect.gen(function* () {
+        const server = typeof credential.metadata?.server === "string" ? credential.metadata.server : defaultServer
+        const token = yield* post(
+          http,
+          `${server}/auth/device/token`,
+          { grant_type: "refresh_token", refresh_token: credential.refresh, client_id: clientID },
+          Token,
+        )
+        return {
+          ...credential,
+          access: token.access_token,
+          refresh: token.refresh_token,
+          expires: Date.now() + token.expires_in * 1000,
+        }
+      }),
+    label: (credential) => {
+      return typeof credential.metadata?.orgName === "string" ? credential.metadata.orgName : undefined
+    },
+  } satisfies IntegrationOAuthMethodRegistration
+}
+
+export const OpencodePlugin = define<HttpClient.HttpClient | EventV2.Service | Scope.Scope>({
+  id: "opencode",
+  effect: Effect.fn(function* (ctx) {
+    const events = yield* EventV2.Service
+    const http = yield* HttpClient.HttpClient
+    let connected = false
+    let providers: typeof ConfigV1.Info.Type.provider | undefined
+
+    const load = Effect.fn("OpencodePlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("opencode")
+      const credential = connection
+        ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined)))
+        : undefined
+      connected = connection !== undefined
+      providers = credential
+        ? yield* fetchProviders(http, credential).pipe(
+            Effect.catch((cause) =>
+              Effect.logWarning("failed to load OpenCode provider config", { cause }).pipe(Effect.as(undefined)),
+            ),
+          )
+        : undefined
+    })
+
+    yield* ctx.integration.transform((draft) => {
+      draft.update("opencode", (integration) => {
+        integration.name = "OpenCode"
+      })
+      draft.method.update(oauth(http))
+      draft.method.update({ integrationID: "opencode", method: { type: "key", label: "API key (service account)" } })
+    })
+
+    yield* load()
+    yield* ctx.catalog.transform((catalog) => {
+      for (const [providerID, item] of Object.entries(providers ?? {})) {
+        catalog.provider.update(providerID, (provider) => {
+          provider.integrationID = Integration.ID.make("opencode")
+          if (item.name !== undefined) provider.name = item.name
+          provider.api = item.npm
+            ? { type: "aisdk", package: item.npm, url: item.api }
+            : { type: "native", url: item.api, settings: {} }
+          Object.assign(provider.request.headers, item.options?.headers)
+          Object.assign(provider.request.body, withoutCredentials(item.options))
+        })
+
+        const modelIDs = new Set(Object.keys(item.models ?? {}))
+        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
+          if (!modelIDs.has(model.id)) catalog.model.remove(providerID, model.id)
+        }
+
+        for (const [modelID, config] of Object.entries(item.models ?? {})) {
+          catalog.model.update(providerID, modelID, (model) => {
+            if (config.family !== undefined) model.family = config.family
+            if (config.name !== undefined) model.name = config.name
+            if (config.id !== undefined) model.api.id = config.id
+            if (config.provider !== undefined) {
+              model.api = config.provider.npm
+                ? {
+                    id: model.api.id,
+                    type: "aisdk",
+                    package: config.provider.npm,
+                    url: config.provider.api,
+                  }
+                : { id: model.api.id, type: "native", url: config.provider.api, settings: {} }
+            }
+            if (config.tool_call !== undefined) model.capabilities.tools = config.tool_call
+            if (config.modalities?.input !== undefined) model.capabilities.input = [...config.modalities.input]
+            if (config.modalities?.output !== undefined) model.capabilities.output = [...config.modalities.output]
+            const packageName = config.provider?.npm ?? item.npm
+            ModelRequest.assign(model.request, {
+              headers: config.headers,
+              ...ModelRequest.normalizeAiSdkOptions(packageName, withoutCredentials(config.options)),
+            })
+            if (config.variants !== undefined) {
+              model.variants = Object.entries(config.variants).map(([id, options]) => ({
+                id: ModelV2.VariantID.make(id),
+                headers: { ...(options.headers ?? {}) },
+                ...ModelRequest.normalizeAiSdkOptions(packageName, withoutCredentials(options)),
+              }))
+            }
+            if (config.release_date !== undefined) {
+              const released = Date.parse(config.release_date)
+              model.time.released = Number.isFinite(released) ? released : 0
+            }
+            if (config.cost !== undefined) {
+              model.cost = remoteCost(config.cost)
+            }
+            model.status = config.status ?? "active"
+            model.enabled = config.status !== "deprecated"
+            if (config.limit !== undefined) model.limit = { ...config.limit }
+          })
+        }
+      }
+
+      const item = catalog.provider.get(ProviderV2.ID.opencode)
+      if (!item) return
+      const hasKey = Boolean(process.env.OPENCODE_API_KEY || connected || item.provider.request.body.apiKey)
+      catalog.provider.update(item.provider.id, (provider) => {
+        if (!hasKey) provider.request.body.apiKey = "public"
+      })
+      if (hasKey) return
+      for (const model of item.models.values()) {
+        if (!model.cost.some((cost) => cost.input > 0)) continue
+        catalog.model.update(item.provider.id, model.id, (draft) => {
+          draft.enabled = false
+        })
+      }
+    })
+
+    yield* events.subscribe(Integration.Event.ConnectionUpdated).pipe(
+      Stream.filter((event) => event.data.integrationID === Integration.ID.make("opencode")),
+      Stream.runForEach(() => load().pipe(Effect.andThen(ctx.catalog.reload()))),
+      Effect.forkScoped({ startImmediately: true }),
     )
   }),
 })
+
+function fetchProviders(http: HttpClient.HttpClient, value: CredentialValue) {
+  const metadata = value.metadata
+  const server = typeof metadata?.server === "string" ? metadata.server : defaultServer
+  const orgID = typeof metadata?.orgID === "string" ? metadata.orgID : undefined
+  const token = value.type === "oauth" ? value.access : value.key
+  return http
+    .execute(
+      HttpClientRequest.get(`${server}/api/config`).pipe(
+        HttpClientRequest.acceptJson,
+        HttpClientRequest.bearerToken(token),
+        HttpClientRequest.setHeaders(orgID ? { "x-org-id": orgID } : {}),
+      ),
+    )
+    .pipe(
+      Effect.flatMap((response) => {
+        if (response.status === 404) return Effect.succeed(undefined)
+        return HttpClientResponse.filterStatusOk(response).pipe(
+          Effect.flatMap(HttpClientResponse.schemaBodyJson(RemoteResponse)),
+          Effect.map((remote) => remote.config.provider),
+        )
+      }),
+    )
+}
+
+function withoutCredentials(body: Readonly<Record<string, unknown>> | undefined) {
+  return Object.fromEntries(Object.entries(body ?? {}).filter(([key]) => key !== "apiKey" && key !== "headers"))
+}
+
+function remoteCost(input: NonNullable<(typeof ConfigProviderV1.Model.Type)["cost"]>) {
+  const base = {
+    input: input.input,
+    output: input.output,
+    cache: { read: input.cache_read ?? 0, write: input.cache_write ?? 0 },
+  }
+  if (!input.context_over_200k) return [base]
+  return [
+    base,
+    {
+      tier: { type: "context" as const, size: 200_000 },
+      input: input.context_over_200k.input,
+      output: input.context_over_200k.output,
+      cache: {
+        read: input.context_over_200k.cache_read ?? 0,
+        write: input.context_over_200k.cache_write ?? 0,
+      },
+    },
+  ]
+}
+
+function poll(http: HttpClient.HttpClient, server: string, deviceCode: string, interval: Duration.Duration) {
+  const loop = (wait: Duration.Duration): Effect.Effect<Credential.OAuth, unknown> =>
+    Effect.gen(function* () {
+      yield* Effect.sleep(wait)
+      const result = yield* post(
+        http,
+        `${server}/auth/device/token`,
+        {
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: clientID,
+        },
+        DeviceToken,
+        false,
+      )
+      if ("access_token" in result) return yield* credential(http, server, result)
+      if (result.error === "authorization_pending") return yield* loop(wait)
+      if (result.error === "slow_down") {
+        return yield* loop(Duration.sum(wait, Duration.seconds(5)))
+      }
+      return yield* Effect.fail(new Error(`Device authorization failed: ${result.error}`))
+    })
+  return loop(interval)
+}
+
+function credential(http: HttpClient.HttpClient, server: string, token: typeof Token.Type) {
+  return Effect.gen(function* () {
+    const [user, orgs] = yield* Effect.all(
+      [
+        get(http, `${server}/api/user`, token.access_token, User),
+        get(http, `${server}/api/orgs`, token.access_token, Schema.Array(Org)),
+      ],
+      { concurrency: 2 },
+    )
+    const org = orgs.toSorted((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))[0]
+    return Credential.OAuth.make({
+      type: "oauth" as const,
+      methodID,
+      access: token.access_token,
+      refresh: token.refresh_token,
+      expires: Date.now() + token.expires_in * 1000,
+      metadata: {
+        server,
+        accountID: user.id,
+        email: user.email,
+        orgID: org?.id,
+        orgName: org?.name,
+      },
+    })
+  })
+}
+
+function get<S extends Schema.Top>(http: HttpClient.HttpClient, url: string, token: string, schema: S) {
+  return HttpClient.filterStatusOk(http)
+    .execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(token)))
+    .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)))
+}
+
+function post<S extends Schema.Top>(
+  http: HttpClient.HttpClient,
+  url: string,
+  body: Record<string, string>,
+  schema: S,
+  statusOk = true,
+) {
+  return HttpClientRequest.post(url).pipe(
+    HttpClientRequest.acceptJson,
+    HttpClientRequest.schemaBodyJson(Schema.Record(Schema.String, Schema.String))(body),
+    Effect.flatMap((request) => http.execute(request)),
+    Effect.flatMap((response) => (statusOk ? HttpClientResponse.filterStatusOk(response) : Effect.succeed(response))),
+    Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)),
+  )
+}

packages/core/src/plugin/skill.ts

@@ -15,9 +15,9 @@ export const Plugin = define({
   effect: Effect.fn(function* (ctx) {
     yield* ctx.skill.transform((draft) => {
       draft.source(
-        new SkillV2.EmbeddedSource({
+        SkillV2.EmbeddedSource.make({
           type: "embedded",
-          skill: new SkillV2.Info({
+          skill: SkillV2.Info.make({
             name: "customize-opencode",
             description:
               "Use ONLY when the user is editing or creating opencode's own configuration: opencode.json, opencode.jsonc, files under .opencode/, or files under ~/.config/opencode/. Also use when creating or fixing opencode agents, subagents, commands, skills, plugins, MCP servers, or permission rules. Do not use for the user's own application code, or for any project that is not configuring opencode itself.",

packages/core/src/process.ts

@@ -10,7 +10,14 @@ export class AppProcessError extends Schema.TaggedErrorClass<AppProcessError>()(
   exitCode: Schema.optional(Schema.Number),
   stderr: Schema.optional(Schema.String),
   cause: Schema.optional(Schema.Defect()),
-}) {}
+}) {
+  override get message() {
+    const detail =
+      this.stderr?.trim() || (this.cause instanceof Error ? this.cause.message : this.cause && String(this.cause))
+    const status = this.exitCode === undefined ? "" : ` (exit ${this.exitCode})`
+    return `Command failed${status}: ${this.command}${detail ? `: ${detail}` : ""}`
+  }
+}
 
 export interface RunOptions {
   readonly maxOutputBytes?: number

packages/core/src/project/schema.ts

@@ -1,14 +1,10 @@
 export * as ProjectSchema from "./schema"
 
 import { Schema } from "effect"
-import { AbsolutePath, withStatics } from "../schema"
+import { Project } from "@opencode-ai/schema/project"
+import { AbsolutePath } from "../schema"
 
-export const ID = Schema.String.pipe(
-  Schema.brand("Project.ID"),
-  withStatics((schema) => ({
-    global: schema.make("global"),
-  })),
-)
+export const ID = Project.ID
 export type ID = typeof ID.Type
 
 export const Vcs = Schema.Union([

packages/core/src/provider.ts

@@ -1,73 +1,25 @@
 export * as ProviderV2 from "./provider"
 
-import { withStatics } from "./schema"
-import { Schema, Types } from "effect"
+import { Types } from "effect"
+import { Provider } from "@opencode-ai/schema/provider"
 
-export const ID = Schema.String.pipe(
-  Schema.brand("ProviderV2.ID"),
-  withStatics((schema) => ({
-    // Well-known providers
-    opencode: schema.make("opencode"),
-    anthropic: schema.make("anthropic"),
-    openai: schema.make("openai"),
-    google: schema.make("google"),
-    googleVertex: schema.make("google-vertex"),
-    githubCopilot: schema.make("github-copilot"),
-    amazonBedrock: schema.make("amazon-bedrock"),
-    azure: schema.make("azure"),
-    openrouter: schema.make("openrouter"),
-    mistral: schema.make("mistral"),
-    gitlab: schema.make("gitlab"),
-  })),
-)
+export const ID = Provider.ID
 export type ID = typeof ID.Type
 
-export const AISDK = Schema.Struct({
-  type: Schema.Literal("aisdk"),
-  package: Schema.String,
-  url: Schema.String.pipe(Schema.optional),
-  settings: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
-})
+export const AISDK = Provider.AISDK
 
-export const Native = Schema.Struct({
-  type: Schema.Literal("native"),
-  url: Schema.String.pipe(Schema.optional),
-  settings: Schema.Record(Schema.String, Schema.Unknown),
-})
+export const Native = Provider.Native
 
-export const Api = Schema.Union([AISDK, Native]).pipe(Schema.toTaggedUnion("type"))
-export type Api = typeof Api.Type
+export const Api = Provider.Api
+export type Api = Provider.Api
 export type MutableApi<T extends Api = Api> = T extends Api
   ? Omit<Types.DeepMutable<T>, "settings"> & (undefined extends T["settings"] ? { settings?: any } : { settings: any })
   : never
 
-export const Request = Schema.Struct({
-  headers: Schema.Record(Schema.String, Schema.String),
-  body: Schema.Record(Schema.String, Schema.Any),
-})
-export type Request = typeof Request.Type
+export const Request = Provider.Request
+export type Request = Provider.Request
 
-export class Info extends Schema.Class<Info>("ProviderV2.Info")({
-  id: ID,
-  name: Schema.String,
-  disabled: Schema.Boolean.pipe(Schema.optional),
-  api: Api,
-  request: Request,
-}) {
-  static empty(providerID: ID): Info {
-    return new Info({
-      id: providerID,
-      name: providerID,
-      api: {
-        type: "native",
-        settings: {},
-      },
-      request: {
-        headers: {},
-        body: {},
-      },
-    })
-  }
-}
+export const Info = Provider.Info
+export type Info = Provider.Info
 
 export type MutableInfo = Omit<Types.DeepMutable<Info>, "api"> & { api: MutableApi }

packages/core/src/public-event-manifest.ts

@@ -0,0 +1,47 @@
+export * as PublicEventManifest from "./public-event-manifest"
+
+import { Event } from "@opencode-ai/schema/event"
+import { Todo } from "@opencode-ai/schema/todo"
+import { Catalog } from "./catalog"
+import { FileSystem } from "./filesystem"
+import { Watcher } from "./filesystem/watcher"
+import { Integration } from "./integration"
+import { ModelsDev } from "./models-dev"
+import { PermissionV2 } from "./permission"
+import { PluginV2 } from "./plugin"
+import { ProjectCopy } from "./project/copy"
+import { Pty } from "./pty"
+import { QuestionV2 } from "./question"
+import { Reference } from "./reference"
+import { EventManifest } from "./event-manifest"
+
+export const FoundationDefinitions = Event.inventory(
+  ModelsDev.Event.Refreshed,
+  Integration.Event.Updated,
+  Integration.Event.ConnectionUpdated,
+  Catalog.Event.Updated,
+  ...EventManifest.Definitions,
+)
+
+export const FeatureDefinitions = Event.inventory(
+  FileSystem.Event.Edited,
+  Reference.Event.Updated,
+  PermissionV2.Event.Asked,
+  PermissionV2.Event.Replied,
+  PluginV2.Event.Added,
+  ProjectCopy.Event.Updated,
+  Watcher.Event.Updated,
+  Pty.Event.Created,
+  Pty.Event.Updated,
+  Pty.Event.Exited,
+  Pty.Event.Deleted,
+  QuestionV2.Event.Asked,
+  QuestionV2.Event.Replied,
+  QuestionV2.Event.Rejected,
+  Todo.Event.Updated,
+)
+
+export const Definitions = Event.inventory(...FoundationDefinitions, ...FeatureDefinitions)
+
+export const Latest = Event.latest(Definitions)
+export const Durable = Event.durable(Definitions)

packages/core/src/reference.ts

@@ -1,6 +1,7 @@
 export * as Reference from "./reference"
 
 import { Context, Effect, Layer, Schema, Scope, Types } from "effect"
+import { Reference } from "@opencode-ai/schema/reference"
 import { Global } from "./global"
 import { EventV2 } from "./event"
 import { Repository } from "./repository"
@@ -8,23 +9,14 @@ import { RepositoryCache } from "./repository-cache"
 import { AbsolutePath } from "./schema"
 import { State } from "./state"
 
-export class LocalSource extends Schema.Class<LocalSource>("Reference.LocalSource")({
-  type: Schema.Literal("local"),
-  path: AbsolutePath,
-  description: Schema.String.pipe(Schema.optional),
-  hidden: Schema.Boolean.pipe(Schema.optional),
-}) {}
+export const LocalSource = Reference.LocalSource
+export type LocalSource = Reference.LocalSource
 
-export class GitSource extends Schema.Class<GitSource>("Reference.GitSource")({
-  type: Schema.Literal("git"),
-  repository: Schema.String,
-  branch: Schema.String.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  hidden: Schema.Boolean.pipe(Schema.optional),
-}) {}
+export const GitSource = Reference.GitSource
+export type GitSource = Reference.GitSource
 
-export const Source = Schema.Union([LocalSource, GitSource]).pipe(Schema.toTaggedUnion("type"))
-export type Source = typeof Source.Type
+export const Source = Reference.Source
+export type Source = Reference.Source
 
 export const Event = {
   Updated: EventV2.define({ type: "reference.updated", schema: {} }),

packages/core/src/ripgrep.ts

@@ -2,10 +2,8 @@ export * as Ripgrep from "./ripgrep"
 
 import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
-import path from "path"
+import { Entry, Match } from "@opencode-ai/schema/filesystem"
 import { LayerNode } from "./effect/layer-node"
-import { Entry, Match } from "./filesystem/schema"
-import { FSUtil } from "./fs-util"
 import { AppProcess, collectStream, waitForAbort } from "./process"
 import { NonNegativeInt, PositiveInt, RelativePath } from "./schema"
 import { RipgrepBinary } from "./ripgrep/binary"
@@ -177,14 +175,12 @@ export const layer = Layer.effect(
             ),
         }).pipe(
           Effect.map((result) =>
-            result.items.map((relative) => {
-              const absolute = path.resolve(input.cwd, relative)
-              return new Entry({
+            result.items.map((relative) =>
+              Entry.make({
                 path: RelativePath.make(relative),
                 type: "file",
-                mime: FSUtil.mimeType(absolute),
-              })
-            }),
+              }),
+            ),
           ),
           Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause))),
         ),
@@ -208,10 +204,9 @@ export const layer = Layer.effect(
               .replace(/^[\\/]+/u, "")
               .replaceAll("\\", "/")
             return Effect.succeed(
-              new Entry({
+              Entry.make({
                 path: RelativePath.make(relative),
                 type: "file",
-                mime: FSUtil.mimeType(path.resolve(input.cwd, relative)),
               }),
             )
           },
@@ -262,12 +257,10 @@ export const layer = Layer.effect(
                 .replace(/^(?:\.[\\/])+/u, "")
                 .replace(/^[\\/]+/u, "")
                 .replaceAll("\\", "/")
-              const absolute = path.resolve(input.cwd, relative)
-              return new Match({
-                entry: new Entry({
+              return Match.make({
+                entry: Entry.make({
                   path: RelativePath.make(relative),
                   type: "file",
-                  mime: FSUtil.mimeType(absolute),
                 }),
                 line: match.line_number,
                 offset: match.absolute_offset,

packages/core/src/schema.ts

@@ -1,48 +1,24 @@
-import { Option, Schema, SchemaGetter } from "effect"
-import { Hash } from "./util/hash"
+import { Schema } from "effect"
+import {
+  AbsolutePath,
+  DateTimeUtcFromMillis,
+  NonNegativeInt,
+  optionalOmitUndefined,
+  PositiveInt,
+  RelativePath,
+  withStatics,
+} from "@opencode-ai/schema/schema"
 
-export type ExternalID = {
-  readonly namespace: string
-  readonly key: string
+export {
+  AbsolutePath,
+  DateTimeUtcFromMillis,
+  NonNegativeInt,
+  optionalOmitUndefined,
+  PositiveInt,
+  RelativePath,
+  withStatics,
 }
 
-export const externalID = (prefix: string, input: ExternalID) =>
-  `${prefix}_${Hash.sha256(JSON.stringify([input.namespace, input.key]))}`
-
-/**
- * Integer greater than zero.
- */
-export const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0))
-
-/**
- * Integer greater than or equal to zero.
- */
-export const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
-
-/**
- * Relative file path (e.g., `src/components/Button.tsx`).
- */
-export const RelativePath = Schema.String.pipe(Schema.brand("RelativePath"))
-export type RelativePath = Schema.Schema.Type<typeof RelativePath>
-
-/**
- * Absolute file path (e.g., `/home/user/projects/myapp/src/main.ts`).
- */
-export const AbsolutePath = Schema.String.pipe(Schema.brand("AbsolutePath"))
-export type AbsolutePath = Schema.Schema.Type<typeof AbsolutePath>
-
-/**
- * Optional public JSON field that can hold explicit `undefined` on the type
- * side but encodes it as an omitted key, matching legacy `JSON.stringify`.
- */
-export const optionalOmitUndefined = <S extends Schema.Top>(schema: S) =>
-  Schema.optionalKey(schema).pipe(
-    Schema.decodeTo(Schema.optional(schema), {
-      decode: SchemaGetter.passthrough({ strict: false }),
-      encode: SchemaGetter.transformOptional(Option.filter((value) => value !== undefined)),
-    }),
-  )
-
 /**
  * Strip `readonly` from a nested type. Stand-in for `effect`'s `Types.DeepMutable`
  * until `effect:core/x228my` ("Types.DeepMutable widens unknown to `{}`") lands.
@@ -71,22 +47,6 @@ export type DeepMutable<T> = T extends string | number | boolean | bigint | symb
         ? { -readonly [K in keyof T]: DeepMutable<T[K]> }
         : T
 
-/**
- * Attach static methods to a schema object. Designed to be used with `.pipe()`:
- *
- * @example
- *   export const Foo = fooSchema.pipe(
- *     withStatics((schema) => ({
- *       zero: schema.make(0),
- *       from: Schema.decodeUnknownOption(schema),
- *     }))
- *   )
- */
-export const withStatics =
-  <S extends object, M extends Record<string, unknown>>(methods: (schema: S) => M) =>
-  (schema: S): S & M =>
-    Object.assign(schema, methods(schema))
-
 /**
  * Nominal wrapper for scalar types. The class itself is a valid schema —
  * pass it directly to `Schema.decode`, `Schema.decodeEffect`, etc.

packages/core/src/session.ts

@@ -2,6 +2,7 @@ export * as SessionV2 from "./session"
 export * from "./session/schema"
 
 import { DateTime, Effect, Layer, Schema, Context, Stream } from "effect"
+import { ListAnchor } from "@opencode-ai/schema/session"
 import { and, asc, desc, eq, gt, like, lt, or, type SQL } from "drizzle-orm"
 import { ProjectV2 } from "./project"
 import { WorkspaceV2 } from "./workspace"
@@ -38,12 +39,7 @@ import { SessionInput } from "./session/input"
 //   - by subpath
 // - by workspace (home is special)
 
-export const ListAnchor = Schema.Struct({
-  id: SessionSchema.ID,
-  time: Schema.Finite,
-  direction: Schema.Literals(["previous", "next"]),
-})
-export type ListAnchor = typeof ListAnchor.Type
+export { ListAnchor }
 
 const ListInputBase = {
   workspaceID: WorkspaceV2.ID.pipe(Schema.optional),

packages/core/src/session/error.ts

@@ -5,7 +5,11 @@ import { SessionSchema } from "./schema"
 export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeError>()("Session.MessageDecodeError", {
   sessionID: SessionSchema.ID,
   messageID: SessionMessage.ID,
-}) {}
+}) {
+  override get message() {
+    return `Failed to decode message ${this.messageID} in session ${this.sessionID}`
+  }
+}
 
 export class ContextSnapshotDecodeError extends Schema.TaggedErrorClass<ContextSnapshotDecodeError>()(
   "Session.ContextSnapshotDecodeError",

packages/core/src/session/event.ts

@@ -1,473 +1,2 @@
-import { Schema } from "effect"
-import { ProviderMetadata, ToolContent } from "@opencode-ai/llm"
-import { EventV2 } from "../event"
-import { ModelV2 } from "../model"
-import { NonNegativeInt } from "../schema"
-import { V2Schema } from "../v2-schema"
-import { FileAttachment, Prompt } from "./prompt"
-import { SessionSchema } from "./schema"
-import { Location } from "../location"
-import { RelativePath } from "../schema"
-import { SessionMessageID } from "./message-id"
-
-export { FileAttachment }
-
-export const Source = Schema.Struct({
-  start: NonNegativeInt,
-  end: NonNegativeInt,
-  text: Schema.String,
-}).annotate({
-  identifier: "session.next.event.source",
-})
-export type Source = typeof Source.Type
-
-const Base = {
-  timestamp: V2Schema.DateTimeUtcFromMillis,
-  sessionID: SessionSchema.ID,
-}
-const PromptFields = {
-  ...Base,
-  messageID: SessionMessageID.ID,
-  prompt: Prompt,
-  delivery: Schema.Literals(["steer", "queue"]),
-}
-
-const options = {
-  durable: {
-    aggregate: "sessionID",
-    version: 1,
-  },
-} as const
-const stepSettlementOptions = {
-  durable: {
-    aggregate: "sessionID",
-    version: 2,
-  },
-} as const
-
-export const UnknownError = Schema.Struct({
-  type: Schema.Literal("unknown"),
-  message: Schema.String,
-}).annotate({
-  identifier: "Session.Error.Unknown",
-})
-export type UnknownError = typeof UnknownError.Type
-
-export const AgentSwitched = EventV2.define({
-  type: "session.next.agent.switched",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    agent: Schema.String,
-  },
-})
-export type AgentSwitched = typeof AgentSwitched.Type
-
-export const ModelSwitched = EventV2.define({
-  type: "session.next.model.switched",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    model: ModelV2.Ref,
-  },
-})
-export type ModelSwitched = typeof ModelSwitched.Type
-
-export const Moved = EventV2.define({
-  type: "session.next.moved",
-  ...options,
-  schema: {
-    ...Base,
-    location: Location.Ref,
-    subdirectory: RelativePath.pipe(Schema.optional),
-  },
-})
-export type Moved = typeof Moved.Type
-
-export const Prompted = EventV2.define({
-  type: "session.next.prompted",
-  ...options,
-  schema: PromptFields,
-})
-export type Prompted = typeof Prompted.Type
-
-export const PromptAdmitted = EventV2.define({
-  type: "session.next.prompt.admitted",
-  ...options,
-  schema: PromptFields,
-})
-export type PromptAdmitted = typeof PromptAdmitted.Type
-
-export const ContextUpdated = EventV2.define({
-  type: "session.next.context.updated",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    text: Schema.String,
-  },
-})
-export type ContextUpdated = typeof ContextUpdated.Type
-
-export const Synthetic = EventV2.define({
-  type: "session.next.synthetic",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    text: Schema.String,
-  },
-})
-export type Synthetic = typeof Synthetic.Type
-
-export namespace Shell {
-  export const Started = EventV2.define({
-    type: "session.next.shell.started",
-    ...options,
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      callID: Schema.String,
-      command: Schema.String,
-    },
-  })
-  export type Started = typeof Started.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.shell.ended",
-    ...options,
-    schema: {
-      ...Base,
-      callID: Schema.String,
-      output: Schema.String,
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-export namespace Step {
-  export const Started = EventV2.define({
-    type: "session.next.step.started",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      agent: Schema.String,
-      model: ModelV2.Ref,
-      snapshot: Schema.String.pipe(Schema.optional),
-    },
-  })
-  export type Started = typeof Started.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.step.ended",
-    ...stepSettlementOptions,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      finish: Schema.String,
-      cost: Schema.Finite,
-      tokens: Schema.Struct({
-        input: Schema.Finite,
-        output: Schema.Finite,
-        reasoning: Schema.Finite,
-        cache: Schema.Struct({
-          read: Schema.Finite,
-          write: Schema.Finite,
-        }),
-      }),
-      snapshot: Schema.String.pipe(Schema.optional),
-    },
-  })
-  export type Ended = typeof Ended.Type
-
-  export const Failed = EventV2.define({
-    type: "session.next.step.failed",
-    ...stepSettlementOptions,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      error: UnknownError,
-    },
-  })
-  export type Failed = typeof Failed.Type
-}
-
-export namespace Text {
-  export const Started = EventV2.define({
-    type: "session.next.text.started",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      textID: Schema.String,
-    },
-  })
-  export type Started = typeof Started.Type
-
-  // Stream fragments are live-only; Text.Ended is the replayable full-value boundary.
-  export const Delta = EventV2.define({
-    type: "session.next.text.delta",
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      textID: Schema.String,
-      delta: Schema.String,
-    },
-  })
-  export type Delta = typeof Delta.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.text.ended",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      textID: Schema.String,
-      text: Schema.String,
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-export namespace Reasoning {
-  export const Started = EventV2.define({
-    type: "session.next.reasoning.started",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      reasoningID: Schema.String,
-      providerMetadata: ProviderMetadata.pipe(Schema.optional),
-    },
-  })
-  export type Started = typeof Started.Type
-
-  // Stream fragments are live-only; Reasoning.Ended is the replayable full-value boundary.
-  export const Delta = EventV2.define({
-    type: "session.next.reasoning.delta",
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      reasoningID: Schema.String,
-      delta: Schema.String,
-    },
-  })
-  export type Delta = typeof Delta.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.reasoning.ended",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      reasoningID: Schema.String,
-      text: Schema.String,
-      providerMetadata: ProviderMetadata.pipe(Schema.optional),
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-export namespace Tool {
-  const ToolBase = {
-    ...Base,
-    assistantMessageID: SessionMessageID.ID,
-    callID: Schema.String,
-  }
-
-  export namespace Input {
-    export const Started = EventV2.define({
-      type: "session.next.tool.input.started",
-      ...options,
-      schema: {
-        ...ToolBase,
-        name: Schema.String,
-      },
-    })
-    export type Started = typeof Started.Type
-
-    // Stream fragments are live-only; Input.Ended is the replayable raw-input boundary.
-    export const Delta = EventV2.define({
-      type: "session.next.tool.input.delta",
-      schema: {
-        ...ToolBase,
-        delta: Schema.String,
-      },
-    })
-    export type Delta = typeof Delta.Type
-
-    export const Ended = EventV2.define({
-      type: "session.next.tool.input.ended",
-      ...options,
-      schema: {
-        ...ToolBase,
-        text: Schema.String,
-      },
-    })
-    export type Ended = typeof Ended.Type
-  }
-
-  export const Called = EventV2.define({
-    type: "session.next.tool.called",
-    ...options,
-    schema: {
-      ...ToolBase,
-      tool: Schema.String,
-      input: Schema.Record(Schema.String, Schema.Unknown),
-      provider: Schema.Struct({
-        executed: Schema.Boolean,
-        metadata: ProviderMetadata.pipe(Schema.optional),
-      }),
-    },
-  })
-  export type Called = typeof Called.Type
-
-  /**
-   * Replayable bounded running-tool state. Tools should checkpoint semantic
-   * transitions or at a bounded cadence, not persist every stdout/stderr chunk.
-   */
-  export const Progress = EventV2.define({
-    type: "session.next.tool.progress",
-    ...options,
-    schema: {
-      ...ToolBase,
-      structured: Schema.Record(Schema.String, Schema.Any),
-      content: Schema.Array(ToolContent),
-    },
-  })
-  export type Progress = typeof Progress.Type
-
-  export const Success = EventV2.define({
-    type: "session.next.tool.success",
-    ...options,
-    schema: {
-      ...ToolBase,
-      structured: Schema.Record(Schema.String, Schema.Any),
-      content: Schema.Array(ToolContent),
-      outputPaths: Schema.Array(Schema.String).pipe(Schema.optional),
-      result: Schema.Unknown.pipe(Schema.optional),
-      provider: Schema.Struct({
-        executed: Schema.Boolean,
-        metadata: ProviderMetadata.pipe(Schema.optional),
-      }),
-    },
-  })
-  export type Success = typeof Success.Type
-
-  export const Failed = EventV2.define({
-    type: "session.next.tool.failed",
-    ...options,
-    schema: {
-      ...ToolBase,
-      error: UnknownError,
-      result: Schema.Unknown.pipe(Schema.optional),
-      provider: Schema.Struct({
-        executed: Schema.Boolean,
-        metadata: ProviderMetadata.pipe(Schema.optional),
-      }),
-    },
-  })
-  export type Failed = typeof Failed.Type
-}
-
-export const RetryError = Schema.Struct({
-  message: Schema.String,
-  statusCode: Schema.Finite.pipe(Schema.optional),
-  isRetryable: Schema.Boolean,
-  responseHeaders: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
-  responseBody: Schema.String.pipe(Schema.optional),
-  metadata: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
-}).annotate({
-  identifier: "session.next.retry_error",
-})
-export type RetryError = typeof RetryError.Type
-
-export const Retried = EventV2.define({
-  type: "session.next.retried",
-  ...options,
-  schema: {
-    ...Base,
-    attempt: Schema.Finite,
-    error: RetryError,
-  },
-})
-export type Retried = typeof Retried.Type
-
-export namespace Compaction {
-  export const Started = EventV2.define({
-    type: "session.next.compaction.started",
-    ...options,
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      reason: Schema.Union([Schema.Literal("auto"), Schema.Literal("manual")]),
-    },
-  })
-  export type Started = typeof Started.Type
-
-  export const Delta = EventV2.define({
-    type: "session.next.compaction.delta",
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      text: Schema.String,
-    },
-  })
-  export type Delta = typeof Delta.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.compaction.ended",
-    ...options,
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      reason: Started.data.fields.reason,
-      text: Schema.String,
-      recent: Schema.String,
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-const DurableDefinitions = [
-  AgentSwitched,
-  ModelSwitched,
-  Moved,
-  Prompted,
-  PromptAdmitted,
-  ContextUpdated,
-  Synthetic,
-  Shell.Started,
-  Shell.Ended,
-  Step.Started,
-  Step.Ended,
-  Step.Failed,
-  Text.Started,
-  Text.Ended,
-  Tool.Input.Started,
-  Tool.Input.Ended,
-  Tool.Called,
-  Tool.Progress,
-  Tool.Success,
-  Tool.Failed,
-  Reasoning.Started,
-  Reasoning.Ended,
-  Retried,
-  Compaction.Started,
-  Compaction.Ended,
-] as const
-const EphemeralDefinitions = [Text.Delta, Tool.Input.Delta, Reasoning.Delta, Compaction.Delta] as const
-
-export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"))
-export type DurableEvent = typeof Durable.Type
-
-export const All = Schema.Union([...DurableDefinitions, ...EphemeralDefinitions], { mode: "oneOf" }).pipe(
-  Schema.toTaggedUnion("type"),
-)
-export type Event = typeof All.Type
-export type Type = Event["type"]
-
-export * as SessionEvent from "./event"
+export * from "@opencode-ai/schema/session-event"
+export { SessionEvent } from "@opencode-ai/schema/session-event"

packages/core/src/session/input.ts

@@ -2,10 +2,9 @@ export * as SessionInput from "./input"
 
 import { and, asc, eq, isNull, lte } from "drizzle-orm"
 import { DateTime, Effect, Schema } from "effect"
+import { Admitted, Delivery } from "@opencode-ai/schema/session-input"
 import type { Database } from "../database/database"
 import type { EventV2 } from "../event"
-import { NonNegativeInt } from "../schema"
-import { V2Schema } from "../v2-schema"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 import { Prompt } from "./prompt"
@@ -14,24 +13,13 @@ import { SessionInputTable, SessionMessageTable } from "./sql"
 
 type DatabaseService = Database.Interface["db"]
 
-export const Delivery = Schema.Literals(["steer", "queue"])
-export type Delivery = typeof Delivery.Type
-
-export class Admitted extends Schema.Class<Admitted>("SessionInput.Admitted")({
-  admittedSeq: NonNegativeInt,
-  id: SessionMessage.ID,
-  sessionID: SessionSchema.ID,
-  prompt: Prompt,
-  delivery: Delivery,
-  timeCreated: V2Schema.DateTimeUtcFromMillis,
-  promotedSeq: NonNegativeInt.pipe(Schema.optional),
-}) {}
+export { Admitted, Delivery }
 
 const decodePrompt = Schema.decodeUnknownSync(Prompt)
 const encodePrompt = Schema.encodeSync(Prompt)
 
 const fromRow = (row: typeof SessionInputTable.$inferSelect): Admitted =>
-  new Admitted({
+  Admitted.make({
     admittedSeq: row.admitted_seq,
     id: SessionMessage.ID.make(row.id),
     sessionID: SessionSchema.ID.make(row.session_id),
@@ -76,7 +64,7 @@ export const admit = Effect.fn("SessionInput.admit")(function* (
         event.durable === undefined
           ? Effect.die("Prompt admission event is missing aggregate sequence")
           : Effect.succeed(
-              new Admitted({
+              Admitted.make({
                 admittedSeq: event.durable.seq,
                 id: input.id,
                 sessionID: input.sessionID,

packages/core/src/session/message-id.ts

@@ -1,13 +1,2 @@
 export * as SessionMessageID from "./message-id"
-
-import { Schema } from "effect"
-import { withStatics } from "../schema"
-import { Identifier } from "../util/identifier"
-
-export const ID = Schema.String.check(Schema.isStartsWith("msg_")).pipe(
-  Schema.brand("Session.Message.ID"),
-  withStatics((schema) => ({
-    create: () => schema.make("msg_" + Identifier.ascending()),
-  })),
-)
-export type ID = typeof ID.Type
+export { ID } from "@opencode-ai/schema/session-message-id"

packages/core/src/session/message-updater.ts

@@ -102,7 +102,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
     yield* SessionEvent.All.match(event, {
       "session.next.agent.switched": (event) => {
         return adapter.appendMessage(
-          new SessionMessage.AgentSwitched({
+          SessionMessage.AgentSwitched.make({
             id: event.data.messageID,
             type: "agent-switched",
             metadata: event.metadata,
@@ -113,7 +113,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       },
       "session.next.model.switched": (event) => {
         return adapter.appendMessage(
-          new SessionMessage.ModelSwitched({
+          SessionMessage.ModelSwitched.make({
             id: event.data.messageID,
             type: "model-switched",
             metadata: event.metadata,
@@ -125,7 +125,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.next.moved": () => Effect.void,
       "session.next.prompted": (event) => {
         return adapter.appendMessage(
-          new SessionMessage.User({
+          SessionMessage.User.make({
             id: event.data.messageID,
             type: "user",
             metadata: event.metadata,
@@ -139,7 +139,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.next.prompt.admitted": () => Effect.void,
       "session.next.context.updated": (event) =>
         adapter.appendMessage(
-          new SessionMessage.System({
+          SessionMessage.System.make({
             id: event.data.messageID,
             type: "system",
             text: event.data.text,
@@ -148,7 +148,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         ),
       "session.next.synthetic": (event) => {
         return adapter.appendMessage(
-          new SessionMessage.Synthetic({
+          SessionMessage.Synthetic.make({
             sessionID: event.data.sessionID,
             text: event.data.text,
             id: event.data.messageID,
@@ -159,7 +159,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       },
       "session.next.shell.started": (event) => {
         return adapter.appendMessage(
-          new SessionMessage.Shell({
+          SessionMessage.Shell.make({
             id: event.data.messageID,
             type: "shell",
             metadata: event.metadata,
@@ -194,7 +194,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             )
           }
           yield* adapter.appendMessage(
-            new SessionMessage.Assistant({
+            SessionMessage.Assistant.make({
               id: event.data.assistantMessageID,
               type: "assistant",
               agent: event.data.agent,
@@ -225,7 +225,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.next.text.started": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.content.push(
-            castDraft(new SessionMessage.AssistantText({ type: "text", id: event.data.textID, text: "" })),
+            castDraft(SessionMessage.AssistantText.make({ type: "text", id: event.data.textID, text: "" })),
           )
         })
       },
@@ -245,12 +245,12 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.content.push(
             castDraft(
-              new SessionMessage.AssistantTool({
+              SessionMessage.AssistantTool.make({
                 type: "tool",
                 id: event.data.callID,
                 name: event.data.name,
                 time: { created: event.data.timestamp },
-                state: new SessionMessage.ToolStatePending({ status: "pending", input: "" }),
+                state: SessionMessage.ToolStatePending.make({ status: "pending", input: "" }),
               }),
             ),
           )
@@ -270,7 +270,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             match.provider = event.data.provider
             match.time.ran = event.data.timestamp
             match.state = castDraft(
-              new SessionMessage.ToolStateRunning({
+              SessionMessage.ToolStateRunning.make({
                 status: "running",
                 input: event.data.input,
                 structured: {},
@@ -300,7 +300,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             }
             match.time.completed = event.data.timestamp
             match.state = castDraft(
-              new SessionMessage.ToolStateCompleted({
+              SessionMessage.ToolStateCompleted.make({
                 status: "completed",
                 input: match.state.input,
                 structured: event.data.structured,
@@ -323,7 +323,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             }
             match.time.completed = event.data.timestamp
             match.state = castDraft(
-              new SessionMessage.ToolStateError({
+              SessionMessage.ToolStateError.make({
                 status: "error",
                 error: event.data.error,
                 input: typeof match.state.input === "string" ? {} : match.state.input,
@@ -339,7 +339,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.content.push(
             castDraft(
-              new SessionMessage.AssistantReasoning({
+              SessionMessage.AssistantReasoning.make({
                 type: "reasoning",
                 id: event.data.reasoningID,
                 text: "",
@@ -369,7 +369,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.next.compaction.delta": () => Effect.void,
       "session.next.compaction.ended": (event) => {
         return adapter.appendMessage(
-          new SessionMessage.Compaction({
+          SessionMessage.Compaction.make({
             id: event.data.messageID,
             type: "compaction",
             metadata: event.metadata,

packages/core/src/session/message.ts

@@ -1,193 +1,2 @@
 export * as SessionMessage from "./message"
-
-import { Schema } from "effect"
-import { ProviderMetadata, ToolContent } from "@opencode-ai/llm"
-import { ModelV2 } from "../model"
-import { V2Schema } from "../v2-schema"
-import { SessionEvent } from "./event"
-import { Prompt } from "./prompt"
-import { SessionMessageID } from "./message-id"
-
-export const ID = SessionMessageID.ID
-export type ID = typeof ID.Type
-
-const Base = {
-  id: ID,
-  metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
-  time: Schema.Struct({
-    created: V2Schema.DateTimeUtcFromMillis,
-  }),
-}
-
-export class AgentSwitched extends Schema.Class<AgentSwitched>("Session.Message.AgentSwitched")({
-  ...Base,
-  type: Schema.Literal("agent-switched"),
-  agent: SessionEvent.AgentSwitched.data.fields.agent,
-}) {}
-
-export class ModelSwitched extends Schema.Class<ModelSwitched>("Session.Message.ModelSwitched")({
-  ...Base,
-  type: Schema.Literal("model-switched"),
-  model: ModelV2.Ref,
-}) {}
-
-export class User extends Schema.Class<User>("Session.Message.User")({
-  ...Base,
-  text: Prompt.fields.text,
-  files: Prompt.fields.files,
-  agents: Prompt.fields.agents,
-  type: Schema.Literal("user"),
-  time: Schema.Struct({
-    created: V2Schema.DateTimeUtcFromMillis,
-  }),
-}) {}
-
-export class Synthetic extends Schema.Class<Synthetic>("Session.Message.Synthetic")({
-  ...Base,
-  sessionID: SessionEvent.Synthetic.data.fields.sessionID,
-  text: SessionEvent.Synthetic.data.fields.text,
-  type: Schema.Literal("synthetic"),
-}) {}
-
-export class System extends Schema.Class<System>("Session.Message.System")({
-  ...Base,
-  type: Schema.Literal("system"),
-  text: SessionEvent.ContextUpdated.data.fields.text,
-}) {}
-
-export class Shell extends Schema.Class<Shell>("Session.Message.Shell")({
-  ...Base,
-  type: Schema.Literal("shell"),
-  callID: SessionEvent.Shell.Started.data.fields.callID,
-  command: SessionEvent.Shell.Started.data.fields.command,
-  output: Schema.String,
-  time: Schema.Struct({
-    created: V2Schema.DateTimeUtcFromMillis,
-    completed: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
-  }),
-}) {}
-
-export class ToolStatePending extends Schema.Class<ToolStatePending>("Session.Message.ToolState.Pending")({
-  status: Schema.Literal("pending"),
-  input: Schema.String,
-}) {}
-
-export class ToolStateRunning extends Schema.Class<ToolStateRunning>("Session.Message.ToolState.Running")({
-  status: Schema.Literal("running"),
-  input: Schema.Record(Schema.String, Schema.Unknown),
-  structured: Schema.Record(Schema.String, Schema.Any),
-  content: ToolContent.pipe(Schema.Array),
-}) {}
-
-export class ToolStateCompleted extends Schema.Class<ToolStateCompleted>("Session.Message.ToolState.Completed")({
-  status: Schema.Literal("completed"),
-  input: Schema.Record(Schema.String, Schema.Unknown),
-  attachments: SessionEvent.FileAttachment.pipe(Schema.Array, Schema.optional),
-  content: ToolContent.pipe(Schema.Array),
-  outputPaths: SessionEvent.Tool.Success.data.fields.outputPaths,
-  structured: Schema.Record(Schema.String, Schema.Any),
-  result: SessionEvent.Tool.Success.data.fields.result,
-}) {}
-
-export class ToolStateError extends Schema.Class<ToolStateError>("Session.Message.ToolState.Error")({
-  status: Schema.Literal("error"),
-  input: Schema.Record(Schema.String, Schema.Unknown),
-  content: ToolContent.pipe(Schema.Array),
-  structured: Schema.Record(Schema.String, Schema.Any),
-  error: SessionEvent.UnknownError,
-  result: SessionEvent.Tool.Failed.data.fields.result,
-}) {}
-
-export const ToolState = Schema.Union([ToolStatePending, ToolStateRunning, ToolStateCompleted, ToolStateError]).pipe(
-  Schema.toTaggedUnion("status"),
-)
-export type ToolState = Schema.Schema.Type<typeof ToolState>
-
-export class AssistantTool extends Schema.Class<AssistantTool>("Session.Message.Assistant.Tool")({
-  type: Schema.Literal("tool"),
-  id: Schema.String,
-  name: Schema.String,
-  provider: Schema.Struct({
-    executed: Schema.Boolean,
-    metadata: ProviderMetadata.pipe(Schema.optional),
-    resultMetadata: ProviderMetadata.pipe(Schema.optional),
-  }).pipe(Schema.optional),
-  state: ToolState,
-  time: Schema.Struct({
-    created: V2Schema.DateTimeUtcFromMillis,
-    ran: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
-    completed: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
-    pruned: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
-  }),
-}) {}
-
-export class AssistantText extends Schema.Class<AssistantText>("Session.Message.Assistant.Text")({
-  type: Schema.Literal("text"),
-  id: Schema.String,
-  text: Schema.String,
-}) {}
-
-export class AssistantReasoning extends Schema.Class<AssistantReasoning>("Session.Message.Assistant.Reasoning")({
-  type: Schema.Literal("reasoning"),
-  id: Schema.String,
-  text: Schema.String,
-  providerMetadata: ProviderMetadata.pipe(Schema.optional),
-}) {}
-
-export const AssistantContent = Schema.Union([AssistantText, AssistantReasoning, AssistantTool]).pipe(
-  Schema.toTaggedUnion("type"),
-)
-export type AssistantContent = Schema.Schema.Type<typeof AssistantContent>
-
-export class Assistant extends Schema.Class<Assistant>("Session.Message.Assistant")({
-  ...Base,
-  type: Schema.Literal("assistant"),
-  agent: Schema.String,
-  model: SessionEvent.Step.Started.data.fields.model,
-  content: AssistantContent.pipe(Schema.Array),
-  snapshot: Schema.Struct({
-    start: Schema.String.pipe(Schema.optional),
-    end: Schema.String.pipe(Schema.optional),
-  }).pipe(Schema.optional),
-  finish: Schema.String.pipe(Schema.optional),
-  cost: Schema.Finite.pipe(Schema.optional),
-  tokens: Schema.Struct({
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }).pipe(Schema.optional),
-  error: SessionEvent.Step.Failed.data.fields.error.pipe(Schema.optional),
-  time: Schema.Struct({
-    created: V2Schema.DateTimeUtcFromMillis,
-    completed: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
-  }),
-}) {}
-
-export class Compaction extends Schema.Class<Compaction>("Session.Message.Compaction")({
-  type: Schema.Literal("compaction"),
-  reason: SessionEvent.Compaction.Started.data.fields.reason,
-  summary: Schema.String,
-  recent: Schema.String,
-  ...Base,
-}) {}
-
-export const Message = Schema.Union([
-  AgentSwitched,
-  ModelSwitched,
-  User,
-  Synthetic,
-  System,
-  Shell,
-  Assistant,
-  Compaction,
-])
-  .pipe(Schema.toTaggedUnion("type"))
-  .annotate({ identifier: "Session.Message" })
-
-export type Message = Schema.Schema.Type<typeof Message>
-
-export type Type = Message["type"]
+export * from "@opencode-ai/schema/session-message"

packages/core/src/session/prompt.ts

@@ -1,46 +1 @@
-import * as Schema from "effect/Schema"
-
-export class Source extends Schema.Class<Source>("Prompt.Source")({
-  start: Schema.Finite,
-  end: Schema.Finite,
-  text: Schema.String,
-}) {}
-
-export class FileAttachment extends Schema.Class<FileAttachment>("Prompt.FileAttachment")({
-  uri: Schema.String,
-  mime: Schema.String,
-  name: Schema.String.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  source: Source.pipe(Schema.optional),
-}) {
-  static create(input: FileAttachment) {
-    return new FileAttachment({
-      uri: input.uri,
-      mime: input.mime,
-      name: input.name,
-      description: input.description,
-      source: input.source,
-    })
-  }
-}
-
-export class AgentAttachment extends Schema.Class<AgentAttachment>("Prompt.AgentAttachment")({
-  name: Schema.String,
-  source: Source.pipe(Schema.optional),
-}) {}
-
-export class Prompt extends Schema.Class<Prompt>("Prompt")({
-  text: Schema.String,
-  files: Schema.Array(FileAttachment).pipe(Schema.optional),
-  agents: Schema.Array(AgentAttachment).pipe(Schema.optional),
-}) {
-  static readonly equivalence = Schema.toEquivalence(Prompt)
-
-  static fromUserMessage(input: Pick<Prompt, "text" | "files" | "agents">) {
-    return new Prompt({
-      text: input.text,
-      ...(input.files === undefined ? {} : { files: input.files }),
-      ...(input.agents === undefined ? {} : { agents: input.agents }),
-    })
-  }
-}
+export { AgentAttachment, FileAttachment, Prompt, Source } from "@opencode-ai/schema/prompt"

packages/core/src/session/runner/model.ts

@@ -10,7 +10,6 @@ import { produce } from "immer"
 import { Catalog } from "../../catalog"
 import { Credential } from "../../credential"
 import { Integration } from "../../integration"
-import { IntegrationConnection } from "../../integration/connection"
 import { ModelV2 } from "../../model"
 import { ModelRequest } from "../../model-request"
 import { ProviderV2 } from "../../provider"
@@ -21,7 +20,11 @@ export class ModelNotSelectedError extends Schema.TaggedErrorClass<ModelNotSelec
   {
     sessionID: SessionSchema.ID,
   },
-) {}
+) {
+  override get message() {
+    return `No model is available for session ${this.sessionID}`
+  }
+}
 
 export class ModelUnavailableError extends Schema.TaggedErrorClass<ModelUnavailableError>()(
   "SessionRunnerModel.ModelUnavailableError",
@@ -29,7 +32,11 @@ export class ModelUnavailableError extends Schema.TaggedErrorClass<ModelUnavaila
     providerID: ProviderV2.ID,
     modelID: ModelV2.ID,
   },
-) {}
+) {
+  override get message() {
+    return `Model unavailable: ${this.providerID}/${this.modelID}`
+  }
+}
 
 export class VariantUnavailableError extends Schema.TaggedErrorClass<VariantUnavailableError>()(
   "SessionRunnerModel.VariantUnavailableError",
@@ -38,7 +45,11 @@ export class VariantUnavailableError extends Schema.TaggedErrorClass<VariantUnav
     modelID: ModelV2.ID,
     variant: ModelV2.VariantID,
   },
-) {}
+) {
+  override get message() {
+    return `Variant unavailable for ${this.providerID}/${this.modelID}: ${this.variant}`
+  }
+}
 
 export class UnsupportedApiError extends Schema.TaggedErrorClass<UnsupportedApiError>()(
   "SessionRunnerModel.UnsupportedApiError",
@@ -47,9 +58,18 @@ export class UnsupportedApiError extends Schema.TaggedErrorClass<UnsupportedApiE
     modelID: ModelV2.ID,
     api: Schema.String,
   },
-) {}
+) {
+  override get message() {
+    return `Unsupported API for ${this.providerID}/${this.modelID}: ${this.api}`
+  }
+}
 
-export type Error = ModelNotSelectedError | ModelUnavailableError | VariantUnavailableError | UnsupportedApiError
+export type Error =
+  | ModelNotSelectedError
+  | ModelUnavailableError
+  | VariantUnavailableError
+  | UnsupportedApiError
+  | Integration.AuthorizationError
 
 export interface Interface {
   readonly resolve: (session: SessionSchema.Info) => Effect.Effect<Model, Error>
@@ -60,12 +80,11 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 /** Test or embedding seam for supplying a model resolver directly. */
 export const layerWith = (resolve: Interface["resolve"]) => Layer.succeed(Service, Service.of({ resolve }))
 
-const apiKey = (model: ModelV2.Info, connection?: IntegrationConnection.Info, credential?: Credential.Info) => {
-  if (credential?.value.type === "key") return Auth.value(credential.value.key)
-  if (credential?.value.type === "oauth") return Auth.value(credential.value.access)
+const apiKey = (model: ModelV2.Info, credential?: Credential.Value) => {
+  if (credential?.type === "key") return Auth.value(credential.key)
+  if (credential?.type === "oauth") return Auth.value(credential.access)
   const value = model.request.body.apiKey ?? model.api.settings?.apiKey
   if (typeof value === "string") return Auth.value(value)
-  return connection?.type === "env" ? Auth.config(connection.name) : undefined
 }
 
 const withDefaults = (model: ModelV2.Info, route: AnyRoute) => {
@@ -114,16 +133,15 @@ const apiName = (model: ModelV2.Info) =>
 
 export const fromCatalogModel = (
   model: ModelV2.Info,
-  connection?: IntegrationConnection.Info,
-  credential?: Credential.Info,
+  credential?: Credential.Value,
 ): Effect.Effect<Model, UnsupportedApiError> => {
   const resolved =
-    credential?.value.metadata === undefined
+    credential?.metadata === undefined
       ? model
       : produce(model, (draft) => {
-          Object.assign(draft.request.body, credential.value.metadata)
+          Object.assign(draft.request.body, credential.metadata)
         })
-  const key = apiKey(resolved, connection, credential)
+  const key = apiKey(resolved, credential)
   if (resolved.api.type === "aisdk" && resolved.api.package === "@ai-sdk/openai") {
     return Effect.succeed(
       withDefaults(resolved, OpenAIResponses.route)
@@ -154,15 +172,8 @@ export const fromCatalogModel = (
   )
 }
 
-export const resolve = (
-  session: SessionSchema.Info,
-  model: ModelV2.Info,
-  connection?: IntegrationConnection.Info,
-  credential?: Credential.Info,
-) =>
-  withVariant(model, session.model?.variant).pipe(
-    Effect.flatMap((model) => fromCatalogModel(model, connection, credential)),
-  )
+export const resolve = (session: SessionSchema.Info, model: ModelV2.Info, credential?: Credential.Value) =>
+  withVariant(model, session.model?.variant).pipe(Effect.flatMap((model) => fromCatalogModel(model, credential)))
 
 export const supported = (model: ModelV2.Info) =>
   model.api.type === "aisdk" &&
@@ -175,7 +186,6 @@ export const locationLayer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const catalog = yield* Catalog.Service
-    const credentials = yield* Credential.Service
     const integrations = yield* Integration.Service
     return Service.of({
       resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session) {
@@ -194,12 +204,14 @@ export const locationLayer = Layer.effect(
             modelID: session.model.id,
           })
         if (!selected) return yield* new ModelNotSelectedError({ sessionID: session.id })
-        const connection = yield* integrations.connection.forIntegration(Integration.ID.make(selected.providerID))
+        const provider = yield* catalog.provider.get(selected.providerID)
+        const connection = yield* integrations.connection.active(
+          provider?.integrationID ?? Integration.ID.make(selected.providerID),
+        )
         return yield* resolve(
           session,
           selected,
-          connection,
-          connection?.type === "credential" ? yield* credentials.get(connection.id) : undefined,
+          connection ? yield* integrations.connection.resolve(connection) : undefined,
         )
       }),
     })

packages/core/src/session/schema.ts

@@ -1,49 +1,9 @@
 export * as SessionSchema from "./schema"
 
-import { Schema } from "effect"
-import { Location } from "../location"
-import { ModelV2 } from "../model"
-import { ProjectV2 } from "../project"
-import { externalID, type ExternalID, RelativePath, optionalOmitUndefined, withStatics } from "../schema"
-import { Identifier } from "../util/identifier"
-import { V2Schema } from "../v2-schema"
-import { AgentV2 } from "../agent"
+import { Session } from "@opencode-ai/schema/session"
 
-export const ID = Schema.String.check(Schema.isStartsWith("ses")).pipe(
-  Schema.brand("SessionID"),
-  withStatics((schema) => {
-    const create = () => schema.make("ses_" + Identifier.descending())
-    return {
-      create,
-      descending: (id?: string) => (id === undefined ? create() : schema.make(id)),
-      fromExternal: (input: ExternalID) => schema.make(externalID("ses", input)),
-    }
-  }),
-)
+export const ID = Session.ID
 export type ID = typeof ID.Type
 
-export class Info extends Schema.Class<Info>("SessionV2.Info")({
-  id: ID,
-  parentID: ID.pipe(optionalOmitUndefined),
-  projectID: ProjectV2.ID,
-  agent: AgentV2.ID.pipe(Schema.optional),
-  model: ModelV2.Ref.pipe(Schema.optional),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-  time: Schema.Struct({
-    created: V2Schema.DateTimeUtcFromMillis,
-    updated: V2Schema.DateTimeUtcFromMillis,
-    archived: V2Schema.DateTimeUtcFromMillis.pipe(Schema.optional),
-  }),
-  title: Schema.String,
-  location: Location.Ref,
-  subpath: RelativePath.pipe(Schema.optional),
-}) {}
+export const Info = Session.Info
+export type Info = Session.Info

packages/core/src/session/todo.ts

@@ -1,30 +1,16 @@
 export * as SessionTodo from "./todo"
 
 import { asc, eq } from "drizzle-orm"
-import { Context, Effect, Layer, Schema } from "effect"
+import { Context, Effect, Layer } from "effect"
+import { Todo } from "@opencode-ai/schema/todo"
 import { Database } from "../database/database"
 import { EventV2 } from "../event"
 import { SessionSchema } from "./schema"
 import { TodoTable } from "./sql"
 
-export const Info = Schema.Struct({
-  content: Schema.String.annotate({ description: "Brief description of the task" }),
-  status: Schema.String.annotate({
-    description: "Current status of the task: pending, in_progress, completed, cancelled",
-  }),
-  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
-}).annotate({ identifier: "SessionTodo.Info" })
-export type Info = typeof Info.Type
-
-export const Event = {
-  Updated: EventV2.define({
-    type: "todo.updated",
-    schema: {
-      sessionID: SessionSchema.ID,
-      todos: Schema.Array(Info),
-    },
-  }),
-}
+export const Info = Todo.Info
+export type Info = Todo.Info
+export const Event = Todo.Event
 
 export interface Interface {
   readonly update: (input: {

packages/core/src/skill.ts

@@ -2,56 +2,29 @@ export * as SkillV2 from "./skill"
 
 import path from "path"
 import { Context, Effect, Layer, Schema, Types } from "effect"
+import { Skill } from "@opencode-ai/schema/skill"
 import { AgentV2 } from "./agent"
 import { ConfigMarkdown } from "./config/markdown"
 import { FSUtil } from "./fs-util"
 import { PermissionV2 } from "./permission"
-import { AbsolutePath, withStatics } from "./schema"
+import { AbsolutePath } from "./schema"
 import { SkillDiscovery } from "./skill/discovery"
 import { State } from "./state"
 
-export class DirectorySource extends Schema.Class<DirectorySource>("SkillV2.DirectorySource")({
-  type: Schema.Literal("directory"),
-  path: AbsolutePath,
-}) {}
+export const DirectorySource = Skill.DirectorySource
+export type DirectorySource = Skill.DirectorySource
 
-export class UrlSource extends Schema.Class<UrlSource>("SkillV2.UrlSource")({
-  type: Schema.Literal("url"),
-  url: Schema.String,
-}) {}
+export const UrlSource = Skill.UrlSource
+export type UrlSource = Skill.UrlSource
 
-export class EmbeddedSource extends Schema.Class<EmbeddedSource>("SkillV2.EmbeddedSource")({
-  type: Schema.Literal("embedded"),
-  skill: Schema.suspend(() => Info),
-}) {}
+export const EmbeddedSource = Skill.EmbeddedSource
+export type EmbeddedSource = Skill.EmbeddedSource
 
-export const Source = Schema.Union([DirectorySource, UrlSource, EmbeddedSource]).pipe(
-  Schema.toTaggedUnion("type"),
-  withStatics(() => ({
-    equals: (a: DirectorySource | UrlSource | EmbeddedSource, b: DirectorySource | UrlSource | EmbeddedSource) => {
-      if (a.type !== b.type) return false
-      if (a.type === "directory" && b.type === "directory") return a.path === b.path
-      if (a.type === "url" && b.type === "url") return a.url === b.url
-      if (a.type === "embedded" && b.type === "embedded") return a.skill.name === b.skill.name
-      return false
-    },
-    key: (source: DirectorySource | UrlSource | EmbeddedSource) =>
-      source.type === "directory"
-        ? `directory:${source.path}`
-        : source.type === "url"
-          ? `url:${source.url}`
-          : `embedded:${source.skill.name}`,
-  })),
-)
+export const Source = Skill.Source
 export type Source = typeof Source.Type
 
-export class Info extends Schema.Class<Info>("SkillV2.Info")({
-  name: Schema.String,
-  description: Schema.String.pipe(Schema.optional),
-  slash: Schema.Boolean.pipe(Schema.optional),
-  location: AbsolutePath,
-  content: Schema.String,
-}) {}
+export const Info = Skill.Info
+export type Info = Skill.Info
 
 export const available = (skills: ReadonlyArray<Info>, agent: AgentV2.Info) =>
   skills.filter((skill) => PermissionV2.evaluate("skill", skill.name, agent.permissions).effect !== "deny")
@@ -118,15 +91,13 @@ export const layer = Layer.effect(
                 ? path.basename(filepath, ".md")
                 : undefined
           if (!name) continue
-          skills.push(
-            new Info({
-              name,
-              description: frontmatter.description,
-              slash: frontmatter.slash,
-              location: AbsolutePath.make(filepath),
-              content: markdown.content,
-            }),
-          )
+          skills.push({
+            name,
+            description: frontmatter.description,
+            slash: frontmatter.slash,
+            location: AbsolutePath.make(filepath),
+            content: markdown.content,
+          })
         }
       }
       return skills

packages/core/src/system-context/index.ts

@@ -82,7 +82,11 @@ export type ReconcileResult = { readonly _tag: "Unchanged" } | Updated | Replace
 export class InitializationBlocked extends Schema.TaggedErrorClass<InitializationBlocked>()(
   "SystemContext.InitializationBlocked",
   { keys: Schema.Array(Key) },
-) {}
+) {
+  override get message() {
+    return `System context initialization blocked by unavailable sources: ${this.keys.join(", ")}`
+  }
+}
 
 export class DuplicateKeyError extends Schema.TaggedErrorClass<DuplicateKeyError>()("SystemContext.DuplicateKeyError", {
   key: Key,

packages/core/src/tool-output-store.ts

@@ -29,7 +29,12 @@ export interface BoundResult {
 export class StorageError extends Schema.TaggedErrorClass<StorageError>()("ToolOutputStore.StorageError", {
   operation: Schema.Literals(["encode", "write"]),
   cause: Schema.Defect(),
-}) {}
+}) {
+  override get message() {
+    const detail = this.cause instanceof Error ? this.cause.message : String(this.cause)
+    return `Failed to ${this.operation} tool output${detail ? `: ${detail}` : ""}`
+  }
+}
 
 export type Error = StorageError
 

packages/core/src/tool/glob.ts

@@ -79,12 +79,11 @@ export const layer = Layer.effectDiscard(
                 })
                 .pipe(
                   Effect.map((result) =>
-                    result.map(
-                      (entry) =>
-                        new FileSystem.Entry({
-                          ...entry,
-                          path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
-                        }),
+                    result.map((entry) =>
+                      FileSystem.Entry.make({
+                        ...entry,
+                        path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
+                      }),
                     ),
                   ),
                 )

packages/core/src/tool/grep.ts

@@ -102,23 +102,22 @@ export const layer = Layer.effectDiscard(
                 })
                 .pipe(
                   Effect.map((result) =>
-                    result.map(
-                      (match) =>
-                        new FileSystem.Match({
-                          ...match,
-                          entry: new FileSystem.Entry({
-                            ...match.entry,
-                            path: RelativePath.make(
-                              path.relative(
-                                location.directory,
-                                path.resolve(
-                                  info?.type === "Directory" ? target : path.dirname(target),
-                                  match.entry.path,
-                                ),
+                    result.map((match) =>
+                      FileSystem.Match.make({
+                        ...match,
+                        entry: FileSystem.Entry.make({
+                          ...match.entry,
+                          path: RelativePath.make(
+                            path.relative(
+                              location.directory,
+                              path.resolve(
+                                info?.type === "Directory" ? target : path.dirname(target),
+                                match.entry.path,
                               ),
                             ),
-                          }),
+                          ),
                         }),
+                      }),
                     ),
                   ),
                 )

packages/core/src/tool/read-filesystem.ts

@@ -335,10 +335,9 @@ export const list = Effect.fn("ReadTool.list")(function* (fs: FSUtil.Interface,
         const info = yield* fs.stat(target).pipe(Effect.catch(() => Effect.void))
         const type = info?.type === "Directory" ? "directory" : info?.type === "File" ? "file" : undefined
         if (!type) return
-        return new FileSystem.Entry({
+        return FileSystem.Entry.make({
           path: RelativePath.make(item.name + (type === "directory" ? path.sep : "")),
           type,
-          mime: type === "directory" ? "application/x-directory" : FSUtil.mimeType(target),
         })
       }),
     { concurrency: 16 },

packages/core/src/util/identifier.ts

@@ -1,48 +1 @@
-import { randomBytes } from "crypto"
-
-export namespace Identifier {
-  const LENGTH = 26
-
-  // State for monotonic ID generation
-  let lastTimestamp = 0
-  let counter = 0
-
-  export function ascending() {
-    return create(false)
-  }
-
-  export function descending() {
-    return create(true)
-  }
-
-  function randomBase62(length: number): string {
-    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    let result = ""
-    const bytes = randomBytes(length)
-    for (let i = 0; i < length; i++) {
-      result += chars[bytes[i] % 62]
-    }
-    return result
-  }
-
-  export function create(descending: boolean, timestamp?: number): string {
-    const currentTimestamp = timestamp ?? Date.now()
-
-    if (currentTimestamp !== lastTimestamp) {
-      lastTimestamp = currentTimestamp
-      counter = 0
-    }
-    counter++
-
-    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
-
-    now = descending ? ~now : now
-
-    const timeBytes = Buffer.alloc(6)
-    for (let i = 0; i < 6; i++) {
-      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
-    }
-
-    return timeBytes.toString("hex") + randomBase62(LENGTH - 12)
-  }
-}
+export * as Identifier from "@opencode-ai/schema/identifier"

packages/core/src/v1/permission.ts

@@ -1,96 +1,2 @@
-export * as PermissionV1 from "./permission"
-
-import { Schema } from "effect"
-import { ProjectV2 } from "../project"
-import { withStatics } from "../schema"
-import { SessionSchema } from "../session/schema"
-import { Identifier } from "../util/identifier"
-
-export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(
-  Schema.brand("PermissionID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "per_" + Identifier.ascending()) })),
-)
-export type ID = typeof ID.Type
-
-export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionAction" })
-export type Action = typeof Action.Type
-
-export const Rule = Schema.Struct({
-  permission: Schema.String,
-  pattern: Schema.String,
-  action: Action,
-}).annotate({ identifier: "PermissionRule" })
-export type Rule = typeof Rule.Type
-
-export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionRuleset" })
-export type Ruleset = typeof Ruleset.Type
-
-export const Request = Schema.Struct({
-  id: ID,
-  sessionID: SessionSchema.ID,
-  permission: Schema.String,
-  patterns: Schema.Array(Schema.String),
-  metadata: Schema.Record(Schema.String, Schema.Unknown),
-  always: Schema.Array(Schema.String),
-  tool: Schema.Struct({
-    messageID: Schema.String,
-    callID: Schema.String,
-  }).pipe(Schema.optional),
-}).annotate({ identifier: "PermissionRequest" })
-export type Request = typeof Request.Type
-
-export const Reply = Schema.Literals(["once", "always", "reject"])
-export type Reply = typeof Reply.Type
-
-export const ReplyBody = Schema.Struct({
-  reply: Reply,
-  message: Schema.String.pipe(Schema.optional),
-}).annotate({ identifier: "PermissionReplyBody" })
-export type ReplyBody = typeof ReplyBody.Type
-
-export const Approval = Schema.Struct({
-  projectID: ProjectV2.ID,
-  patterns: Schema.Array(Schema.String),
-}).annotate({ identifier: "PermissionApproval" })
-export type Approval = typeof Approval.Type
-
-export const AskInput = Schema.Struct({
-  ...Request.fields,
-  id: ID.pipe(Schema.optional),
-  ruleset: Ruleset,
-}).annotate({ identifier: "PermissionAskInput" })
-export type AskInput = typeof AskInput.Type
-
-export const ReplyInput = Schema.Struct({
-  requestID: ID,
-  ...ReplyBody.fields,
-}).annotate({ identifier: "PermissionReplyInput" })
-export type ReplyInput = typeof ReplyInput.Type
-
-export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("PermissionRejectedError", {}) {
-  override get message() {
-    return "The user rejected permission to use this specific tool call."
-  }
-}
-
-export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("PermissionCorrectedError", {
-  feedback: Schema.String,
-}) {
-  override get message() {
-    return `The user rejected permission to use this specific tool call with the following feedback: ${this.feedback}`
-  }
-}
-
-export class DeniedError extends Schema.TaggedErrorClass<DeniedError>()("PermissionDeniedError", {
-  ruleset: Schema.Any,
-}) {
-  override get message() {
-    return `The user has specified a rule which prevents you from using this specific tool call. Here are some of the relevant rules ${JSON.stringify(this.ruleset)}`
-  }
-}
-
-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Permission.NotFoundError", {
-  requestID: ID,
-}) {}
-
-export type Error = DeniedError | RejectedError | CorrectedError
+export * from "@opencode-ai/schema/permission-v1"
+export { PermissionV1 } from "@opencode-ai/schema/permission-v1"

packages/core/src/v1/session.ts

@@ -1,632 +1,2 @@
-export * as SessionV1 from "./session"
-
-import { Effect, Schema, Types } from "effect"
-import { EventV2 } from "../event"
-import { PermissionV1 } from "./permission"
-import { ProjectV2 } from "../project"
-import { ProviderV2 } from "../provider"
-import { ModelV2 } from "../model"
-import { optionalOmitUndefined, withStatics } from "../schema"
-import { Identifier } from "../util/identifier"
-import { NonNegativeInt } from "../schema"
-import { NamedError } from "../util/error"
-import { SessionSchema } from "../session/schema"
-import { WorkspaceV2 } from "../workspace"
-
-const Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0))
-
-export const MessageID = Schema.String.check(Schema.isStartsWith("msg")).pipe(
-  Schema.brand("MessageID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "msg_" + Identifier.ascending()) })),
-)
-export type MessageID = typeof MessageID.Type
-
-export const PartID = Schema.String.check(Schema.isStartsWith("prt")).pipe(
-  Schema.brand("PartID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "prt_" + Identifier.ascending()) })),
-)
-export type PartID = typeof PartID.Type
-
-export const OutputLengthError = NamedError.create("MessageOutputLengthError", {})
-
-export const AuthError = NamedError.create("ProviderAuthError", {
-  providerID: Schema.String,
-  message: Schema.String,
-})
-
-export const AbortedError = NamedError.create("MessageAbortedError", { message: Schema.String })
-export const StructuredOutputError = NamedError.create("StructuredOutputError", {
-  message: Schema.String,
-  retries: NonNegativeInt,
-})
-export const APIError = NamedError.create("APIError", {
-  message: Schema.String,
-  statusCode: Schema.optional(NonNegativeInt),
-  isRetryable: Schema.Boolean,
-  responseHeaders: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  responseBody: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-})
-export type APIError = Schema.Schema.Type<typeof APIError.Schema>
-export const ContextOverflowError = NamedError.create("ContextOverflowError", {
-  message: Schema.String,
-  responseBody: Schema.optional(Schema.String),
-})
-export const ContentFilterError = NamedError.create("ContentFilterError", {
-  message: Schema.String,
-})
-
-export class OutputFormatText extends Schema.Class<OutputFormatText>("OutputFormatText")({
-  type: Schema.Literal("text"),
-}) {}
-
-export class OutputFormatJsonSchema extends Schema.Class<OutputFormatJsonSchema>("OutputFormatJsonSchema")({
-  type: Schema.Literal("json_schema"),
-  schema: Schema.Record(Schema.String, Schema.Any).annotate({ identifier: "JSONSchema" }),
-  retryCount: NonNegativeInt.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(2))),
-}) {}
-
-export const Format = Schema.Union([OutputFormatText, OutputFormatJsonSchema]).annotate({
-  discriminator: "type",
-  identifier: "OutputFormat",
-})
-export type OutputFormat = Schema.Schema.Type<typeof Format>
-
-const partBase = {
-  id: PartID,
-  sessionID: SessionSchema.ID,
-  messageID: MessageID,
-}
-
-export const SnapshotPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("snapshot"),
-  snapshot: Schema.String,
-}).annotate({ identifier: "SnapshotPart" })
-export type SnapshotPart = Types.DeepMutable<Schema.Schema.Type<typeof SnapshotPart>>
-
-export const PatchPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("patch"),
-  hash: Schema.String,
-  files: Schema.Array(Schema.String),
-}).annotate({ identifier: "PatchPart" })
-export type PatchPart = Types.DeepMutable<Schema.Schema.Type<typeof PatchPart>>
-
-export const TextPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  synthetic: Schema.optional(Schema.Boolean),
-  ignored: Schema.optional(Schema.Boolean),
-  time: Schema.optional(
-    Schema.Struct({
-      start: NonNegativeInt,
-      end: Schema.optional(NonNegativeInt),
-    }),
-  ),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "TextPart" })
-export type TextPart = Types.DeepMutable<Schema.Schema.Type<typeof TextPart>>
-
-export const ReasoningPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("reasoning"),
-  text: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: Schema.optional(NonNegativeInt),
-  }),
-}).annotate({ identifier: "ReasoningPart" })
-export type ReasoningPart = Types.DeepMutable<Schema.Schema.Type<typeof ReasoningPart>>
-
-const filePartSourceBase = {
-  text: Schema.Struct({
-    value: Schema.String,
-    start: Schema.Finite,
-    end: Schema.Finite,
-  }).annotate({ identifier: "FilePartSourceText" }),
-}
-
-export const Range = Schema.Struct({
-  start: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
-  end: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
-}).annotate({ identifier: "Range" })
-export type Range = typeof Range.Type
-
-export const FileSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("file"),
-  path: Schema.String,
-}).annotate({ identifier: "FileSource" })
-
-export const SymbolSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("symbol"),
-  path: Schema.String,
-  range: Range,
-  name: Schema.String,
-  kind: NonNegativeInt,
-}).annotate({ identifier: "SymbolSource" })
-
-export const ResourceSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("resource"),
-  clientName: Schema.String,
-  uri: Schema.String,
-}).annotate({ identifier: "ResourceSource" })
-
-export const FilePartSource = Schema.Union([FileSource, SymbolSource, ResourceSource]).annotate({
-  discriminator: "type",
-  identifier: "FilePartSource",
-})
-
-export const FilePart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("file"),
-  mime: Schema.String,
-  filename: Schema.optional(Schema.String),
-  url: Schema.String,
-  source: Schema.optional(FilePartSource),
-}).annotate({ identifier: "FilePart" })
-export type FilePart = Types.DeepMutable<Schema.Schema.Type<typeof FilePart>>
-
-export const AgentPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("agent"),
-  name: Schema.String,
-  source: Schema.optional(
-    Schema.Struct({
-      value: Schema.String,
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
-}).annotate({ identifier: "AgentPart" })
-export type AgentPart = Types.DeepMutable<Schema.Schema.Type<typeof AgentPart>>
-
-export const CompactionPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("compaction"),
-  auto: Schema.Boolean,
-  overflow: Schema.optional(Schema.Boolean),
-  tail_start_id: Schema.optional(MessageID),
-}).annotate({ identifier: "CompactionPart" })
-export type CompactionPart = Types.DeepMutable<Schema.Schema.Type<typeof CompactionPart>>
-
-export const SubtaskPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("subtask"),
-  prompt: Schema.String,
-  description: Schema.String,
-  agent: Schema.String,
-  model: Schema.optional(
-    Schema.Struct({
-      providerID: ProviderV2.ID,
-      modelID: ModelV2.ID,
-    }),
-  ),
-  command: Schema.optional(Schema.String),
-}).annotate({ identifier: "SubtaskPart" })
-export type SubtaskPart = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPart>>
-
-export const RetryPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("retry"),
-  attempt: NonNegativeInt,
-  error: APIError.EffectSchema,
-  time: Schema.Struct({
-    created: NonNegativeInt,
-  }),
-}).annotate({ identifier: "RetryPart" })
-export type RetryPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof RetryPart>>, "error"> & {
-  error: APIError
-}
-
-export const StepStartPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("step-start"),
-  snapshot: Schema.optional(Schema.String),
-}).annotate({ identifier: "StepStartPart" })
-export type StepStartPart = Types.DeepMutable<Schema.Schema.Type<typeof StepStartPart>>
-
-export const StepFinishPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("step-finish"),
-  reason: Schema.String,
-  snapshot: Schema.optional(Schema.String),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    total: Schema.optional(Schema.Finite),
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-}).annotate({ identifier: "StepFinishPart" })
-export type StepFinishPart = Types.DeepMutable<Schema.Schema.Type<typeof StepFinishPart>>
-
-export const ToolStatePending = Schema.Struct({
-  status: Schema.Literal("pending"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  raw: Schema.String,
-}).annotate({ identifier: "ToolStatePending" })
-export type ToolStatePending = Types.DeepMutable<Schema.Schema.Type<typeof ToolStatePending>>
-
-export const ToolStateRunning = Schema.Struct({
-  status: Schema.Literal("running"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  title: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-  }),
-}).annotate({ identifier: "ToolStateRunning" })
-export type ToolStateRunning = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateRunning>>
-
-export const ToolStateCompleted = Schema.Struct({
-  status: Schema.Literal("completed"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  output: Schema.String,
-  title: Schema.String,
-  metadata: Schema.Record(Schema.String, Schema.Any),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-    compacted: Schema.optional(NonNegativeInt),
-  }),
-  attachments: Schema.optional(Schema.Array(FilePart)),
-}).annotate({ identifier: "ToolStateCompleted" })
-export type ToolStateCompleted = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateCompleted>>
-
-export const ToolStateError = Schema.Struct({
-  status: Schema.Literal("error"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  error: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-  }),
-}).annotate({ identifier: "ToolStateError" })
-export type ToolStateError = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateError>>
-
-export const ToolState = Schema.Union([
-  ToolStatePending,
-  ToolStateRunning,
-  ToolStateCompleted,
-  ToolStateError,
-]).annotate({
-  discriminator: "status",
-  identifier: "ToolState",
-})
-export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError
-
-export const ToolPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("tool"),
-  callID: Schema.String,
-  tool: Schema.String,
-  state: ToolState,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "ToolPart" })
-export type ToolPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof ToolPart>>, "state"> & {
-  state: ToolState
-}
-
-const messageBase = {
-  id: MessageID,
-  sessionID: partBase.sessionID,
-}
-
-const FileDiff = Schema.Struct({
-  file: Schema.optional(Schema.String),
-  patch: Schema.optional(Schema.String),
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
-}).annotate({ identifier: "SnapshotFileDiff" })
-
-export const User = Schema.Struct({
-  ...messageBase,
-  role: Schema.Literal("user"),
-  time: Schema.Struct({
-    created: Timestamp,
-  }),
-  format: Schema.optional(Format),
-  summary: Schema.optional(
-    Schema.Struct({
-      title: Schema.optional(Schema.String),
-      body: Schema.optional(Schema.String),
-      diffs: Schema.Array(FileDiff),
-    }),
-  ),
-  agent: Schema.String,
-  model: Schema.Struct({
-    providerID: ProviderV2.ID,
-    modelID: ModelV2.ID,
-    variant: Schema.optional(Schema.String),
-  }),
-  system: Schema.optional(Schema.String),
-  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
-}).annotate({ identifier: "UserMessage" })
-export type User = Types.DeepMutable<Schema.Schema.Type<typeof User>>
-
-export const Part = Schema.Union([
-  TextPart,
-  SubtaskPart,
-  ReasoningPart,
-  FilePart,
-  ToolPart,
-  StepStartPart,
-  StepFinishPart,
-  SnapshotPart,
-  PatchPart,
-  AgentPart,
-  RetryPart,
-  CompactionPart,
-]).annotate({ discriminator: "type", identifier: "Part" })
-export type Part =
-  | TextPart
-  | SubtaskPart
-  | ReasoningPart
-  | FilePart
-  | ToolPart
-  | StepStartPart
-  | StepFinishPart
-  | SnapshotPart
-  | PatchPart
-  | AgentPart
-  | RetryPart
-  | CompactionPart
-
-const AssistantErrorSchema = Schema.Union([
-  AuthError.EffectSchema,
-  NamedError.Unknown.EffectSchema,
-  OutputLengthError.EffectSchema,
-  AbortedError.EffectSchema,
-  StructuredOutputError.EffectSchema,
-  ContextOverflowError.EffectSchema,
-  ContentFilterError.EffectSchema,
-  APIError.EffectSchema,
-]).annotate({ discriminator: "name" })
-type AssistantError = Schema.Schema.Type<typeof AssistantErrorSchema>
-
-export const TextPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  synthetic: Schema.optional(Schema.Boolean),
-  ignored: Schema.optional(Schema.Boolean),
-  time: Schema.optional(
-    Schema.Struct({
-      start: NonNegativeInt,
-      end: Schema.optional(NonNegativeInt),
-    }),
-  ),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "TextPartInput" })
-export type TextPartInput = Types.DeepMutable<Schema.Schema.Type<typeof TextPartInput>>
-
-export const FilePartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("file"),
-  mime: Schema.String,
-  filename: Schema.optional(Schema.String),
-  url: Schema.String,
-  source: Schema.optional(FilePartSource),
-}).annotate({ identifier: "FilePartInput" })
-export type FilePartInput = Types.DeepMutable<Schema.Schema.Type<typeof FilePartInput>>
-
-export const AgentPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("agent"),
-  name: Schema.String,
-  source: Schema.optional(
-    Schema.Struct({
-      value: Schema.String,
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
-}).annotate({ identifier: "AgentPartInput" })
-export type AgentPartInput = Types.DeepMutable<Schema.Schema.Type<typeof AgentPartInput>>
-
-export const SubtaskPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("subtask"),
-  prompt: Schema.String,
-  description: Schema.String,
-  agent: Schema.String,
-  model: Schema.optional(
-    Schema.Struct({
-      providerID: ProviderV2.ID,
-      modelID: ModelV2.ID,
-    }),
-  ),
-  command: Schema.optional(Schema.String),
-}).annotate({ identifier: "SubtaskPartInput" })
-export type SubtaskPartInput = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPartInput>>
-
-export const Assistant = Schema.Struct({
-  ...messageBase,
-  role: Schema.Literal("assistant"),
-  time: Schema.Struct({
-    created: NonNegativeInt,
-    completed: Schema.optional(NonNegativeInt),
-  }),
-  error: Schema.optional(AssistantErrorSchema),
-  parentID: MessageID,
-  modelID: ModelV2.ID,
-  providerID: ProviderV2.ID,
-  mode: Schema.String,
-  agent: Schema.String,
-  path: Schema.Struct({
-    cwd: Schema.String,
-    root: Schema.String,
-  }),
-  summary: Schema.optional(Schema.Boolean),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    total: Schema.optional(Schema.Finite),
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-  structured: Schema.optional(Schema.Any),
-  variant: Schema.optional(Schema.String),
-  finish: Schema.optional(Schema.String),
-}).annotate({ identifier: "AssistantMessage" })
-export type Assistant = Omit<Types.DeepMutable<Schema.Schema.Type<typeof Assistant>>, "error"> & {
-  error?: AssistantError
-}
-
-export const Info = Schema.Union([User, Assistant]).annotate({ discriminator: "role", identifier: "Message" })
-export type Info = User | Assistant
-
-export const WithParts = Schema.Struct({
-  info: Info,
-  parts: Schema.Array(Part),
-})
-export type WithParts = {
-  info: Info
-  parts: Part[]
-}
-
-const options = {
-  durable: {
-    aggregate: "sessionID",
-    version: 1,
-  },
-} as const
-
-const SessionSummary = Schema.Struct({
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  files: Schema.Finite,
-  diffs: optionalOmitUndefined(Schema.Array(FileDiff)),
-})
-
-const SessionTokens = Schema.Struct({
-  input: Schema.Finite,
-  output: Schema.Finite,
-  reasoning: Schema.Finite,
-  cache: Schema.Struct({
-    read: Schema.Finite,
-    write: Schema.Finite,
-  }),
-})
-
-const SessionShare = Schema.Struct({
-  url: Schema.String,
-})
-
-const SessionRevert = Schema.Struct({
-  messageID: MessageID,
-  partID: optionalOmitUndefined(PartID),
-  snapshot: optionalOmitUndefined(Schema.String),
-  diff: optionalOmitUndefined(Schema.String),
-})
-
-const SessionModel = Schema.Struct({
-  id: ModelV2.ID,
-  providerID: ProviderV2.ID,
-  variant: optionalOmitUndefined(Schema.String),
-})
-
-export const SessionInfo = Schema.Struct({
-  id: SessionSchema.ID,
-  slug: Schema.String,
-  projectID: ProjectV2.ID,
-  workspaceID: optionalOmitUndefined(WorkspaceV2.ID),
-  directory: Schema.String,
-  path: optionalOmitUndefined(Schema.String),
-  parentID: optionalOmitUndefined(SessionSchema.ID),
-  summary: optionalOmitUndefined(SessionSummary),
-  cost: optionalOmitUndefined(Schema.Finite),
-  tokens: optionalOmitUndefined(SessionTokens),
-  share: optionalOmitUndefined(SessionShare),
-  title: Schema.String,
-  agent: optionalOmitUndefined(Schema.String),
-  model: optionalOmitUndefined(SessionModel),
-  version: Schema.String,
-  metadata: optionalOmitUndefined(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    created: NonNegativeInt,
-    updated: NonNegativeInt,
-    compacting: optionalOmitUndefined(NonNegativeInt),
-    archived: optionalOmitUndefined(Schema.Finite),
-  }),
-  permission: optionalOmitUndefined(PermissionV1.Ruleset),
-  revert: optionalOmitUndefined(SessionRevert),
-}).annotate({ identifier: "Session" })
-export type SessionInfo = typeof SessionInfo.Type
-
-export const Event = {
-  Created: EventV2.define({
-    type: "session.created",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  Updated: EventV2.define({
-    type: "session.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  Deleted: EventV2.define({
-    type: "session.deleted",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  MessageUpdated: EventV2.define({
-    type: "message.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: Info,
-    },
-  }),
-  MessageRemoved: EventV2.define({
-    type: "message.removed",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      messageID: MessageID,
-    },
-  }),
-  PartUpdated: EventV2.define({
-    type: "message.part.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      part: Part,
-      time: Schema.Finite,
-    },
-  }),
-  PartRemoved: EventV2.define({
-    type: "message.part.removed",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      messageID: MessageID,
-      partID: PartID,
-    },
-  }),
-}
+export * from "@opencode-ai/schema/session-v1"
+export { SessionV1 } from "@opencode-ai/schema/session-v1"

packages/core/src/v2-schema.ts

@@ -1,10 +1,3 @@
-import { DateTime, Schema, SchemaGetter } from "effect"
-
-export const DateTimeUtcFromMillis = Schema.Finite.pipe(
-  Schema.decodeTo(Schema.DateTimeUtc, {
-    decode: SchemaGetter.transform((value) => DateTime.makeUnsafe(value)),
-    encode: SchemaGetter.transform((value) => DateTime.toEpochMillis(value)),
-  }),
-)
-
 export * as V2Schema from "./v2-schema"
+
+export { DateTimeUtcFromMillis } from "@opencode-ai/schema/schema"

packages/core/src/workspace.ts

@@ -1,18 +1,6 @@
 export * as WorkspaceV2 from "./workspace"
 
-import { Schema } from "effect"
-import { withStatics } from "./schema"
-import { Identifier } from "./util/identifier"
+import { Workspace } from "@opencode-ai/schema/workspace"
 
-export const ID = Schema.String.check(Schema.isStartsWith("wrk")).pipe(
-  Schema.brand("WorkspaceV2.ID"),
-  withStatics((schema) => ({
-    ascending: (id?: string) => {
-      if (!id) return schema.make("wrk_" + Identifier.ascending())
-      if (!id.startsWith("wrk")) throw new Error(`ID ${id} does not start with wrk`)
-      return schema.make(id)
-    },
-    create: () => schema.make("wrk_" + Identifier.ascending()),
-  })),
-)
+export const ID = Workspace.ID
 export type ID = typeof ID.Type

packages/core/test/catalog.test.ts

@@ -61,7 +61,7 @@ describe("CatalogV2", () => {
       yield* credentials.create({
         integrationID,
         label: "First",
-        value: new Credential.Key({ type: "key", key: "first", metadata: { tenant: "one" } }),
+        value: Credential.Key.make({ type: "key", key: "first", metadata: { tenant: "one" } }),
       })
 
       expect((yield* catalog.provider.available()).map((provider) => provider.id)).toEqual([ProviderV2.ID.make("test")])
@@ -69,13 +69,42 @@ describe("CatalogV2", () => {
       yield* credentials.create({
         integrationID,
         label: "Second",
-        value: new Credential.Key({ type: "key", key: "second", metadata: { tenant: "two" } }),
+        value: Credential.Key.make({ type: "key", key: "second", metadata: { tenant: "two" } }),
       })
       expect((yield* catalog.provider.available()).map((provider) => provider.id)).toEqual([ProviderV2.ID.make("test")])
       expect(required(yield* catalog.provider.get(ProviderV2.ID.make("test"))).request.body).toEqual({})
     }).pipe(Effect.provide(layer))
   })
 
+  it.effect("derives availability from a provider's integration", () => {
+    const integrationID = Integration.ID.make("gateway")
+    const providerID = ProviderV2.ID.make("remote")
+    const layer = Catalog.locationLayer.pipe(
+      Layer.fresh,
+      Layer.provideMerge(EventV2.defaultLayer),
+      Layer.provideMerge(locationLayer),
+      Layer.provideMerge(Credential.defaultLayer.pipe(Layer.fresh)),
+    )
+
+    return Effect.gen(function* () {
+      const catalog = yield* Catalog.Service
+      yield* (yield* Integration.Service).transform((editor) => editor.update(integrationID, () => {}))
+      yield* catalog.transform((editor) =>
+        editor.provider.update(providerID, (provider) => {
+          provider.integrationID = integrationID
+        }),
+      )
+      expect(yield* catalog.provider.available()).toEqual([])
+
+      yield* (yield* Credential.Service).create({
+        integrationID,
+        value: Credential.Key.make({ type: "key", key: "secret" }),
+      })
+
+      expect((yield* catalog.provider.available()).map((provider) => provider.id)).toEqual([providerID])
+    }).pipe(Effect.provide(layer))
+  })
+
   it.effect("projects environment connections without a catalog plugin", () =>
     Effect.acquireUseRelease(
       Effect.sync(() => {

packages/core/test/command.test.ts

@@ -27,7 +27,7 @@ describe("CommandV2", () => {
       })
 
       expect(yield* command.get("review")).toEqual(
-        new CommandV2.Info({
+        CommandV2.Info.make({
           name: "review",
           template: "Second",
           description: "Review code",
@@ -39,7 +39,7 @@ describe("CommandV2", () => {
         }),
       )
       expect(yield* command.list()).toEqual([
-        new CommandV2.Info({
+        CommandV2.Info.make({
           name: "review",
           template: "Second",
           description: "Review code",

packages/core/test/config/command.test.ts

@@ -59,7 +59,7 @@ Review files`,
           )
 
           expect(yield* command.list()).toEqual([
-            new CommandV2.Info({
+            CommandV2.Info.make({
               name: "review",
               template: "Review files",
               description: "File review",
@@ -71,8 +71,8 @@ Review files`,
               },
               subtask: true,
             }),
-            new CommandV2.Info({ name: "empty", template: "" }),
-            new CommandV2.Info({ name: "nested/docs", template: "Write docs" }),
+            CommandV2.Info.make({ name: "empty", template: "" }),
+            CommandV2.Info.make({ name: "nested/docs", template: "Write docs" }),
           ])
         }),
       ),

packages/core/test/config/skill.test.ts

@@ -59,21 +59,21 @@ describe("ConfigSkillPlugin.Plugin", () => {
       )
 
       expect(sources).toEqual([
-        new SkillV2.DirectorySource({
+        SkillV2.DirectorySource.make({
           type: "directory",
           path: AbsolutePath.make(path.join("/repo/.opencode", "skill")),
         }),
-        new SkillV2.DirectorySource({
+        SkillV2.DirectorySource.make({
           type: "directory",
           path: AbsolutePath.make(path.join("/repo/.opencode", "skills")),
         }),
-        new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }),
-        new SkillV2.DirectorySource({
+        SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }),
+        SkillV2.DirectorySource.make({
           type: "directory",
           path: AbsolutePath.make(path.join("/home/test", "shared-skills")),
         }),
-        new SkillV2.DirectorySource({ type: "directory", path: AbsolutePath.make("/opt/skills") }),
-        new SkillV2.UrlSource({ type: "url", url: "https://example.test/skills/" }),
+        SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make("/opt/skills") }),
+        SkillV2.UrlSource.make({ type: "url", url: "https://example.test/skills/" }),
       ])
     }),
   )

packages/core/test/credential.test.ts

@@ -14,7 +14,7 @@ describe("Credential", () => {
       const created = yield* credentials.create({
         integrationID,
         label: "Work",
-        value: new Credential.Key({ type: "key", key: "secret" }),
+        value: Credential.Key.make({ type: "key", key: "secret" }),
       })
 
       expect(yield* credentials.list(integrationID)).toEqual([created])
@@ -24,7 +24,7 @@ describe("Credential", () => {
       const replacement = yield* credentials.create({
         integrationID,
         label: "Replacement",
-        value: new Credential.Key({ type: "key", key: "replacement" }),
+        value: Credential.Key.make({ type: "key", key: "replacement" }),
       })
       expect(yield* credentials.list(integrationID)).toEqual([replacement])
 

packages/core/test/event.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect } from "bun:test"
 import { Cause, DateTime, Deferred, Effect, Exit, Fiber, Layer, Schema, Stream } from "effect"
 import { EventV2 } from "@opencode-ai/core/event"
+import { Event } from "@opencode-ai/schema/event"
 import { Database } from "@opencode-ai/core/database/database"
 import { EventSequenceTable, EventTable } from "@opencode-ai/core/event/sql"
 import { Location } from "@opencode-ai/core/location"
-import { AbsolutePath } from "@opencode-ai/core/schema"
+import { AbsolutePath, DateTimeUtcFromMillis } from "@opencode-ai/core/schema"
 import { WorkspaceV2 } from "@opencode-ai/core/workspace"
-import { V2Schema } from "@opencode-ai/core/v2-schema"
 import { eq } from "drizzle-orm"
 import { location } from "./fixture/location"
 import { testEffect } from "./lib/effect"
@@ -17,10 +17,6 @@ const locationLayer = Layer.succeed(
     location({ directory: AbsolutePath.make("project"), workspaceID: WorkspaceV2.ID.make("wrk_test") }),
   ),
 )
-const eventLayer = Layer.mergeAll(EventV2.defaultLayer, Database.defaultLayer)
-const it = testEffect(eventLayer.pipe(Layer.provideMerge(locationLayer)))
-const itWithoutLocation = testEffect(eventLayer)
-
 const Message = EventV2.define({
   type: "test.message",
   schema: {
@@ -79,24 +75,20 @@ const SyncTimestamp = EventV2.define({
   },
   schema: {
     id: Schema.String,
-    timestamp: V2Schema.DateTimeUtcFromMillis,
+    timestamp: DateTimeUtcFromMillis,
   },
 })
 
+const eventLayer = Layer.mergeAll(
+  EventV2.layerWith({
+    definitions: [Message, SyncMessage, SyncSent, GlobalMessage, VersionedMessage, SyncTimestamp],
+  }).pipe(Layer.provide(Database.defaultLayer)),
+  Database.defaultLayer,
+)
+const it = testEffect(eventLayer.pipe(Layer.provideMerge(locationLayer)))
+const itWithoutLocation = testEffect(eventLayer)
+
 describe("EventV2", () => {
-  it.effect("derives stable namespaced external IDs", () =>
-    Effect.sync(() => {
-      const input = { namespace: "opencord.agent-input", key: "input-1" }
-
-      expect(EventV2.ID.fromExternal(input)).toBe(EventV2.ID.fromExternal(input))
-      expect(EventV2.ID.fromExternal(input)).toMatch(/^evt_[a-f0-9]{64}$/)
-      expect(EventV2.ID.fromExternal({ ...input, namespace: "another-app" })).not.toBe(EventV2.ID.fromExternal(input))
-      expect(EventV2.ID.fromExternal({ namespace: "a:b", key: "c" })).not.toBe(
-        EventV2.ID.fromExternal({ namespace: "a", key: "b:c" }),
-      )
-    }),
-  )
-
   it.effect("publishes events with the current location", () =>
     Effect.gen(function* () {
       const events = yield* EventV2.Service
@@ -136,26 +128,21 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("stores definitions in the exported registry", () =>
-    Effect.sync(() => {
-      expect(EventV2.registry.get(Message.type)).toBe(Message)
-    }),
-  )
-
-  it.effect("keeps the latest sync definition in the registry", () =>
+  it.effect("selects the latest durable definition independent of declaration order", () =>
     Effect.sync(() => {
       const latest = EventV2.define({
         type: "test.out-of-order",
         durable: { version: 2, aggregate: "id" },
         schema: { id: Schema.String },
       })
-      EventV2.define({
+      const historical = EventV2.define({
         type: "test.out-of-order",
         durable: { version: 1, aggregate: "id" },
         schema: { id: Schema.String },
       })
 
-      expect(EventV2.registry.get("test.out-of-order")).toBe(latest)
+      expect(Event.latest([latest, historical]).get("test.out-of-order")).toBe(latest)
+      expect(Event.latest([historical, latest]).get("test.out-of-order")).toBe(latest)
     }),
   )
 
@@ -421,6 +408,7 @@ describe("EventV2", () => {
       const continueRead = yield* Deferred.make<void>()
       let pause = true
       const eventLayer = EventV2.layerWith({
+        definitions: [SyncMessage],
         beforeAggregateRead: () =>
           pause
             ? Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(continueRead)))

packages/core/test/integration.test.ts

@@ -125,7 +125,7 @@ describe("Integration", () => {
         expect.objectContaining({
           integrationID,
           label: "Work",
-          value: new Credential.Key({ type: "key", key: "secret" }),
+          value: Credential.Key.make({ type: "key", key: "secret" }),
         }),
       ])
       expect((yield* Fiber.join(updated)).length).toBe(1)
@@ -149,7 +149,7 @@ describe("Integration", () => {
               instructions: "Paste the code",
               callback: (code: string) =>
                 Effect.succeed(
-                  new Credential.OAuth({
+                  Credential.OAuth.make({
                     type: "oauth",
                     methodID,
                     access: "access",
@@ -175,7 +175,7 @@ describe("Integration", () => {
         expect.objectContaining({
           integrationID,
           label: "Personal",
-          value: new Credential.OAuth({
+          value: Credential.OAuth.make({
             type: "oauth",
             methodID,
             access: "access",
@@ -238,7 +238,7 @@ describe("Integration", () => {
               url: "https://example.com/authorize",
               instructions: "Sign in",
               callback: Effect.succeed(
-                new Credential.OAuth({ type: "oauth", methodID, access: "access", refresh: "refresh", expires: 1 }),
+                Credential.OAuth.make({ type: "oauth", methodID, access: "access", refresh: "refresh", expires: 1 }),
               ),
             }),
         }),
@@ -315,12 +315,12 @@ describe("Integration", () => {
           const work = yield* credentials.create({
             integrationID,
             label: "Work",
-            value: new Credential.Key({ type: "key", key: "a" }),
+            value: Credential.Key.make({ type: "key", key: "a" }),
           })
           const personal = yield* credentials.create({
             integrationID,
             label: "Personal",
-            value: new Credential.Key({ type: "key", key: "b" }),
+            value: Credential.Key.make({ type: "key", key: "b" }),
           })
 
           // Stored credentials and detected env vars appear as connections.
@@ -332,7 +332,7 @@ describe("Integration", () => {
             },
             { type: "env", name: "INTEGRATION_TEST_ACME_KEY" },
           ])
-          expect(yield* integrations.connection.forIntegration(integrationID)).toEqual({
+          expect(yield* integrations.connection.active(integrationID)).toEqual({
             type: "credential",
             id: personal.id,
             label: "Personal",

packages/core/test/location-layer.test.ts

@@ -52,14 +52,28 @@ const it = testEffect(
 )
 
 describe("LocationServiceMap", () => {
-  it.effect("compares equivalent location refs by value", () =>
-    Effect.sync(() => {
-      const directory = AbsolutePath.make("/project")
-      expect(Equal.equals(Location.Ref.make({ directory }), Location.Ref.make({ directory }))).toBe(true)
-      expect(Hash.hash(Location.Ref.make({ directory }))).toBe(
-        Hash.hash(Location.Ref.make({ directory, workspaceID: undefined })),
-      )
-    }),
+  it.live("reuses cached services for constructed and decoded location refs", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.scoped(
+          Effect.gen(function* () {
+            const locations = yield* LocationServiceMap
+            const directory = AbsolutePath.make(dir.path)
+            const constructed = Location.Ref.make({ directory })
+            const decoded = Schema.decodeUnknownSync(Location.Ref)({ directory })
+
+            expect(constructed).toEqual({ directory, workspaceID: undefined })
+            expect(decoded).toEqual(constructed)
+            expect(Equal.equals(constructed, decoded)).toBe(true)
+            expect(Hash.hash(constructed)).toBe(Hash.hash(decoded))
+            expect(yield* locations.contextEffect(constructed)).toBe(yield* locations.contextEffect(decoded))
+          }),
+        ),
+      ),
+    ),
   )
 
   it.live("isolates location state while sharing location policy with catalog", () =>

packages/core/test/plugin/fixture.ts

@@ -9,6 +9,7 @@ import { RepositoryCache } from "@opencode-ai/core/repository-cache"
 import { Ripgrep } from "@opencode-ai/core/ripgrep"
 import { SkillDiscovery } from "@opencode-ai/core/skill/discovery"
 import { Effect, Layer } from "effect"
+import { FetchHttpClient } from "effect/unstable/http"
 import { tempLocationLayer } from "../fixture/location"
 
 export const PluginTestLayer = Layer.mergeAll(FileSystem.locationLayer, PluginV2.locationLayer).pipe(
@@ -16,6 +17,7 @@ export const PluginTestLayer = Layer.mergeAll(FileSystem.locationLayer, PluginV2
     Layer.mergeAll(
       Credential.defaultLayer,
       EventV2.defaultLayer,
+      FetchHttpClient.layer,
       FSUtil.defaultLayer,
       Global.defaultLayer,
       Layer.succeed(

packages/core/test/plugin/host.ts

@@ -1,6 +1,7 @@
 import type { PluginContext } from "@opencode-ai/plugin/v2/effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
+import { Credential } from "@opencode-ai/core/credential"
 import { Integration } from "@opencode-ai/core/integration"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
@@ -31,6 +32,10 @@ export function host(overrides: Overrides = {}): PluginContext {
     integration: overrides.integration ?? {
       transform: () => Effect.die("unused integration.transform"),
       reload: () => Effect.die("unused integration.reload"),
+      connection: {
+        active: () => Effect.die("unused integration.connection.active"),
+        resolve: () => Effect.die("unused integration.connection.resolve"),
+      },
     },
     plugin: overrides.plugin ?? {
       add: () => Effect.die("unused plugin.add"),
@@ -138,6 +143,13 @@ export function catalogHost(catalog: Catalog.Interface): PluginContext["catalog"
 export function integrationHost(integration: Integration.Interface): PluginContext["integration"] {
   return {
     reload: integration.reload,
+    connection: {
+      active: (id) => integration.connection.active(Integration.ID.make(id)),
+      resolve: (connection) =>
+        integration.connection.resolve(
+          connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection,
+        ),
+    },
     transform: (callback) =>
       integration.transform((draft) =>
         callback({
@@ -150,16 +162,72 @@ export function integrationHost(integration: Integration.Interface): PluginConte
           remove: (id) => draft.remove(Integration.ID.make(id)),
           method: {
             list: (id) => draft.method.list(Integration.ID.make(id)).map(method),
-            update: (input) =>
-              input.method.type === "env"
-                ? draft.method.update({
-                    integrationID: Integration.ID.make(input.integrationID),
-                    method: { ...input.method, names: [...input.method.names] },
-                  })
-                : draft.method.update({
-                    integrationID: Integration.ID.make(input.integrationID),
-                    method: input.method,
-                  }),
+            update: (input) => {
+              if ("authorize" in input) {
+                const methodID = Integration.MethodID.make(input.method.id)
+                const refresh = input.refresh
+                draft.method.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  method: { ...input.method, id: methodID },
+                  authorize: (inputs) =>
+                    input.authorize(inputs).pipe(
+                      Effect.map((authorization) => {
+                        if (authorization.mode === "auto") {
+                          return {
+                            ...authorization,
+                            callback: authorization.callback.pipe(
+                              Effect.map((credential) =>
+                                Credential.OAuth.make({
+                                  ...credential,
+                                  methodID: Integration.MethodID.make(credential.methodID),
+                                }),
+                              ),
+                            ),
+                          }
+                        }
+                        return {
+                          ...authorization,
+                          callback: (code: string) =>
+                            authorization.callback(code).pipe(
+                              Effect.map((credential) =>
+                                Credential.OAuth.make({
+                                  ...credential,
+                                  methodID: Integration.MethodID.make(credential.methodID),
+                                }),
+                              ),
+                            ),
+                        }
+                      }),
+                    ),
+                  ...(refresh
+                    ? {
+                        refresh: (value: Credential.OAuth) =>
+                          refresh(value).pipe(
+                            Effect.map((next) =>
+                              Credential.OAuth.make({
+                                ...next,
+                                methodID: Integration.MethodID.make(next.methodID),
+                              }),
+                            ),
+                          ),
+                      }
+                    : {}),
+                  ...(input.label ? { label: input.label } : {}),
+                })
+                return
+              }
+              if (input.method.type === "env") {
+                draft.method.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  method: { ...input.method, names: [...input.method.names] },
+                })
+                return
+              }
+              draft.method.update({
+                integrationID: Integration.ID.make(input.integrationID),
+                method: input.method,
+              })
+            },
             remove: (id, item) => draft.method.remove(Integration.ID.make(id), internalMethod(item)),
           },
         }),

packages/core/test/plugin/provider-alibaba.test.ts

@@ -26,7 +26,7 @@ describe("AlibabaPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("qwen")),
           api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
         }),
@@ -43,7 +43,7 @@ describe("AlibabaPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("qwen")),
           api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
         }),
@@ -60,7 +60,7 @@ describe("AlibabaPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-alibaba"), ModelV2.ID.make("qwen")),
           api: { id: ModelV2.ID.make("qwen"), type: "aisdk", package: "test-provider" },
         }),
@@ -79,7 +79,7 @@ describe("AlibabaPlugin", () => {
       const plugin = yield* PluginV2.Service
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
-      const item = new ModelV2.Info({
+      const item = ModelV2.Info.make({
         ...ModelV2.Info.empty(ProviderV2.ID.make("alibaba"), ModelV2.ID.make("alias")),
         api: { id: ModelV2.ID.make("qwen-plus"), type: "aisdk", package: "test-provider" },
       })

packages/core/test/plugin/provider-amazon-bedrock.test.ts

@@ -83,7 +83,7 @@ describe("AmazonBedrockPlugin", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       yield* catalog.transform((catalog) => {
-        const bedrock = new ProviderV2.Info({
+        const bedrock = ProviderV2.Info.make({
           ...ProviderV2.Info.empty(ProviderV2.ID.amazonBedrock),
           api: { type: "aisdk", package: "@ai-sdk/amazon-bedrock" },
           request: {
@@ -114,7 +114,7 @@ describe("AmazonBedrockPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -139,7 +139,7 @@ describe("AmazonBedrockPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -173,7 +173,7 @@ describe("AmazonBedrockPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
               api: {
                 id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
@@ -197,7 +197,7 @@ describe("AmazonBedrockPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -216,7 +216,7 @@ describe("AmazonBedrockPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -235,7 +235,7 @@ describe("AmazonBedrockPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -255,7 +255,7 @@ describe("AmazonBedrockPlugin", () => {
         const headers: Array<string | null> = []
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -284,7 +284,7 @@ describe("AmazonBedrockPlugin", () => {
         const headers: Array<string | null> = []
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -312,7 +312,7 @@ describe("AmazonBedrockPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-5.5")),
             api: {
               id: ModelV2.ID.make("openai.gpt-5.5"),
@@ -343,7 +343,7 @@ describe("AmazonBedrockPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-5.5")),
           api: {
             id: ModelV2.ID.make("openai.gpt-5.5"),
@@ -355,7 +355,7 @@ describe("AmazonBedrockPlugin", () => {
         options: { baseURL: "https://bedrock-mantle.us-east-2.api.aws/openai/v1", region: "us-east-2" },
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("openai.gpt-oss-safeguard-120b")),
           api: {
             id: ModelV2.ID.make("openai.gpt-oss-safeguard-120b"),
@@ -376,7 +376,7 @@ describe("AmazonBedrockPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
           api: {
             id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
@@ -407,7 +407,7 @@ describe("AmazonBedrockPlugin", () => {
           const headers: Array<string | null> = []
           yield* addPlugin()
           const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
               api: {
                 id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"),
@@ -442,7 +442,7 @@ describe("AmazonBedrockPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -450,7 +450,7 @@ describe("AmazonBedrockPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -458,7 +458,7 @@ describe("AmazonBedrockPlugin", () => {
         options: { region: "eu-west-1" },
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("global.anthropic.claude-sonnet-4-5")),
           api: {
             id: ModelV2.ID.make("global.anthropic.claude-sonnet-4-5"),
@@ -470,7 +470,7 @@ describe("AmazonBedrockPlugin", () => {
         options: { region: "eu-west-1" },
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -478,7 +478,7 @@ describe("AmazonBedrockPlugin", () => {
         options: { region: "ap-northeast-1" },
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -503,7 +503,7 @@ describe("AmazonBedrockPlugin", () => {
         const calls: string[] = []
         yield* addPlugin()
         yield* aisdk.runLanguage({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
             api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -589,7 +589,7 @@ describe("AmazonBedrockPlugin", () => {
       yield* addPlugin()
       for (const item of cases) {
         yield* aisdk.runLanguage({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.amazonBedrock, ModelV2.ID.make(item.modelID)),
             api: { id: ModelV2.ID.make(item.modelID), type: "aisdk", package: "test-provider" },
           }),
@@ -608,7 +608,7 @@ describe("AmazonBedrockPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("anthropic.claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("anthropic.claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),

packages/core/test/plugin/provider-anthropic.test.ts

@@ -29,7 +29,7 @@ describe("AnthropicPlugin", () => {
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       yield* catalog.transform((catalog) => {
-        const item = new ProviderV2.Info({
+        const item = ProviderV2.Info.make({
           ...ProviderV2.Info.empty(ProviderV2.ID.anthropic),
           api: { type: "aisdk", package: "@ai-sdk/anthropic" },
           request: { headers: { Existing: "1" }, body: {} },
@@ -64,7 +64,7 @@ describe("AnthropicPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-anthropic"), ModelV2.ID.make("claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "@ai-sdk/anthropic" },
         }),
@@ -81,7 +81,7 @@ describe("AnthropicPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.anthropic, ModelV2.ID.make("claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "@ai-sdk/anthropic" },
         }),

packages/core/test/plugin/provider-azure-cognitive-services.test.ts

@@ -87,11 +87,11 @@ describe("AzureCognitiveServicesPlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const azure = new ProviderV2.Info({
+          const azure = ProviderV2.Info.make({
             ...ProviderV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services")),
             api: { type: "aisdk", package: "@ai-sdk/openai-compatible" },
           })
-          const openai = new ProviderV2.Info({
+          const openai = ProviderV2.Info.make({
             ...ProviderV2.Info.empty(ProviderV2.ID.openai),
             api: { type: "aisdk", package: "test-provider" },
           })
@@ -120,7 +120,7 @@ describe("AzureCognitiveServicesPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -138,7 +138,7 @@ describe("AzureCognitiveServicesPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -146,7 +146,7 @@ describe("AzureCognitiveServicesPlugin", () => {
         options: {},
       })
       const ignored = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -166,7 +166,7 @@ describe("AzureCognitiveServicesPlugin", () => {
       const sdk = fakeSelectorSdk(calls)
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("messages-deployment")),
           api: { id: ModelV2.ID.make("messages-deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -174,7 +174,7 @@ describe("AzureCognitiveServicesPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("chat-deployment")),
           api: { id: ModelV2.ID.make("chat-deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -182,7 +182,7 @@ describe("AzureCognitiveServicesPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("azure-cognitive-services"), ModelV2.ID.make("language-deployment")),
           api: { id: ModelV2.ID.make("language-deployment"), type: "aisdk", package: "test-provider" },
         }),

packages/core/test/plugin/provider-azure.test.ts

@@ -80,7 +80,7 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const azure = new ProviderV2.Info({
+          const azure = ProviderV2.Info.make({
             ...ProviderV2.Info.empty(ProviderV2.ID.azure),
             api: { type: "aisdk", package: "@ai-sdk/azure" },
             request: { headers: {}, body: { resourceName: "from-config" } },
@@ -103,7 +103,7 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const azure = new ProviderV2.Info({
+          const azure = ProviderV2.Info.make({
             ...ProviderV2.Info.empty(ProviderV2.ID.azure),
             api: { type: "aisdk", package: "@ai-sdk/azure" },
             request: { headers: {}, body: { resourceName: "" } },
@@ -124,7 +124,7 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const catalog = yield* Catalog.Service
         yield* catalog.transform((catalog) => {
-          const azure = new ProviderV2.Info({
+          const azure = ProviderV2.Info.make({
             ...ProviderV2.Info.empty(ProviderV2.ID.azure),
             api: { type: "aisdk", package: "@ai-sdk/azure" },
             request: { headers: {}, body: { resourceName: "   " } },
@@ -147,7 +147,7 @@ describe("AzurePlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
             api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
           }),
@@ -166,7 +166,7 @@ describe("AzurePlugin", () => {
         yield* addPlugin()
         const exit = yield* aisdk
           .runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
               api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
             }),
@@ -186,7 +186,7 @@ describe("AzurePlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -204,7 +204,7 @@ describe("AzurePlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -222,7 +222,7 @@ describe("AzurePlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
           request: { headers: {}, body: { useCompletionUrls: true } },
@@ -241,7 +241,7 @@ describe("AzurePlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -249,7 +249,7 @@ describe("AzurePlugin", () => {
         options: {},
       })
       const ignored = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.openai, ModelV2.ID.make("deployment")),
           api: { id: ModelV2.ID.make("deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -272,7 +272,7 @@ describe("AzurePlugin", () => {
       }
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("messages-deployment")),
           api: { id: ModelV2.ID.make("messages-deployment"), type: "aisdk", package: "test-provider" },
         }),
@@ -280,7 +280,7 @@ describe("AzurePlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.azure, ModelV2.ID.make("language-deployment")),
           api: { id: ModelV2.ID.make("language-deployment"), type: "aisdk", package: "test-provider" },
         }),

packages/core/test/plugin/provider-cerebras.test.ts

@@ -64,7 +64,7 @@ describe("CerebrasPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(
             ProviderV2.ID.make("custom-cerebras"),
             ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
@@ -90,7 +90,7 @@ describe("CerebrasPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(
             ProviderV2.ID.make("custom-cerebras"),
             ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),
@@ -115,7 +115,7 @@ describe("CerebrasPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(
             ProviderV2.ID.make("custom-cerebras"),
             ModelV2.ID.make("llama-4-scout-17b-16e-instruct"),

packages/core/test/plugin/provider-cloudflare-ai-gateway.test.ts

@@ -116,7 +116,7 @@ describe("CloudflareAIGatewayPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
               api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
             }),
@@ -137,7 +137,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
             api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -181,7 +181,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
             api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -210,7 +210,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
             api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -247,7 +247,7 @@ describe("CloudflareAIGatewayPlugin", () => {
           yield* addPlugin()
 
           yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
               api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
             }),
@@ -278,7 +278,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
             api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -300,7 +300,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
             api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -323,7 +323,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
             api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
           }),
@@ -352,7 +352,7 @@ describe("CloudflareAIGatewayPlugin", () => {
           yield* addPlugin()
 
           const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
               api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
             }),
@@ -375,7 +375,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(
               ProviderV2.ID.make("cloudflare-ai-gateway"),
               ModelV2.ID.make("anthropic/claude-sonnet-4-5"),
@@ -410,7 +410,7 @@ describe("CloudflareAIGatewayPlugin", () => {
         yield* addPlugin()
 
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-ai-gateway"), ModelV2.ID.make("openai/gpt-5")),
             api: { id: ModelV2.ID.make("openai/gpt-5"), type: "aisdk", package: "test-provider" },
           }),

packages/core/test/plugin/provider-cloudflare-workers-ai.test.ts

@@ -93,7 +93,7 @@ describe("CloudflareWorkersAIPlugin", () => {
         yield* addPlugin()
         const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("cloudflare-workers-ai")))
         const sdk = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-workers-ai"), ModelV2.ID.make("@cf/model")),
             api: { id: ModelV2.ID.make("@cf/model"), ...provider.api },
           }),
@@ -136,7 +136,7 @@ describe("CloudflareWorkersAIPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-workers-ai"), ModelV2.ID.make("@cf/model")),
             api: {
               id: ModelV2.ID.make("@cf/model"),
@@ -180,7 +180,7 @@ describe("CloudflareWorkersAIPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-workers-ai"), ModelV2.ID.make("@cf/model")),
             api: {
               id: ModelV2.ID.make("@cf/model"),
@@ -212,7 +212,7 @@ describe("CloudflareWorkersAIPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-workers-ai"), ModelV2.ID.make("@cf/model")),
             api: {
               id: ModelV2.ID.make("@cf/model"),
@@ -241,7 +241,7 @@ describe("CloudflareWorkersAIPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-workers-ai"), ModelV2.ID.make("alias")),
           api: { id: ModelV2.ID.make("@cf/api-model"), type: "aisdk", package: "test-provider" },
         }),
@@ -260,7 +260,7 @@ describe("CloudflareWorkersAIPlugin", () => {
         const aisdk = yield* AISDK.Service
         yield* addPlugin()
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("cloudflare-workers-ai"), ModelV2.ID.make("@cf/model")),
             api: {
               id: ModelV2.ID.make("@cf/model"),

packages/core/test/plugin/provider-cohere.test.ts

@@ -54,7 +54,7 @@ describe("CoherePlugin", () => {
       yield* addPlugin()
 
       const ignored = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("cohere"), ModelV2.ID.make("command")),
           api: { id: ModelV2.ID.make("command"), type: "aisdk", package: "test-provider" },
         }),
@@ -64,7 +64,7 @@ describe("CoherePlugin", () => {
       expect(ignored.sdk).toBeUndefined()
 
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("cohere"), ModelV2.ID.make("command")),
           api: { id: ModelV2.ID.make("command"), type: "aisdk", package: "test-provider" },
         }),
@@ -81,7 +81,7 @@ describe("CoherePlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-cohere"), ModelV2.ID.make("command-r-plus")),
           api: { id: ModelV2.ID.make("command-r-plus"), type: "aisdk", package: "test-provider" },
         }),
@@ -106,7 +106,7 @@ describe("CoherePlugin", () => {
       const sdk = fakeSelectorSdk(calls)
       yield* addPlugin()
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("cohere"), ModelV2.ID.make("alias")),
           api: { id: ModelV2.ID.make("command-r-plus"), type: "aisdk", package: "test-provider" },
         }),

packages/core/test/plugin/provider-deepinfra.test.ts

@@ -46,7 +46,7 @@ describe("DeepInfraPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("deepinfra"), ModelV2.ID.make("model")),
           api: { id: ModelV2.ID.make("model"), type: "aisdk", package: "@ai-sdk/deepinfra" },
         }),
@@ -64,7 +64,7 @@ describe("DeepInfraPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-deepinfra"), ModelV2.ID.make("model")),
           api: { id: ModelV2.ID.make("model"), type: "aisdk", package: "@ai-sdk/deepinfra" },
         }),
@@ -83,7 +83,7 @@ describe("DeepInfraPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("deepinfra"), ModelV2.ID.make("model")),
           api: { id: ModelV2.ID.make("model"), type: "aisdk", package: "@ai-sdk/deepinfra" },
         }),
@@ -109,7 +109,7 @@ describe("DeepInfraPlugin", () => {
       yield* Effect.forEach(packages, (item) =>
         Effect.gen(function* () {
           const ignored = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("deepinfra"), ModelV2.ID.make("model")),
               api: { id: ModelV2.ID.make("model"), type: "aisdk", package: "@ai-sdk/deepinfra" },
             }),
@@ -120,7 +120,7 @@ describe("DeepInfraPlugin", () => {
         }),
       )
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("deepinfra"), ModelV2.ID.make("model")),
           api: { id: ModelV2.ID.make("model"), type: "aisdk", package: "@ai-sdk/deepinfra" },
         }),
@@ -139,7 +139,7 @@ describe("DeepInfraPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const sdkEvent = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("deepinfra"), ModelV2.ID.make("meta-llama/Llama-3.3-70B-Instruct")),
           api: {
             id: ModelV2.ID.make("meta-llama/Llama-3.3-70B-Instruct"),

packages/core/test/plugin/provider-dynamic.test.ts

@@ -51,7 +51,7 @@ describe("DynamicProviderPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom"), ModelV2.ID.make("test-model")),
           api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: fixtureProvider },
         }),
@@ -69,7 +69,7 @@ describe("DynamicProviderPlugin", () => {
       const sdk = { marker: "existing" }
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom"), ModelV2.ID.make("test-model")),
           api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: fixtureProvider },
         }),
@@ -86,7 +86,7 @@ describe("DynamicProviderPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-provider"), ModelV2.ID.make("test-model")),
           api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: fixtureProvider },
         }),
@@ -102,7 +102,7 @@ describe("DynamicProviderPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin(npmEntrypoint(fixtureProviderPath))
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("npm-provider"), ModelV2.ID.make("test-model")),
           api: { id: ModelV2.ID.make("test-model"), type: "aisdk", package: "fixture-provider" },
         }),
@@ -119,7 +119,7 @@ describe("DynamicProviderPlugin", () => {
       yield* addPlugin(npmEntrypoint())
       const exit = yield* aisdk
         .language(
-          new ModelV2.Info({
+          ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("missing-entrypoint"), ModelV2.ID.make("alias")),
             api: { id: ModelV2.ID.make("alias"), type: "aisdk", package: "fixture-provider" },
           }),
@@ -136,7 +136,7 @@ describe("DynamicProviderPlugin", () => {
       yield* addPlugin()
       const exit = yield* aisdk
         .language(
-          new ModelV2.Info({
+          ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("bad-import"), ModelV2.ID.make("alias")),
             api: { id: ModelV2.ID.make("alias"), type: "aisdk", package: "file:///missing/provider-factory.js" },
           }),
@@ -155,7 +155,7 @@ describe("DynamicProviderPlugin", () => {
       yield* addPlugin(npmEntrypoint(tmp.entrypoint))
       const exit = yield* aisdk
         .language(
-          new ModelV2.Info({
+          ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("missing-factory"), ModelV2.ID.make("alias")),
             api: { id: ModelV2.ID.make("alias"), type: "aisdk", package: "fixture-provider" },
           }),
@@ -172,7 +172,7 @@ describe("DynamicProviderPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const language = yield* aisdk.language(
-        new ModelV2.Info({
+        ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom"), ModelV2.ID.make("alias")),
           api: { id: ModelV2.ID.make("test-model-api"), type: "aisdk", package: fixtureProvider },
         }),

packages/core/test/plugin/provider-gateway.test.ts

@@ -43,7 +43,7 @@ describe("GatewayPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("gateway"), ModelV2.ID.make("model")),
           api: { id: ModelV2.ID.make("model"), type: "aisdk", package: "test-provider" },
         }),
@@ -63,7 +63,7 @@ describe("GatewayPlugin", () => {
       yield* addPlugin()
 
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("vercel"), ModelV2.ID.make("anthropic/claude-sonnet-4")),
           api: {
             id: ModelV2.ID.make("anthropic/claude-sonnet-4"),
@@ -89,7 +89,7 @@ describe("GatewayPlugin", () => {
 
       for (const modelID of vercelGatewayModels) {
         const ignored = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("vercel"), ModelV2.ID.make(modelID)),
             api: { id: ModelV2.ID.make(modelID), type: "aisdk", package: "test-provider" },
           }),
@@ -99,7 +99,7 @@ describe("GatewayPlugin", () => {
         expect(ignored.sdk).toBeUndefined()
 
         const result = yield* aisdk.runSDK({
-          model: new ModelV2.Info({
+          model: ModelV2.Info.make({
             ...ModelV2.Info.empty(ProviderV2.ID.make("vercel"), ModelV2.ID.make(modelID)),
             api: { id: ModelV2.ID.make(modelID), type: "aisdk", package: "test-provider" },
           }),

packages/core/test/plugin/provider-github-copilot.test.ts

@@ -45,7 +45,7 @@ describe("GithubCopilotPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const ignored = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5")),
           api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -53,7 +53,7 @@ describe("GithubCopilotPlugin", () => {
         options: { name: "github-copilot" },
       })
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5")),
           api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -72,7 +72,7 @@ describe("GithubCopilotPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("claude-sonnet-4")),
           api: { id: ModelV2.ID.make("claude-sonnet-4"), type: "aisdk", package: "test-provider" },
         }),
@@ -90,7 +90,7 @@ describe("GithubCopilotPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("alias")),
           api: { id: ModelV2.ID.make("claude-sonnet-4"), type: "aisdk", package: "test-provider" },
         }),
@@ -108,7 +108,7 @@ describe("GithubCopilotPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5")),
           api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -116,7 +116,7 @@ describe("GithubCopilotPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5.1-codex")),
           api: { id: ModelV2.ID.make("gpt-5.1-codex"), type: "aisdk", package: "test-provider" },
         }),
@@ -124,7 +124,7 @@ describe("GithubCopilotPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-4o")),
           api: { id: ModelV2.ID.make("gpt-4o"), type: "aisdk", package: "test-provider" },
         }),
@@ -132,7 +132,7 @@ describe("GithubCopilotPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-mini")),
           api: { id: ModelV2.ID.make("gpt-5-mini"), type: "aisdk", package: "test-provider" },
         }),
@@ -140,7 +140,7 @@ describe("GithubCopilotPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("gpt-5-mini-2025-08-07")),
           api: { id: ModelV2.ID.make("gpt-5-mini-2025-08-07"), type: "aisdk", package: "test-provider" },
         }),
@@ -164,7 +164,7 @@ describe("GithubCopilotPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("default")),
           api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -172,7 +172,7 @@ describe("GithubCopilotPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("small")),
           api: { id: ModelV2.ID.make("gpt-5-mini"), type: "aisdk", package: "test-provider" },
         }),
@@ -180,7 +180,7 @@ describe("GithubCopilotPlugin", () => {
         options: {},
       })
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("github-copilot"), ModelV2.ID.make("sonnet")),
           api: { id: ModelV2.ID.make("claude-sonnet-4"), type: "aisdk", package: "test-provider" },
         }),
@@ -228,7 +228,7 @@ describe("GithubCopilotPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("openai"), ModelV2.ID.make("gpt-5")),
           api: { id: ModelV2.ID.make("gpt-5"), type: "aisdk", package: "test-provider" },
         }),

packages/core/test/plugin/provider-gitlab.test.ts

@@ -68,7 +68,7 @@ describe("GitLabPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("claude")),
               api: { id: ModelV2.ID.make("claude"), type: "aisdk", package: "test-provider" },
             }),
@@ -105,7 +105,7 @@ describe("GitLabPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("claude")),
               api: { id: ModelV2.ID.make("claude"), type: "aisdk", package: "test-provider" },
             }),
@@ -130,7 +130,7 @@ describe("GitLabPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("claude")),
               api: { id: ModelV2.ID.make("claude"), type: "aisdk", package: "test-provider" },
             }),
@@ -171,7 +171,7 @@ describe("GitLabPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("claude")),
           api: { id: ModelV2.ID.make("claude"), type: "aisdk", package: "test-provider" },
         }),
@@ -190,7 +190,7 @@ describe("GitLabPlugin", () => {
       const calls: [string, unknown][] = []
       yield* addPlugin()
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("duo-workflow-custom")),
           api: { id: ModelV2.ID.make("duo-workflow-custom"), type: "aisdk", package: "test-provider" },
           request: {
@@ -225,7 +225,7 @@ describe("GitLabPlugin", () => {
       const calls: [string, unknown][] = []
       yield* addPlugin()
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("duo-workflow-exact")),
           api: { id: ModelV2.ID.make("duo-workflow-exact"), type: "aisdk", package: "test-provider" },
         }),
@@ -252,7 +252,7 @@ describe("GitLabPlugin", () => {
       const calls: [string, unknown][] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("duo-workflow-custom")),
           api: { id: ModelV2.ID.make("duo-workflow-custom"), type: "aisdk", package: "test-provider" },
           request: {
@@ -280,7 +280,7 @@ describe("GitLabPlugin", () => {
       const calls: [string, unknown][] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("gitlab"), ModelV2.ID.make("claude")),
           api: { id: ModelV2.ID.make("claude"), type: "aisdk", package: "test-provider" },
           request: { headers: { h: "v" }, body: {} },

packages/core/test/plugin/provider-google-vertex-anthropic.test.ts

@@ -116,7 +116,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin(GoogleVertexAnthropicPlugin)
           const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(
                 ProviderV2.ID.make("google-vertex-anthropic"),
                 ModelV2.ID.make("claude-sonnet-4-5"),
@@ -142,7 +142,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin(GoogleVertexAnthropicPlugin)
           const result = yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(
                 ProviderV2.ID.make("google-vertex-anthropic"),
                 ModelV2.ID.make("claude-sonnet-4-5"),
@@ -165,7 +165,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin(GoogleVertexAnthropicPlugin)
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -184,7 +184,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin(GoogleVertexAnthropicPlugin)
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),
@@ -202,7 +202,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
       yield* addPlugin(GoogleVertexPlugin)
       yield* addPlugin(GoogleVertexAnthropicPlugin)
       const sdkResult = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make(" claude-sonnet-4-5 ")),
           api: { id: ModelV2.ID.make(" claude-sonnet-4-5 "), type: "aisdk", package: "test-provider" },
         }),
@@ -210,7 +210,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
         options: { name: "google-vertex", project: "project", location: "us" },
       })
       const languageResult = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make(" claude-sonnet-4-5 ")),
           api: { id: ModelV2.ID.make(" claude-sonnet-4-5 "), type: "aisdk", package: "test-provider" },
         }),
@@ -232,7 +232,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
       const calls: string[] = []
       yield* addPlugin(GoogleVertexAnthropicPlugin)
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex-anthropic"), ModelV2.ID.make(" claude-sonnet-4-5 ")),
           api: { id: ModelV2.ID.make(" claude-sonnet-4-5 "), type: "aisdk", package: "test-provider" },
         }),
@@ -250,7 +250,7 @@ describe("GoogleVertexAnthropicPlugin", () => {
       const calls: string[] = []
       yield* addPlugin(GoogleVertexAnthropicPlugin)
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("claude-sonnet-4-5")),
           api: { id: ModelV2.ID.make("claude-sonnet-4-5"), type: "aisdk", package: "test-provider" },
         }),

packages/core/test/plugin/provider-google-vertex.test.ts

@@ -170,7 +170,7 @@ describe("GoogleVertexPlugin", () => {
           yield* addPlugin()
           const provider = required(yield* catalog.provider.get(ProviderV2.ID.make("google-vertex")))
           yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("gemini")),
               api: {
                 id: ModelV2.ID.make("gemini"),
@@ -295,7 +295,7 @@ describe("GoogleVertexPlugin", () => {
           const aisdk = yield* AISDK.Service
           yield* addPlugin()
           yield* aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("gemini")),
               api: {
                 id: ModelV2.ID.make("gemini"),
@@ -343,7 +343,7 @@ describe("GoogleVertexPlugin", () => {
         Effect.void,
         () =>
           aisdk.runSDK({
-            model: new ModelV2.Info({
+            model: ModelV2.Info.make({
               ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make("gemini")),
               api: {
                 id: ModelV2.ID.make("gemini"),
@@ -374,7 +374,7 @@ describe("GoogleVertexPlugin", () => {
       const calls: string[] = []
       yield* addPlugin()
       yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google-vertex"), ModelV2.ID.make(" gemini-2.5-pro ")),
           api: { id: ModelV2.ID.make(" gemini-2.5-pro "), type: "aisdk", package: "test-provider" },
         }),

packages/core/test/plugin/provider-google.test.ts

@@ -25,7 +25,7 @@ describe("GooglePlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-google"), ModelV2.ID.make("gemini")),
           api: { id: ModelV2.ID.make("gemini"), type: "aisdk", package: "@ai-sdk/google" },
         }),
@@ -43,7 +43,7 @@ describe("GooglePlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("google"), ModelV2.ID.make("gemini")),
           api: { id: ModelV2.ID.make("gemini"), type: "aisdk", package: "@ai-sdk/google" },
         }),
@@ -60,7 +60,7 @@ describe("GooglePlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const sdkEvent = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-google"), ModelV2.ID.make("alias")),
           api: { id: ModelV2.ID.make("gemini-api"), type: "aisdk", package: "@ai-sdk/google" },
         }),

packages/core/test/plugin/provider-groq.test.ts

@@ -26,7 +26,7 @@ describe("GroqPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("llama")),
           api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
         }),
@@ -43,7 +43,7 @@ describe("GroqPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("llama")),
           api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
         }),
@@ -60,7 +60,7 @@ describe("GroqPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("llama")),
           api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
         }),
@@ -77,7 +77,7 @@ describe("GroqPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-groq"), ModelV2.ID.make("llama")),
           api: { id: ModelV2.ID.make("llama"), type: "aisdk", package: "@ai-sdk/groq" },
         }),
@@ -102,7 +102,7 @@ describe("GroqPlugin", () => {
         name: string
       })
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("groq"), ModelV2.ID.make("alias")),
           api: {
             id: ModelV2.ID.make("llama-api"),

packages/core/test/plugin/provider-mistral.test.ts

@@ -26,7 +26,7 @@ describe("MistralPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("mistral"), ModelV2.ID.make("mistral-large")),
           api: { id: ModelV2.ID.make("mistral-large"), type: "aisdk", package: "test-provider" },
         }),
@@ -43,7 +43,7 @@ describe("MistralPlugin", () => {
       const aisdk = yield* AISDK.Service
       yield* addPlugin()
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("mistral"), ModelV2.ID.make("mistral-large")),
           api: { id: ModelV2.ID.make("mistral-large"), type: "aisdk", package: "test-provider" },
         }),
@@ -66,7 +66,7 @@ describe("MistralPlugin", () => {
         }),
       )
       const result = yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("mistral"), ModelV2.ID.make("mistral-large")),
           api: { id: ModelV2.ID.make("mistral-large"), type: "aisdk", package: "test-provider" },
         }),
@@ -90,7 +90,7 @@ describe("MistralPlugin", () => {
         }),
       )
       yield* aisdk.runSDK({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("custom-mistral"), ModelV2.ID.make("mistral-large")),
           api: { id: ModelV2.ID.make("mistral-large"), type: "aisdk", package: "test-provider" },
         }),
@@ -114,7 +114,7 @@ describe("MistralPlugin", () => {
       }
       yield* addPlugin()
       const result = yield* aisdk.runLanguage({
-        model: new ModelV2.Info({
+        model: ModelV2.Info.make({
           ...ModelV2.Info.empty(ProviderV2.ID.make("mistral"), ModelV2.ID.make("alias")),
           api: { id: ModelV2.ID.make("mistral-large"), type: "aisdk", package: "test-provider" },
         }),