refactor(core): narrow shell spawn handling

packages/ai/src/protocols/anthropic-messages.ts

@@ -422,12 +422,14 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: Me
 
 // Tool results may carry structured text, images, and documents. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
-const lowerToolResultContentItem = Effect.fnUntraced(function* (item: Tool.Content) {
+const lowerToolResultContentItem = Effect.fn("AnthropicMessages.lowerToolResultContentItem")(function* (
+  item: Tool.Content,
+) {
   if (item.type === "text") return { type: "text" as const, text: item.text } satisfies AnthropicTextBlock
   return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name })
 })
 
-const lowerToolResultContent = Effect.fnUntraced(function* (part: ToolResultPart) {
+const lowerToolResultContent = Effect.fn("AnthropicMessages.lowerToolResultContent")(function* (part: ToolResultPart) {
   // Text / json / error results stay as a string for backward compatibility
   // with existing cassettes and provider expectations.
   if (part.result.type !== "content") return ProviderShared.toolResultText(part)

packages/ai/src/protocols/open-responses.ts

@@ -358,7 +358,7 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
   return { type: "input_image" as const, image_url: media.dataUrl }
 })
 
-const lowerUserContent = Effect.fnUntraced(function* (
+const lowerUserContent = Effect.fn("OpenResponses.lowerUserContent")(function* (
   part: LLMRequest["messages"][number]["content"][number],
   request: LLMRequest,
   extension: Extension,
@@ -370,7 +370,7 @@ const lowerUserContent = Effect.fnUntraced(function* (
 
 // Tool results may carry structured text, images, and files. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
-const lowerToolResultContentItem = Effect.fnUntraced(function* (
+const lowerToolResultContentItem = Effect.fn("OpenResponses.lowerToolResultContentItem")(function* (
   item: Content,
   request: LLMRequest,
   extension: Extension,
@@ -383,7 +383,7 @@ const lowerToolResultContentItem = Effect.fnUntraced(function* (
   )
 })
 
-const lowerToolResultOutput = Effect.fnUntraced(function* (
+const lowerToolResultOutput = Effect.fn("OpenResponses.lowerToolResultOutput")(function* (
   part: ToolResultPart,
   request: LLMRequest,
   extension: Extension,

packages/ai/src/providers/github-copilot.ts

@@ -0,0 +1,71 @@
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
+import type { RouteDefaultsInput } from "../route/client"
+import { ProviderID, type ModelID } from "../schema"
+import * as OpenAIChat from "../protocols/openai-chat"
+import * as OpenAIResponses from "../protocols/openai-responses"
+import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
+
+export const id = ProviderID.make("github-copilot")
+
+// GitHub Copilot has no canonical public URL — callers (opencode, etc.) must
+// supply `baseURL` explicitly.
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL: string
+    readonly endpoint?: "chat" | "responses"
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
+export const shouldUseResponsesApi = (modelID: string | ModelID, endpoint?: LanguageModelOptions["endpoint"]) => {
+  if (endpoint) return endpoint === "responses"
+  const model = String(modelID)
+  const match = /^gpt-(\d+)/.exec(model)
+  if (!match) return false
+  return Number(match[1]) >= 5 && !model.startsWith("gpt-5-mini")
+}
+
+export const routes = [OpenAIResponses.route, OpenAIChat.route]
+
+const chatRoute = OpenAIChat.route.with({ provider: id })
+const responsesRoute = OpenAIResponses.route.with({ provider: id })
+
+const defaults = (options: LanguageModelOptions) => {
+  const { apiKey: _, auth: _auth, baseURL: _baseURL, endpoint: _endpoint, ...rest } = options
+  return rest
+}
+
+const configuredResponsesRoute = (options: LanguageModelOptions) =>
+  responsesRoute.with({
+    endpoint: { baseURL: options.baseURL },
+    auth: AuthOptions.bearer(options, []),
+  })
+
+const configuredChatRoute = (options: LanguageModelOptions) =>
+  chatRoute.with({
+    endpoint: { baseURL: options.baseURL },
+    auth: AuthOptions.bearer(options, []),
+  })
+
+export const configure = (options: LanguageModelOptions) => {
+  const responsesRoute = configuredResponsesRoute(options)
+  const chatRoute = configuredChatRoute(options)
+  const responses = (modelID: string | ModelID) =>
+    responsesRoute
+      .with(withOpenAIOptions(modelID, defaults(options)))
+      .model<OpenAIProviderOptionsInput>({ id: modelID })
+  const chat = (modelID: string | ModelID) =>
+    chatRoute.with(withOpenAIOptions(modelID, defaults(options))).model<OpenAIProviderOptionsInput>({ id: modelID })
+  return {
+    id,
+    model: (modelID: string | ModelID) =>
+      shouldUseResponsesApi(modelID, options.endpoint) ? responses(modelID) : chat(modelID),
+    responses,
+    chat,
+    configure,
+  }
+}
+
+export const provider = {
+  id,
+  configure,
+}

packages/ai/src/providers/index.ts

@@ -5,6 +5,7 @@ export * as AmazonBedrockMantle from "./amazon-bedrock-mantle"
 export * as Azure from "./azure"
 export * as Cloudflare from "./cloudflare"
 export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare"
+export * as GitHubCopilot from "./github-copilot"
 export * as Google from "./google"
 export * as GoogleVertex from "./google-vertex"
 export * as GoogleVertexChat from "./google-vertex-chat"

packages/ai/src/schema/messages.ts

@@ -45,34 +45,35 @@ const isToolResultValue = (value: unknown): value is ToolResultValue =>
   (value.type === "text" || value.type === "json" || value.type === "error" || value.type === "content") &&
   "value" in value
 
-const toolResultValueSchema = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("json"),
-    value: Schema.Unknown,
-  }),
-  Schema.Struct({
-    type: Schema.Literal("text"),
-    value: Schema.Unknown,
-  }),
-  Schema.Struct({
-    type: Schema.Literal("error"),
-    value: Schema.Unknown,
-  }),
-  Schema.Struct({
-    type: Schema.Literal("content"),
-    value: Schema.Array(Tool.Content),
-  }),
-]).annotate({ identifier: "LLM.ToolResult" })
-export type ToolResultValue = Schema.Schema.Type<typeof toolResultValueSchema>
-
-export const ToolResultValue = Object.assign(toolResultValueSchema, {
-  is: isToolResultValue,
-  make: (value: unknown, type: ToolResultValue["type"] = "json"): ToolResultValue => {
-    if (isToolResultValue(value)) return value
-    if (type === "content") return { type, value: Array.isArray(value) ? value : [] }
-    return { type, value }
+export const ToolResultValue = Object.assign(
+  Schema.Union([
+    Schema.Struct({
+      type: Schema.Literal("json"),
+      value: Schema.Unknown,
+    }),
+    Schema.Struct({
+      type: Schema.Literal("text"),
+      value: Schema.Unknown,
+    }),
+    Schema.Struct({
+      type: Schema.Literal("error"),
+      value: Schema.Unknown,
+    }),
+    Schema.Struct({
+      type: Schema.Literal("content"),
+      value: Schema.Array(Tool.Content),
+    }),
+  ]).annotate({ identifier: "LLM.ToolResult" }),
+  {
+    is: isToolResultValue,
+    make: (value: unknown, type: ToolResultValue["type"] = "json"): ToolResultValue => {
+      if (isToolResultValue(value)) return value
+      if (type === "content") return { type, value: Array.isArray(value) ? value : [] }
+      return { type, value }
+    },
   },
-})
+)
+export type ToolResultValue = Schema.Schema.Type<typeof ToolResultValue>
 
 export interface ToolOutput {
   readonly structured: unknown

packages/ai/test/auth-options.types.ts

@@ -7,6 +7,7 @@ import * as Anthropic from "../src/providers/anthropic"
 import * as AnthropicCompatible from "../src/providers/anthropic-compatible"
 import * as Azure from "../src/providers/azure"
 import * as Cloudflare from "../src/providers/cloudflare"
+import * as GitHubCopilot from "../src/providers/github-copilot"
 import * as Google from "../src/providers/google"
 import * as GoogleVertex from "../src/providers/google-vertex"
 import * as GoogleVertexChat from "../src/providers/google-vertex-chat"
@@ -269,3 +270,7 @@ OpenAICompatible.deepseek.configure({ apiKey: "deepseek-key" }).model("deepseek-
 Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama")
 // @ts-expect-error Cloudflare Workers AI model selectors only accept model ids.
 Cloudflare.CloudflareWorkersAI.configure({ accountId: "account", apiKey: "cf-key" }).model("@cf/meta/llama", {})
+
+GitHubCopilot.configure({ baseURL: "https://copilot.test", apiKey: "copilot-key" }).model("gpt-4.1")
+// @ts-expect-error GitHub Copilot model selectors only accept model ids.
+GitHubCopilot.configure({ baseURL: "https://copilot.test", apiKey: "copilot-key" }).model("gpt-4.1", {})

packages/ai/test/exports.test.ts

@@ -10,6 +10,7 @@ import {
   OpenRouter,
   XAI,
 } from "@opencode-ai/ai/providers"
+import * as GitHubCopilot from "@opencode-ai/ai/providers/github-copilot"
 import {
   OpenAIChat,
   OpenAICompatibleChat,
@@ -59,6 +60,23 @@ describe("public exports", () => {
     expect(XAI.provider.chat).toBe(XAI.chat)
     expect(XAI.configure({ apiKey: "fixture" }).responses("grok-4.3").route.id).toBe("openai-responses")
     expect(XAI.configure({ apiKey: "fixture" }).chat("grok-4.3").route.id).toBe("openai-compatible-chat")
+    expect(
+      GitHubCopilot.configure({ baseURL: "https://api.githubcopilot.test", apiKey: "fixture" }).model,
+    ).toBeFunction()
+    expect(
+      GitHubCopilot.configure({
+        baseURL: "https://api.githubcopilot.test",
+        apiKey: "fixture",
+        endpoint: "responses",
+      }).model("mai-code-1-flash-picker").route.id,
+    ).toBe("openai-responses")
+    expect(
+      GitHubCopilot.configure({
+        baseURL: "https://api.githubcopilot.test",
+        apiKey: "fixture",
+        endpoint: "chat",
+      }).model("gpt-5").route.id,
+    ).toBe("openai-chat")
   })
 
   test("protocol barrels expose supported low-level routes", () => {

packages/ai/test/provider-options/github-copilot.types.ts

@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { GitHubCopilot } from "../../src/providers"
+
+const model = GitHubCopilot.configure({ baseURL: "https://example.com" }).model("gpt-5")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { reasoningSummary: "auto" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Copilot reasoning summaries use the OpenAI union.
+  providerOptions: { openai: { reasoningSummary: "full" } },
+})

packages/app/src/components/dialog-connect-provider.tsx

@@ -1,4 +1,4 @@
-import type { FormAnswer, IntegrationMethod, IntegrationOauthConnectOutput } from "@opencode-ai/client/promise"
+import type { IntegrationMethod, IntegrationOauthConnectOutput } from "@opencode-ai/client/promise"
 import { Button } from "@opencode-ai/ui/button"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Dialog } from "@opencode-ai/ui/dialog"
@@ -40,8 +40,6 @@ import { decode64 } from "@/utils/base64"
 
 const CUSTOM_ID = "_custom"
 type ConnectMethod = Extract<IntegrationMethod, { type: "key" | "oauth" }>
-type IntegrationForm = NonNullable<ConnectMethod["form"]>[number]
-type StringForm = Extract<IntegrationForm, { type: "string" }>
 
 export function useProviderConnectController(options: { onBack?: () => void } = {}) {
   const [store, setStore] = createStore({ selected: undefined as string | undefined })
@@ -436,16 +434,16 @@ function ProviderConnection(props: {
   const [store, setStore] = createStore({
     methodIndex: undefined as undefined | number,
     authorization: undefined as undefined | IntegrationOauthConnectOutput["data"],
-    formAnswer: undefined as FormAnswer | undefined,
-    state: "pending" as undefined | "pending" | "complete" | "error" | "form",
+    promptInputs: undefined as undefined | Record<string, string>,
+    state: "pending" as undefined | "pending" | "complete" | "error" | "prompt",
     error: undefined as string | undefined,
   })
 
   type Action =
     | { type: "method.select"; index: number }
     | { type: "method.reset" }
-    | { type: "auth.form" }
-    | { type: "auth.answer"; answer: FormAnswer | undefined }
+    | { type: "auth.prompt" }
+    | { type: "auth.inputs"; inputs: Record<string, string> }
     | { type: "auth.pending" }
     | { type: "auth.complete"; authorization: IntegrationOauthConnectOutput["data"] }
     | { type: "auth.error"; error: string }
@@ -456,7 +454,7 @@ function ProviderConnection(props: {
         if (action.type === "method.select") {
           draft.methodIndex = action.index
           draft.authorization = undefined
-          draft.formAnswer = undefined
+          draft.promptInputs = undefined
           draft.state = undefined
           draft.error = undefined
           return
@@ -464,18 +462,18 @@ function ProviderConnection(props: {
         if (action.type === "method.reset") {
           draft.methodIndex = undefined
           draft.authorization = undefined
-          draft.formAnswer = undefined
+          draft.promptInputs = undefined
           draft.state = undefined
           draft.error = undefined
           return
         }
-        if (action.type === "auth.form") {
-          draft.state = "form"
+        if (action.type === "auth.prompt") {
+          draft.state = "prompt"
           draft.error = undefined
           return
         }
-        if (action.type === "auth.answer") {
-          draft.formAnswer = action.answer
+        if (action.type === "auth.inputs") {
+          draft.promptInputs = action.inputs
           draft.state = undefined
           draft.error = undefined
           return
@@ -533,7 +531,7 @@ function ProviderConnection(props: {
     return fallback
   }
 
-  async function selectMethod(index: number, answer?: FormAnswer) {
+  async function selectMethod(index: number, inputs?: Record<string, string>) {
     if (timer.current !== undefined) {
       clearTimeout(timer.current)
       timer.current = undefined
@@ -542,17 +540,9 @@ function ProviderConnection(props: {
     const method = methods()[index]
     dispatch({ type: "method.select", index })
 
-    if (method.form?.length && !answer) {
-      dispatch({ type: "auth.form" })
-      return
-    }
-    if (method.type === "key") {
-      dispatch({ type: "auth.answer", answer })
-      return
-    }
     if (method.type === "oauth") {
-      if (method.form?.some((field) => field.type !== "string")) {
-        dispatch({ type: "auth.error", error: "This authentication form contains unsupported fields" })
+      if (method.prompts?.length && !inputs) {
+        dispatch({ type: "auth.prompt" })
         return
       }
       dispatch({ type: "auth.pending" })
@@ -560,7 +550,7 @@ function ProviderConnection(props: {
         .api.integration.oauth.connect({
           integrationID: props.provider,
           methodID: method.id,
-          ...(answer ? { answer } : {}),
+          inputs: inputs ?? {},
           location: location(),
         })
         .then((x) => {
@@ -574,42 +564,41 @@ function ProviderConnection(props: {
     }
   }
 
-  function AuthFormView() {
+  function AuthPromptsView() {
     const [formStore, setFormStore] = createStore({
       value: {} as Record<string, string>,
       index: 0,
     })
 
-    const fields = createMemo<StringForm[]>(() => {
+    const prompts = createMemo(() => {
       const value = method()
-      return (value?.form ?? []).flatMap((field) => (field.type === "string" ? [field] : []))
+      return value?.type === "oauth" ? (value.prompts ?? []) : []
     })
-    const matches = (field: StringForm, value: Record<string, string>) => {
-      return (field.when ?? []).every((condition) => {
-        const actual = value[condition.key]
-        if (actual === undefined) return false
-        return condition.op === "eq" ? actual === condition.value : actual !== condition.value
-      })
+    const matches = (prompt: NonNullable<ReturnType<typeof prompts>[number]>, value: Record<string, string>) => {
+      if (!prompt.when) return true
+      const actual = value[prompt.when.key]
+      if (actual === undefined) return false
+      return prompt.when.op === "eq" ? actual === prompt.when.value : actual !== prompt.when.value
     }
     const current = createMemo(() => {
-      const all = fields()
-      const index = all.findIndex((field, index) => index >= formStore.index && matches(field, formStore.value))
+      const all = prompts()
+      const index = all.findIndex((prompt, index) => index >= formStore.index && matches(prompt, formStore.value))
       if (index === -1) return
       return {
         index,
-        field: all[index],
+        prompt: all[index],
       }
     })
     const valid = createMemo(() => {
       const item = current()
-      if (!item || item.field.options) return false
-      if (!item.field.required) return true
-      return (formStore.value[item.field.key] ?? "").trim().length > 0
+      if (!item || item.prompt.type !== "text") return false
+      const value = formStore.value[item.prompt.key] ?? ""
+      return value.trim().length > 0
     })
 
     async function next(index: number, value: Record<string, string>) {
       if (store.methodIndex === undefined) return
-      const next = fields().findIndex((field, i) => i > index && matches(field, value))
+      const next = prompts().findIndex((prompt, i) => i > index && matches(prompt, value))
       if (next !== -1) {
         setFormStore("index", next)
         return
@@ -620,60 +609,60 @@ function ProviderConnection(props: {
     async function handleSubmit(e: SubmitEvent) {
       e.preventDefault()
       const item = current()
-      if (!item || item.field.options) return
+      if (!item || item.prompt.type !== "text") return
       if (!valid()) return
       await next(item.index, formStore.value)
     }
 
     const item = () => current()
     const text = createMemo(() => {
-      const field = item()?.field
-      if (!field || field.options) return
-      return field
+      const prompt = item()?.prompt
+      if (!prompt || prompt.type !== "text") return
+      return prompt
     })
     const select = createMemo(() => {
-      const field = item()?.field
-      if (!field?.options) return
-      return field
+      const prompt = item()?.prompt
+      if (!prompt || prompt.type !== "select") return
+      return prompt
     })
 
     return (
       <form onSubmit={handleSubmit} class="flex flex-col items-start gap-4">
         <Switch>
-          <Match when={item()?.field.options === undefined}>
+          <Match when={item()?.prompt.type === "text"}>
             <TextField
               type="text"
-              label={text()?.title ?? ""}
+              label={text()?.message ?? ""}
               placeholder={text()?.placeholder}
               value={text() ? (formStore.value[text()!.key] ?? "") : ""}
               onChange={(value) => {
-                const field = text()
-                if (!field) return
-                setFormStore("value", field.key, value)
+                const prompt = text()
+                if (!prompt) return
+                setFormStore("value", prompt.key, value)
               }}
             />
             <Button class="w-auto" type="submit" size="large" variant="primary" disabled={!valid()}>
               {language.t("common.continue")}
             </Button>
           </Match>
-          <Match when={item()?.field.options !== undefined}>
+          <Match when={item()?.prompt.type === "select"}>
             <div class="w-full flex flex-col gap-1.5">
-              <div class="text-14-regular text-text-base">{select()?.title}</div>
+              <div class="text-14-regular text-text-base">{select()?.message}</div>
               <div>
                 <List
                   class="px-3"
                   items={select()?.options ?? []}
                   key={(x) => x.value}
-                  current={select()?.options?.find((x) => x.value === formStore.value[select()!.key])}
+                  current={select()?.options.find((x) => x.value === formStore.value[select()!.key])}
                   onSelect={(value) => {
                     if (!value) return
-                    const field = select()
-                    if (!field) return
+                    const prompt = select()
+                    if (!prompt) return
                     const nextValue = {
                       ...formStore.value,
-                      [field.key]: value.value,
+                      [prompt.key]: value.value,
                     }
-                    setFormStore("value", field.key, value.value)
+                    setFormStore("value", prompt.key, value.value)
                     void next(item()!.index, nextValue)
                   }}
                 >
@@ -683,7 +672,7 @@ function ProviderConnection(props: {
                         <div class="w-2.5 h-0.5 ml-0 bg-icon-strong-base hidden" data-slot="list-item-extra-icon" />
                       </div>
                       <span>{option.label}</span>
-                      <span class="text-14-regular text-text-weak">{option.description}</span>
+                      <span class="text-14-regular text-text-weak">{option.hint}</span>
                     </div>
                   )}
                 </List>
@@ -831,7 +820,6 @@ function ProviderConnection(props: {
         integrationID: props.provider,
         location: location(),
         key: apiKey,
-        ...(store.formAnswer ? { answer: store.formAnswer } : {}),
       })
       await complete()
     }
@@ -1155,8 +1143,8 @@ function ProviderConnection(props: {
                 </div>
               </div>
             </Match>
-            <Match when={store.state === "form"}>
-              <AuthFormView />
+            <Match when={store.state === "prompt"}>
+              <AuthPromptsView />
             </Match>
             <Match when={store.state === "error"}>
               <div class="text-14-regular text-text-base">

packages/app/src/context/server-sync.tsx

@@ -662,12 +662,13 @@ export function createServerSyncContextInner(serverSDK: ServerSDK) {
               integrationID: server.integrationID,
               location: { directory: key },
             })
-            const method = integration.data?.methods.find((item) => item.type === "oauth" && !item.form?.length)
+            const method = integration.data?.methods.find((item) => item.type === "oauth" && !item.prompts?.length)
             if (!method || method.type !== "oauth")
               throw new Error(`MCP server ${name} requires an interactive authentication form`)
             const attempt = await serverSDK.api.integration.oauth.connect({
               integrationID: server.integrationID,
               methodID: method.id,
+              inputs: {},
               location: { directory: key },
             })
             platform.openLink(attempt.data.url)

packages/cli/src/commands/handlers/console/login.ts

@@ -50,7 +50,7 @@ const login = Effect.fn("cli.console.login.run")(function* (timeline: TimelineHo
       {
         integrationID,
         methodID: method.id,
-        ...(server ? { answer: { server } } : {}),
+        inputs: server ? { server } : {},
         location,
       },
       { signal },

packages/cli/src/commands/handlers/mcp/auth.ts

@@ -32,7 +32,7 @@ export default Runtime.handler(
       return yield* Effect.fail(new Error(`MCP server "${input.name}" is not an OAuth-capable remote server`))
 
     const started = yield* Effect.promise(() =>
-      client.integration.oauth.connect({ integrationID: integration.id, methodID: method.id, location }),
+      client.integration.oauth.connect({ integrationID: integration.id, methodID: method.id, inputs: {}, location }),
     )
     const attempt = started.data
     if (attempt.mode === "code")

packages/cli/src/server-process.ts

@@ -92,6 +92,10 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
             file: process.env.OPENCODE_MODELS_PATH,
             fetch: !truthy(process.env.OPENCODE_DISABLE_MODELS_FETCH),
           },
+          observability: {
+            endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+            headers: process.env.OTEL_EXPORTER_OTLP_HEADERS,
+          },
           config: {
             directory: process.env.OPENCODE_CONFIG_DIR,
             project: !truthy(

packages/client/src/effect/api/api.ts

@@ -23,9 +23,9 @@ import type { Shell } from "@opencode-ai/schema/shell"
 import type { DateTime } from "effect"
 import type { Provider } from "@opencode-ai/schema/provider"
 import type { Integration } from "@opencode-ai/schema/integration"
-import type { Form } from "@opencode-ai/schema/form"
 import type { Mcp } from "@opencode-ai/schema/mcp"
 import type { Credential } from "@opencode-ai/schema/credential"
+import type { Form } from "@opencode-ai/schema/form"
 import type { Permission } from "@opencode-ai/schema/permission"
 import type { PermissionSaved } from "@opencode-ai/schema/permission-saved"
 import type { FileSystem } from "@opencode-ai/schema/filesystem"
@@ -180,7 +180,6 @@ export type Endpoint5_12Input = {
   readonly text: string
   readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined
   readonly agents?: ReadonlyArray<AgentAttachment> | undefined
-  readonly skills?: ReadonlyArray<PromptInput.SkillAttachment> | undefined
   readonly metadata?: { readonly [x: string]: unknown } | undefined
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
@@ -197,7 +196,6 @@ export type Endpoint5_13Input = {
   readonly model?: Model.Ref | undefined
   readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined
   readonly agents?: ReadonlyArray<AgentAttachment> | undefined
-  readonly skills?: ReadonlyArray<PromptInput.SkillAttachment> | undefined
   readonly delivery?: "steer" | "queue" | undefined
   readonly resume?: boolean | undefined
 }
@@ -1054,7 +1052,6 @@ export type Endpoint10_3Input = {
   readonly integrationID: Integration.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly key: string
-  readonly answer?: Form.Answer | undefined
   readonly label?: string | undefined
 }
 export type Endpoint10_3Output = void
@@ -1066,7 +1063,7 @@ export type Endpoint10_4Input = {
   readonly integrationID: Integration.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly methodID: Integration.MethodID
-  readonly answer?: Form.Answer | undefined
+  readonly inputs: { readonly [x: string]: string }
   readonly label?: string | undefined
 }
 export type Endpoint10_4Output = { readonly location: Location.Info; readonly data: Integration.Attempt }

packages/client/src/effect/generated/client.ts

@@ -412,7 +412,6 @@ const Endpoint5_12 = (raw: RawClient["server.session"]) => (input: Endpoint5_12I
         text: input["text"],
         files: input["files"],
         agents: input["agents"],
-        skills: input["skills"],
         metadata: input["metadata"],
         delivery: input["delivery"],
         resume: input["resume"],
@@ -435,7 +434,6 @@ const Endpoint5_13 = (raw: RawClient["server.session"]) => (input: Endpoint5_13I
         model: input["model"],
         files: input["files"],
         agents: input["agents"],
-        skills: input["skills"],
         delivery: input["delivery"],
         resume: input["resume"],
       },
@@ -717,7 +715,7 @@ const Endpoint10_3 = (raw: RawClient["server.integration"]) => (input: Endpoint1
     raw["integration.connect.key"]({
       params: { integrationID: input["integrationID"] },
       query: { location: input["location"] },
-      payload: { key: input["key"], answer: input["answer"], label: input["label"] },
+      payload: { key: input["key"], label: input["label"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
@@ -726,7 +724,7 @@ const Endpoint10_4 = (raw: RawClient["server.integration"]) => (input: Endpoint1
     raw["integration.oauth.connect"]({
       params: { integrationID: input["integrationID"] },
       query: { location: input["location"] },
-      payload: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
+      payload: { methodID: input["methodID"], inputs: input["inputs"], label: input["label"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 

packages/client/src/promise/generated/client.ts

@@ -615,7 +615,6 @@ export function make(options: ClientOptions) {
               text: input["text"],
               files: input["files"],
               agents: input["agents"],
-              skills: input["skills"],
               metadata: input["metadata"],
               delivery: input["delivery"],
               resume: input["resume"],
@@ -639,7 +638,6 @@ export function make(options: ClientOptions) {
               model: input["model"],
               files: input["files"],
               agents: input["agents"],
-              skills: input["skills"],
               delivery: input["delivery"],
               resume: input["resume"],
             },
@@ -1032,7 +1030,7 @@ export function make(options: ClientOptions) {
               method: "POST",
               path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
               query: { location: input["location"] },
-              body: { key: input["key"], answer: input["answer"], label: input["label"] },
+              body: { key: input["key"], label: input["label"] },
               successStatus: 204,
               declaredStatuses: [400, 401],
               empty: true,
@@ -1047,7 +1045,7 @@ export function make(options: ClientOptions) {
               method: "POST",
               path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
               query: { location: input["location"] },
-              body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
+              body: { methodID: input["methodID"], inputs: input["inputs"], label: input["label"] },
               successStatus: 200,
               declaredStatuses: [400, 401],
               empty: false,

packages/client/src/promise/generated/types.ts

@@ -41,7 +41,6 @@ export type SessionMessageAgentSelected = {
   time: { created: number }
   type: "agent-switched"
   agent: string
-  previous?: string
 }
 
 export type PromptBase64 = string
@@ -196,18 +195,12 @@ export type ProviderInfo = {
   body?: { [x: string]: any }
 }
 
-export type FormWhen = {
-  key: string
-  op: "eq" | "neq"
-  value: string | number | "Infinity" | "-Infinity" | "NaN" | boolean
-}
-
-export type FormOption = { value: string; label: string; description?: string }
-
-export type FormExternalField = { key: string; type: "external"; url: string; title?: string; description?: string }
+export type IntegrationWhen = { key: string; op: "eq" | "neq"; value: string }
 
 export type IntegrationCommandMethod = { id: string; type: "command"; label: string; command: Array<string> }
 
+export type IntegrationKeyMethod = { type: "key"; label?: string }
+
 export type IntegrationEnvMethod = { type: "env"; names: Array<string> }
 
 export type ConnectionCredentialInfo = { type: "credential"; id: string; label: string }
@@ -292,6 +285,16 @@ export type ProjectDirectory = { directory: string; strategy?: string }
 
 export type FormMetadata = { [x: string]: JsonValue }
 
+export type FormWhen = {
+  key: string
+  op: "eq" | "neq"
+  value: string | number | "Infinity" | "-Infinity" | "NaN" | boolean
+}
+
+export type FormOption = { value: string; label: string; description?: string }
+
+export type FormExternalField = { key: string; type: "external"; url: string; title?: string; description?: string }
+
 export type FormValue = string | number | boolean | Array<string>
 
 export type PermissionSource = { type: "tool"; messageID: string; id: string }
@@ -1077,8 +1080,6 @@ export type PromptFileAttachment = {
 
 export type PromptAgentAttachment = { name: string; mention?: PromptMention }
 
-export type PromptSkillAttachment = { id: string; name: string; text: string; mention?: PromptMention }
-
 export type SessionMessageAssistantText = { type: "text"; text: string; state?: SessionMessageProviderState }
 
 export type SessionMessageAssistantReasoning = {
@@ -1274,6 +1275,45 @@ export type ModelCost = {
   cache: { read: MoneyUSDPerMillionTokens; write: MoneyUSDPerMillionTokens }
 }
 
+export type IntegrationTextPrompt = {
+  type: "text"
+  key: string
+  message: string
+  placeholder?: string
+  when?: IntegrationWhen
+}
+
+export type IntegrationSelectPrompt = {
+  type: "select"
+  key: string
+  message: string
+  options: Array<{ label: string; value: string; hint?: string }>
+  when?: IntegrationWhen
+}
+
+export type ConnectionInfo = ConnectionCredentialInfo | ConnectionEnvInfo
+
+export type McpServer = {
+  name: string
+  status: McpStatusConnected | McpStatusPending | McpStatusDisabled | McpStatusFailed | McpStatusNeedsAuth
+  integrationID?: string
+}
+
+export type McpResourceCatalog = { resources: Array<McpResource>; templates: Array<McpResourceTemplate> }
+
+export type Project = {
+  id: string
+  canonical: string
+  vcs?: ProjectVcs
+  name?: string
+  icon?: ProjectIcon
+  commands?: ProjectCommands
+  time: ProjectTime
+  sandboxes: Array<string>
+}
+
+export type ProjectDirectories = Array<ProjectDirectory>
+
 export type FormNumberField = {
   key: string
   title?: string
@@ -1339,29 +1379,6 @@ export type FormMultiselectField = {
   default?: Array<string>
 }
 
-export type ConnectionInfo = ConnectionCredentialInfo | ConnectionEnvInfo
-
-export type McpServer = {
-  name: string
-  status: McpStatusConnected | McpStatusPending | McpStatusDisabled | McpStatusFailed | McpStatusNeedsAuth
-  integrationID?: string
-}
-
-export type McpResourceCatalog = { resources: Array<McpResource>; templates: Array<McpResourceTemplate> }
-
-export type Project = {
-  id: string
-  canonical: string
-  vcs?: ProjectVcs
-  name?: string
-  icon?: ProjectIcon
-  commands?: ProjectCommands
-  time: ProjectTime
-  sandboxes: Array<string>
-}
-
-export type ProjectDirectories = Array<ProjectDirectory>
-
 export type FormAnswer = { [x: string]: FormValue }
 
 export type PermissionRequest = {
@@ -1548,7 +1565,6 @@ export type SessionMessageUser = {
   text: string
   files?: Array<PromptFileAttachment>
   agents?: Array<PromptAgentAttachment>
-  skills?: Array<PromptSkillAttachment>
   type: "user"
 }
 
@@ -1556,7 +1572,6 @@ export type SessionPendingUserData = {
   text: string
   files?: Array<PromptFileAttachment>
   agents?: Array<PromptAgentAttachment>
-  skills?: Array<PromptSkillAttachment>
   metadata?: { [x: string]: JsonValue }
 }
 
@@ -1564,7 +1579,6 @@ export type SessionPendingUserData1 = {
   text: string
   files?: Array<PromptFileAttachment>
   agents?: Array<PromptAgentAttachment>
-  skills?: Array<PromptSkillAttachment>
   metadata?: { [x: string]: any }
 }
 
@@ -1645,6 +1659,13 @@ export type ModelInfo = {
   limit: { context: number; input?: number; output: number }
 }
 
+export type IntegrationOAuthMethod = {
+  id: string
+  type: "oauth"
+  label: string
+  prompts?: Array<IntegrationTextPrompt | IntegrationSelectPrompt>
+}
+
 export type FormField =
   | FormStringField
   | FormNumberField
@@ -1898,9 +1919,15 @@ export type SessionMessageAssistantTool = {
   time: { created: number; ran?: number; completed?: number }
 }
 
+export type IntegrationMethod =
+  | IntegrationOAuthMethod
+  | IntegrationCommandMethod
+  | IntegrationKeyMethod
+  | IntegrationEnvMethod
+
 export type FormFields = [FormField, ...Array<FormField>]
 
-export type FormFields3 = [FormField1, ...Array<FormField1>]
+export type FormFields1 = [FormField1, ...Array<FormField1>]
 
 export type SessionPendingInfo = SessionPendingUser | SessionPendingSynthetic | SessionPendingCompaction
 
@@ -1922,13 +1949,16 @@ export type SessionMessageAssistant = {
   retry?: SessionMessageAssistantRetry
 }
 
-export type IntegrationOAuthMethod = { id: string; type: "oauth"; label: string; form?: FormFields }
-
-export type IntegrationKeyMethod = { type: "key"; label?: string; form?: FormFields }
+export type IntegrationInfo = {
+  id: string
+  name: string
+  methods: Array<IntegrationMethod>
+  connections: Array<ConnectionInfo>
+}
 
 export type FormInfo = { id: string; sessionID: string; title: string; metadata?: FormMetadata; fields: FormFields }
 
-export type FormInfo1 = { id: string; sessionID: string; title: string; metadata?: FormMetadata1; fields: FormFields3 }
+export type FormInfo1 = { id: string; sessionID: string; title: string; metadata?: FormMetadata1; fields: FormFields1 }
 
 export type SessionInputAdmitted = {
   id: string
@@ -1951,12 +1981,6 @@ export type SessionMessageInfo =
   | SessionMessageAssistant
   | SessionMessageCompaction
 
-export type IntegrationMethod =
-  | IntegrationOAuthMethod
-  | IntegrationCommandMethod
-  | IntegrationKeyMethod
-  | IntegrationEnvMethod
-
 export type FormCreated = {
   id: string
   created: number
@@ -2017,13 +2041,6 @@ export type SessionMessagesResponse = {
   cursor: { previous?: string | null; next?: string | null }
 }
 
-export type IntegrationInfo = {
-  id: string
-  name: string
-  methods: Array<IntegrationMethod>
-  connections: Array<ConnectionInfo>
-}
-
 export type V2Event =
   | ModelsDevRefreshed
   | IntegrationUpdated
@@ -2536,7 +2553,6 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
-          readonly previous?: string
         }
       | {
           readonly id: string
@@ -2563,12 +2579,6 @@ export type SessionImportInput = {
             readonly name: string
             readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
           }>
-          readonly skills?: ReadonlyArray<{
-            readonly id: string
-            readonly name: string
-            readonly text: string
-            readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-          }>
           readonly type: "user"
         }
       | {
@@ -2788,7 +2798,6 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
-          readonly previous?: string
         }
       | {
           readonly id: string
@@ -2815,12 +2824,6 @@ export type SessionImportInput = {
             readonly name: string
             readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
           }>
-          readonly skills?: ReadonlyArray<{
-            readonly id: string
-            readonly name: string
-            readonly text: string
-            readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-          }>
           readonly type: "user"
         }
       | {
@@ -3040,7 +3043,6 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
-          readonly previous?: string
         }
       | {
           readonly id: string
@@ -3067,12 +3069,6 @@ export type SessionImportInput = {
             readonly name: string
             readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
           }>
-          readonly skills?: ReadonlyArray<{
-            readonly id: string
-            readonly name: string
-            readonly text: string
-            readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-          }>
           readonly type: "user"
         }
       | {
@@ -3324,10 +3320,6 @@ export type SessionPromptInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
@@ -3345,10 +3337,6 @@ export type SessionPromptInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
@@ -3366,10 +3354,6 @@ export type SessionPromptInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
@@ -3387,35 +3371,10 @@ export type SessionPromptInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["agents"]
-  readonly skills?: {
-    readonly id?: string | null
-    readonly text: string
-    readonly files?: ReadonlyArray<{
-      readonly uri: string
-      readonly name?: string
-      readonly description?: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
-    readonly agents?: ReadonlyArray<{
-      readonly name: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
-    readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly delivery?: "steer" | "queue" | null
-    readonly resume?: boolean | null
-  }["skills"]
   readonly metadata?: {
     readonly id?: string | null
     readonly text: string
@@ -3429,10 +3388,6 @@ export type SessionPromptInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
@@ -3450,10 +3405,6 @@ export type SessionPromptInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
@@ -3471,10 +3422,6 @@ export type SessionPromptInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly metadata?: { readonly [x: string]: JsonValue }
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
@@ -3501,10 +3448,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["id"]
@@ -3524,10 +3467,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["command"]
@@ -3547,10 +3486,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["arguments"]
@@ -3570,10 +3505,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["agent"]
@@ -3593,10 +3524,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["model"]
@@ -3616,10 +3543,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["files"]
@@ -3639,36 +3562,9 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["agents"]
-  readonly skills?: {
-    readonly id?: string | null
-    readonly command: string
-    readonly arguments?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
-    readonly files?: ReadonlyArray<{
-      readonly uri: string
-      readonly name?: string
-      readonly description?: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
-    readonly agents?: ReadonlyArray<{
-      readonly name: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
-    readonly delivery?: "steer" | "queue" | null
-    readonly resume?: boolean | null
-  }["skills"]
   readonly delivery?: {
     readonly id?: string | null
     readonly command: string
@@ -3685,10 +3581,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["delivery"]
@@ -3708,10 +3600,6 @@ export type SessionCommandInput = {
       readonly name: string
       readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
     }>
-    readonly skills?: ReadonlyArray<{
-      readonly id: string
-      readonly mention?: { readonly start: number; readonly end: number; readonly text: string }
-    }>
     readonly delivery?: "steer" | "queue" | null
     readonly resume?: boolean | null
   }["resume"]
@@ -4026,21 +3914,8 @@ export type IntegrationConnectKeyInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   }["location"]
-  readonly key: {
-    readonly key: string
-    readonly answer?: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> } | undefined
-    readonly label?: string | undefined
-  }["key"]
-  readonly answer?: {
-    readonly key: string
-    readonly answer?: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> } | undefined
-    readonly label?: string | undefined
-  }["answer"]
-  readonly label?: {
-    readonly key: string
-    readonly answer?: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> } | undefined
-    readonly label?: string | undefined
-  }["label"]
+  readonly key: { readonly key: string; readonly label?: string | undefined }["key"]
+  readonly label?: { readonly key: string; readonly label?: string | undefined }["label"]
 }
 
 export type IntegrationConnectKeyOutput = void
@@ -4052,17 +3927,17 @@ export type IntegrationOauthConnectInput = {
   }["location"]
   readonly methodID: {
     readonly methodID: string
-    readonly answer?: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> } | undefined
+    readonly inputs: { readonly [x: string]: string }
     readonly label?: string | undefined
   }["methodID"]
-  readonly answer?: {
+  readonly inputs: {
     readonly methodID: string
-    readonly answer?: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> } | undefined
+    readonly inputs: { readonly [x: string]: string }
     readonly label?: string | undefined
-  }["answer"]
+  }["inputs"]
   readonly label?: {
     readonly methodID: string
-    readonly answer?: { readonly [x: string]: string | number | boolean | ReadonlyArray<string> } | undefined
+    readonly inputs: { readonly [x: string]: string }
     readonly label?: string | undefined
   }["label"]
 }

packages/client/test/promise.test.ts

@@ -148,49 +148,6 @@ test("experimental wellknown integration add uses the public HTTP contract", asy
   expect(await request?.json()).toEqual({ url: "https://example.com" })
 })
 
-test("integration connections optionally submit a form answer", async () => {
-  const requests: Request[] = []
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      requests.push(request)
-      if (request.url.endsWith("/connect/key")) return new Response(null, { status: 204 })
-      return Response.json({
-        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
-        data: {
-          attemptID: "con_test",
-          url: "https://example.com/authorize",
-          instructions: "Authorize",
-          mode: "auto",
-          time: { created: 1, expires: 2 },
-        },
-      })
-    },
-  })
-
-  await client.integration.connect.key({
-    integrationID: "cloudflare-workers-ai",
-    key: "secret",
-    answer: { accountId: "account" },
-  })
-  await client.integration.oauth.connect({
-    integrationID: "github-copilot",
-    methodID: "device",
-    answer: { deploymentType: "enterprise", enabled: true, scopes: ["read:user"] },
-  })
-  await client.integration.connect.key({ integrationID: "openai", key: "secret" })
-  await client.integration.oauth.connect({ integrationID: "openai", methodID: "device" })
-
-  expect(await requests[0].json()).toEqual({ key: "secret", answer: { accountId: "account" } })
-  expect(await requests[1].json()).toEqual({
-    methodID: "device",
-    answer: { deploymentType: "enterprise", enabled: true, scopes: ["read:user"] },
-  })
-  expect(await requests[2].json()).toEqual({ key: "secret" })
-  expect(await requests[3].json()).toEqual({ methodID: "device" })
-})
-
 test("health.stop sends exact replacement identity", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/core/schema.json

@@ -1,9 +1,13 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "15060ec5-05f7-4b86-b2a5-9108609432b3",
-  "prevIds": ["1551a157-8959-4ba9-a52b-4ea3b7b28cae"],
+  "id": "2d214a71-3b0a-48c1-a667-741952c4e188",
+  "prevIds": ["f14a9b18-8207-487e-a3d3-227e629ba9ad"],
   "ddl": [
+    {
+      "name": "workspace",
+      "entityType": "tables"
+    },
     {
       "name": "account_state",
       "entityType": "tables"
@@ -69,8 +73,84 @@
       "entityType": "tables"
     },
     {
-      "name": "workspace",
-      "entityType": "tables"
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "id",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "type",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": "''",
+      "generated": null,
+      "name": "name",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "branch",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "directory",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": false,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "extra",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "text",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "project_id",
+      "entityType": "columns",
+      "table": "workspace"
+    },
+    {
+      "type": "integer",
+      "notNull": true,
+      "autoincrement": false,
+      "default": null,
+      "generated": null,
+      "name": "time_used",
+      "entityType": "columns",
+      "table": "workspace"
     },
     {
       "type": "integer",
@@ -1303,53 +1383,14 @@
       "table": "session_v2"
     },
     {
-      "type": "text",
-      "notNull": false,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "id",
-      "entityType": "columns",
-      "table": "workspace"
-    },
-    {
-      "type": "text",
-      "notNull": true,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "provider",
-      "entityType": "columns",
-      "table": "workspace"
-    },
-    {
-      "type": "text",
-      "notNull": true,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "binding",
-      "entityType": "columns",
-      "table": "workspace"
-    },
-    {
-      "type": "integer",
-      "notNull": true,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "created_at",
-      "entityType": "columns",
-      "table": "workspace"
-    },
-    {
-      "type": "integer",
-      "notNull": true,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "last_used_at",
-      "entityType": "columns",
+      "columns": ["project_id"],
+      "tableTo": "project",
+      "columnsTo": ["id"],
+      "onUpdate": "NO ACTION",
+      "onDelete": "CASCADE",
+      "nameExplicit": false,
+      "name": "fk_workspace_project_id_project_id_fk",
+      "entityType": "fks",
       "table": "workspace"
     },
     {
@@ -1472,6 +1513,13 @@
       "entityType": "pks",
       "table": "instruction_entry"
     },
+    {
+      "columns": ["id"],
+      "nameExplicit": false,
+      "name": "workspace_pk",
+      "table": "workspace",
+      "entityType": "pks"
+    },
     {
       "columns": ["id"],
       "nameExplicit": false,
@@ -1563,13 +1611,6 @@
       "table": "session_v2",
       "entityType": "pks"
     },
-    {
-      "columns": ["id"],
-      "nameExplicit": false,
-      "name": "workspace_pk",
-      "table": "workspace",
-      "entityType": "pks"
-    },
     {
       "columns": [
         {

packages/core/src/control-plane/workspace.sql.ts

@@ -0,0 +1,20 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core"
+import { ProjectTable } from "../project/sql"
+import { Project } from "../project"
+import { Workspace } from "../workspace"
+
+export const WorkspaceTable = sqliteTable("workspace", {
+  id: text().$type<Workspace.ID>().primaryKey(),
+  type: text().notNull(),
+  name: text().notNull().default(""),
+  branch: text(),
+  directory: text(),
+  extra: text({ mode: "json" }),
+  project_id: text()
+    .$type<Project.ID>()
+    .notNull()
+    .references(() => ProjectTable.id, { onDelete: "cascade" }),
+  time_used: integer()
+    .notNull()
+    .$default(() => Date.now()),
+})

packages/core/src/database/migration.gen.ts

@@ -42,6 +42,5 @@ export const migrations: DatabaseMigration.Migration[] = (
     import("./migration/20260622202450_simplify_session_input"),
     import("./migration/20260804233008_loose_psylocke"),
     import("./migration/20260805200742_import_legacy_credentials"),
-    import("./migration/20260808023530_workspace_domain"),
   ])
 ).map((module) => module.default)

packages/core/src/database/migration/20260808023530_workspace_domain.ts

@@ -1,22 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration"
-
-const migration: DatabaseMigration.Migration = {
-  id: "20260808023530_workspace_domain",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`DROP TABLE \`workspace\`;`)
-      yield* tx.run(`
-        CREATE TABLE \`workspace\` (
-          \`id\` text PRIMARY KEY,
-          \`provider\` text NOT NULL,
-          \`binding\` text NOT NULL,
-          \`created_at\` integer NOT NULL,
-          \`last_used_at\` integer NOT NULL
-        );
-      `)
-    })
-  },
-}
-
-export default migration

packages/core/src/database/schema.gen.ts

@@ -4,6 +4,19 @@ import type { DatabaseMigration } from "./migration"
 const schema: Omit<DatabaseMigration.Migration, "id"> = {
   up(tx) {
     return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`type\` text NOT NULL,
+          \`name\` text DEFAULT '' NOT NULL,
+          \`branch\` text,
+          \`directory\` text,
+          \`extra\` text,
+          \`project_id\` text NOT NULL,
+          \`time_used\` integer NOT NULL,
+          CONSTRAINT \`fk_workspace_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `)
       yield* tx.run(`
         CREATE TABLE \`account_state\` (
           \`id\` integer PRIMARY KEY,
@@ -203,15 +216,6 @@ const schema: Omit<DatabaseMigration.Migration, "id"> = {
           CONSTRAINT \`fk_session_v2_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
         );
       `)
-      yield* tx.run(`
-        CREATE TABLE \`workspace\` (
-          \`id\` text PRIMARY KEY,
-          \`provider\` text NOT NULL,
-          \`binding\` text NOT NULL,
-          \`created_at\` integer NOT NULL,
-          \`last_used_at\` integer NOT NULL
-        );
-      `)
       yield* tx.run(`CREATE UNIQUE INDEX \`event_aggregate_seq_idx\` ON \`event\` (\`aggregate_id\`,\`seq\`);`)
       yield* tx.run(`CREATE INDEX \`event_aggregate_type_seq_idx\` ON \`event\` (\`aggregate_id\`,\`type\`,\`seq\`);`)
       yield* tx.run(

packages/core/src/environment/environment.ts

@@ -5,8 +5,6 @@ import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner
 import type { Files } from "./files"
 import { makeFiles } from "./index"
 import { makeLocalDriver } from "./local"
-import { Location } from "../location"
-import { Workspace } from "../workspace"
 
 export interface Interface {
   readonly files: Files
@@ -19,25 +17,10 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const spawner = yield* ChildProcessSpawner
-    const location = yield* Location.Service
-    const workspace = yield* Workspace.Service
-    const driver = location.workspaceID
-      ? yield* workspace.connect(location.workspaceID).pipe(
-          // Environment has no error channel; an unknown or destroyed placement is a configuration defect by design.
-          Effect.mapError(
-            (cause) => new Error(`Failed to bind Environment to workspace ${location.workspaceID}`, { cause }),
-          ),
-          Effect.orDie,
-        )
-      : makeLocalDriver(spawner)
-    return Service.of({ files: makeFiles(driver), spawner: driver.spawner })
+    return Service.of({ files: makeFiles(makeLocalDriver(spawner)), spawner })
   }),
 )
 
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [CrossSpawnSpawner.node, Location.node, Workspace.node],
-})
+export const node = makeLocationNode({ service: Service, layer, deps: [CrossSpawnSpawner.node] })
 
 export * as EnvironmentService from "./environment"

packages/core/src/form.ts

@@ -180,7 +180,7 @@ export const layer = Layer.effect(
         Effect.gen(function* () {
           const entry = yield* find(input.id)
           if (entry.state.status !== "pending") return yield* new AlreadySettledError({ id: input.id })
-          const invalid = validateAnswer(entry.form.fields, input.answer)
+          const invalid = validateAnswer(entry.form, input.answer)
           if (invalid) return yield* new InvalidAnswerError({ id: input.id, message: invalid })
           const next: TerminalState = { status: "answered", answer: input.answer }
           yield* bus.publish(Form.Event.Replied, {
@@ -227,12 +227,12 @@ export const locationLayer = layer
 
 export const node = makeLocationNode({ service: Service, layer, deps: [Bus.node] })
 
-export function validateAnswer(form: ReadonlyArray<Form.Field>, answer: Answer) {
-  const fields = new Map(form.map((field) => [field.key, field] as const))
+function validateAnswer(form: Info, answer: Answer) {
+  const fields = new Map(form.fields.map((field) => [field.key, field] as const))
   for (const key of Object.keys(answer)) {
     if (!fields.has(key)) return `Unknown form field: ${key}`
   }
-  for (const field of form) {
+  for (const field of form.fields) {
     const value = answer[field.key]
     if (field.type === "external") {
       if (value !== true) return `External form field must be acknowledged: ${field.key}`
@@ -268,7 +268,7 @@ function matches(when: Form.When, value: Form.Value | undefined) {
 // carry a value matching that field's type, and use a declared option when the field's options
 // are closed. Rejecting these at creation surfaces authoring mistakes to the caller instead of
 // silently never matching.
-export function validateFields(fields: ReadonlyArray<Form.Field>) {
+function validateFields(fields: ReadonlyArray<Form.Field>) {
   if (fields.length === 0) return "Form must have at least one field"
   const earlier = new Map<string, InputField>()
   const keys = new Set<string>()

packages/core/src/github-copilot/responses/convert-to-openai-responses-input.ts

@@ -127,7 +127,7 @@ export async function convertToOpenAIResponsesInput({
               input.push({
                 role: "assistant",
                 content: [{ type: "output_text", text: part.text }],
-                id: store ? ((part.providerOptions?.copilot?.itemId as string) ?? undefined) : undefined,
+                id: (part.providerOptions?.copilot?.itemId as string) ?? undefined,
               })
               break
             }
@@ -143,7 +143,7 @@ export async function convertToOpenAIResponsesInput({
                 input.push({
                   type: "local_shell_call",
                   call_id: part.toolCallId,
-                  id: store ? ((part.providerOptions?.copilot?.itemId as string) ?? undefined) : undefined,
+                  id: (part.providerOptions?.copilot?.itemId as string) ?? undefined,
                   action: {
                     type: "exec",
                     command: parsedInput.action.command,
@@ -162,7 +162,7 @@ export async function convertToOpenAIResponsesInput({
                 call_id: part.toolCallId,
                 name: part.toolName,
                 arguments: JSON.stringify(part.input),
-                id: store ? ((part.providerOptions?.copilot?.itemId as string) ?? undefined) : undefined,
+                id: (part.providerOptions?.copilot?.itemId as string) ?? undefined,
               })
               break
             }
@@ -206,14 +206,35 @@ export async function convertToOpenAIResponsesInput({
                       summary: [],
                     }
                   }
-                } else if (providerOptions?.reasoningEncryptedContent != null && reasoningMessage === undefined) {
-                  reasoningMessages[reasoningId] = {
-                    type: "reasoning",
-                    id: reasoningId,
-                    encrypted_content: providerOptions.reasoningEncryptedContent,
-                    summary: [],
+                } else {
+                  const summaryParts: Array<{
+                    type: "summary_text"
+                    text: string
+                  }> = []
+
+                  if (part.text.length > 0) {
+                    summaryParts.push({
+                      type: "summary_text",
+                      text: part.text,
+                    })
+                  } else if (reasoningMessage !== undefined) {
+                    warnings.push({
+                      type: "other",
+                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                    })
+                  }
+
+                  if (reasoningMessage === undefined) {
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      encrypted_content: providerOptions?.reasoningEncryptedContent,
+                      summary: summaryParts,
+                    }
+                    input.push(reasoningMessages[reasoningId])
+                  } else {
+                    reasoningMessage.summary.push(...summaryParts)
                   }
-                  input.push(reasoningMessages[reasoningId])
                 }
               } else {
                 warnings.push({

packages/core/src/github-copilot/responses/openai-responses-api-types.ts

@@ -71,7 +71,7 @@ export type OpenAIResponsesComputerCall = {
 
 export type OpenAIResponsesLocalShellCall = {
   type: "local_shell_call"
-  id?: string
+  id: string
   call_id: string
   action: {
     type: "exec"

packages/core/src/github-copilot/responses/openai-responses-language-model.ts

@@ -198,13 +198,12 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       providerOptions,
       schema: openaiResponsesProviderOptionsSchema,
     })
-    const store = openaiOptions?.store ?? false
 
     const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput({
       prompt,
       systemMessageMode: modelConfig.systemMessageMode,
       fileIdPrefixes: this.config.fileIdPrefixes,
-      store,
+      store: openaiOptions?.store ?? true,
       hasLocalShellTool: hasOpenAITool("openai.local_shell"),
     })
 
@@ -215,12 +214,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
     let include: OpenAIResponsesIncludeOptions = openaiOptions?.include
 
     function addInclude(key: OpenAIResponsesIncludeValue) {
-      if (include?.includes(key)) return
       include = include != null ? [...include, key] : [key]
     }
 
-    addInclude("reasoning.encrypted_content")
-
     function hasOpenAITool(id: string) {
       return tools?.find((tool) => tool.type === "provider" && tool.id === id) != null
     }
@@ -286,7 +282,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       metadata: openaiOptions?.metadata,
       parallel_tool_calls: openaiOptions?.parallelToolCalls,
       previous_response_id: openaiOptions?.previousResponseId,
-      store,
+      store: openaiOptions?.store,
       user: openaiOptions?.user,
       instructions: openaiOptions?.instructions,
       service_tier: openaiOptions?.serviceTier,
@@ -844,7 +840,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       {
         canonicalId: string // the item.id from output_item.added
         encryptedContent?: string | null
-        summaryParts: Record<number, "active" | "can-conclude" | "concluded">
+        summaryParts: number[]
       }
     > = {}
 
@@ -964,14 +960,10 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                   },
                 })
               } else if (isResponseOutputItemAddedReasoningChunk(value)) {
-                if (activeReasoning[value.output_index]) {
-                  currentReasoningOutputIndex = value.output_index
-                  return
-                }
                 activeReasoning[value.output_index] = {
                   canonicalId: value.item.id,
                   encryptedContent: value.item.encrypted_content,
-                  summaryParts: { 0: "active" },
+                  summaryParts: [0],
                 }
                 currentReasoningOutputIndex = value.output_index
 
@@ -1125,14 +1117,13 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
               } else if (isResponseOutputItemDoneReasoningChunk(value)) {
                 const activeReasoningPart = activeReasoning[value.output_index]
                 if (activeReasoningPart) {
-                  for (const [summaryIndex, status] of Object.entries(activeReasoningPart.summaryParts)) {
-                    if (status === "concluded") continue
+                  for (const summaryIndex of activeReasoningPart.summaryParts) {
                     controller.enqueue({
                       type: "reasoning-end",
                       id: `${activeReasoningPart.canonicalId}:${summaryIndex}`,
                       providerMetadata: {
                         copilot: {
-                          itemId: value.item.id,
+                          itemId: activeReasoningPart.canonicalId,
                           reasoningEncryptedContent: value.item.encrypted_content ?? null,
                         },
                       },
@@ -1237,19 +1228,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                 currentReasoningOutputIndex !== null ? activeReasoning[currentReasoningOutputIndex] : null
 
               // the first reasoning start is pushed in isResponseOutputItemAddedReasoningChunk.
-              if (activeItem && value.summary_index > 0 && activeItem.summaryParts[value.summary_index] === undefined) {
-                for (const [summaryIndex, status] of Object.entries(activeItem.summaryParts)) {
-                  if (status !== "can-conclude") continue
-                  controller.enqueue({
-                    type: "reasoning-end",
-                    id: `${activeItem.canonicalId}:${summaryIndex}`,
-                    providerMetadata: {
-                      copilot: { itemId: activeItem.canonicalId },
-                    },
-                  })
-                  activeItem.summaryParts[Number(summaryIndex)] = "concluded"
-                }
-                activeItem.summaryParts[value.summary_index] = "active"
+              if (activeItem && value.summary_index > 0) {
+                activeItem.summaryParts.push(value.summary_index)
 
                 controller.enqueue({
                   type: "reasoning-start",
@@ -1262,22 +1242,6 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                   },
                 })
               }
-            } else if (isResponseReasoningSummaryPartDoneChunk(value)) {
-              const activeItem =
-                currentReasoningOutputIndex !== null ? activeReasoning[currentReasoningOutputIndex] : null
-              if (!activeItem || activeItem.summaryParts[value.summary_index] !== "active") return
-              if (body.store === false) {
-                activeItem.summaryParts[value.summary_index] = "can-conclude"
-                return
-              }
-              controller.enqueue({
-                type: "reasoning-end",
-                id: `${activeItem.canonicalId}:${value.summary_index}`,
-                providerMetadata: {
-                  copilot: { itemId: activeItem.canonicalId },
-                },
-              })
-              activeItem.summaryParts[value.summary_index] = "concluded"
             } else if (isResponseReasoningSummaryTextDeltaChunk(value)) {
               const activeItem =
                 currentReasoningOutputIndex !== null ? activeReasoning[currentReasoningOutputIndex] : null
@@ -1340,16 +1304,6 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
               controller.enqueue({ type: "text-end", id: currentTextId })
               currentTextId = null
             }
-            for (const activeItem of Object.values(activeReasoning)) {
-              for (const [summaryIndex, status] of Object.entries(activeItem.summaryParts)) {
-                if (status === "concluded") continue
-                controller.enqueue({
-                  type: "reasoning-end",
-                  id: `${activeItem.canonicalId}:${summaryIndex}`,
-                  providerMetadata: { copilot: { itemId: activeItem.canonicalId } },
-                })
-              }
-            }
 
             const providerMetadata: SharedV3ProviderMetadata = {
               copilot: {
@@ -1598,12 +1552,6 @@ const responseReasoningSummaryTextDeltaSchema = z.object({
   delta: z.string(),
 })
 
-const responseReasoningSummaryPartDoneSchema = z.object({
-  type: z.literal("response.reasoning_summary_part.done"),
-  item_id: z.string(),
-  summary_index: z.number(),
-})
-
 const openaiResponsesChunkSchema = z.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
@@ -1616,7 +1564,6 @@ const openaiResponsesChunkSchema = z.union([
   responseCodeInterpreterCallCodeDoneSchema,
   responseAnnotationAddedSchema,
   responseReasoningSummaryPartAddedSchema,
-  responseReasoningSummaryPartDoneSchema,
   responseReasoningSummaryTextDeltaSchema,
   errorChunkSchema,
   z.object({ type: z.string() }).loose(), // fallback for unknown chunks
@@ -1705,12 +1652,6 @@ function isResponseReasoningSummaryPartAddedChunk(
   return chunk.type === "response.reasoning_summary_part.added"
 }
 
-function isResponseReasoningSummaryPartDoneChunk(
-  chunk: z.infer<typeof openaiResponsesChunkSchema>,
-): chunk is z.infer<typeof responseReasoningSummaryPartDoneSchema> {
-  return chunk.type === "response.reasoning_summary_part.done"
-}
-
 function isResponseReasoningSummaryTextDeltaChunk(
   chunk: z.infer<typeof openaiResponsesChunkSchema>,
 ): chunk is z.infer<typeof responseReasoningSummaryTextDeltaSchema> {

packages/core/src/integration.ts

@@ -24,7 +24,6 @@ import { Bus } from "./bus"
 import { IntegrationConnection } from "./integration/connection"
 import { AppProcess } from "@opencode-ai/util/process"
 import { ChildProcess } from "effect/unstable/process"
-import { Form } from "./form"
 
 export const ID = Integration.ID
 export type ID = Integration.ID
@@ -35,6 +34,18 @@ export type MethodID = Integration.MethodID
 export const AttemptID = Integration.AttemptID
 export type AttemptID = typeof AttemptID.Type
 
+export const When = Integration.When
+export type When = Integration.When
+
+export const TextPrompt = Integration.TextPrompt
+export type TextPrompt = Integration.TextPrompt
+
+export const SelectPrompt = Integration.SelectPrompt
+export type SelectPrompt = Integration.SelectPrompt
+
+export const Prompt = Integration.Prompt
+export type Prompt = Integration.Prompt
+
 export const OAuthMethod = Integration.OAuthMethod
 export type OAuthMethod = Integration.OAuthMethod
 
@@ -53,6 +64,9 @@ export type Method = Integration.Method
 export const Info = Integration.Info
 export type Info = Integration.Info
 
+export const Inputs = Integration.Inputs
+export type Inputs = Integration.Inputs
+
 export type OAuthAuthorization = {
   readonly url: string
   readonly instructions: string
@@ -71,7 +85,7 @@ export type OAuthAuthorization = {
 export interface OAuthImplementation {
   readonly integrationID: ID
   readonly method: OAuthMethod
-  readonly authorize: (answer: Form.Answer) => Effect.Effect<OAuthAuthorization, unknown, Scope.Scope>
+  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
 }
@@ -161,8 +175,6 @@ export interface Interface extends State.Transformable<Draft> {
       readonly integrationID: ID
       /** Secret entered by the user. */
       readonly key: string
-      /** Values collected from the method's form fields. */
-      readonly answer?: Form.Answer
       /** User-facing label for the stored credential. */
       readonly label?: string
     }) => Effect.Effect<void, AuthorizationError>
@@ -179,7 +191,7 @@ export interface Interface extends State.Transformable<Draft> {
     readonly connect: (input: {
       readonly integrationID: ID
       readonly methodID: MethodID
-      readonly answer?: Form.Answer
+      readonly inputs: Inputs
       readonly label?: string
     }) => Effect.Effect<Attempt, AuthorizationError>
     /** Returns the current state of an OAuth attempt. */
@@ -344,7 +356,7 @@ const layer = Layer.effect(
       return [...credentials, ...env]
     }
 
-    const project = (entry: Entry, connections: IntegrationConnection.Info[]): Info =>
+    const project = (entry: Entry, connections: IntegrationConnection.Info[]) =>
       Info.make({
         id: entry.ref.id,
         name: entry.ref.name,
@@ -535,20 +547,15 @@ const layer = Layer.effect(
     const connectOAuth = Effect.fn("Integration.oauth.connect")(function* (input: {
       readonly integrationID: ID
       readonly methodID: MethodID
-      readonly answer?: Form.Answer
+      readonly inputs: Inputs
       readonly label?: string
     }) {
       const method = state.get().integrations.get(input.integrationID)?.implementations.get(input.methodID)
       if (!method) {
         return yield* Effect.die(new Error(`OAuth method not found: ${input.integrationID}/${input.methodID}`))
       }
-      const answer = input.answer ?? {}
-      if (method.method.form) {
-        const invalid = Form.validateFields(method.method.form) ?? Form.validateAnswer(method.method.form, answer)
-        if (invalid) return yield* new AuthorizationError({ cause: new Error(invalid) })
-      }
       const attemptScope = yield* Scope.fork(scope)
-      const authorization = yield* authorize(method.authorize(answer)).pipe(
+      const authorization = yield* authorize(method.authorize(input.inputs)).pipe(
         Scope.provide(attemptScope),
         Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(attemptScope, exit) : Effect.void)),
       )
@@ -692,24 +699,12 @@ const layer = Layer.effect(
           const method = state
             .get()
             .integrations.get(input.integrationID)
-            ?.methods.find((method) => method.type === "key")
+            ?.methods.some((method) => method.type === "key")
           if (!method) return yield* Effect.die(new Error(`Key method not found: ${input.integrationID}`))
-          const answer = input.answer ?? {}
-          if (method.type === "key" && method.form) {
-            const invalid = Form.validateFields(method.form) ?? Form.validateAnswer(method.form, answer)
-            if (invalid) return yield* new AuthorizationError({ cause: new Error(invalid) })
-          }
-          if (method.type === "key" && !method.form && Object.keys(answer).length > 0) {
-            return yield* new AuthorizationError({ cause: new Error("Key method does not accept a form answer") })
-          }
           yield* credentials.create({
             integrationID: input.integrationID,
             label: input.label,
-            value: Credential.Key.make({
-              type: "key",
-              key: input.key,
-              ...(Object.keys(answer).length > 0 ? { configuration: answer } : {}),
-            }),
+            value: Credential.Key.make({ type: "key", key: input.key }),
           })
           yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: input.integrationID })
           yield* bus.publish(Integration.Event.Updated, {})

packages/core/src/model-resolver.ts

@@ -149,7 +149,6 @@ export const fromCatalogModel = (
   })
   const packageName = Provider.packageName(resolved.package)
   const key = apiKey(resolved, credential)
-  const configuration = credential?.type === "key" ? credential.configuration : undefined
 
   if (Provider.isAISDK(resolved.package) && packageName === "@ai-sdk/openai") {
     return Effect.succeed(
@@ -176,7 +175,7 @@ export const fromCatalogModel = (
         .model({ id: resolved.modelID ?? resolved.id, compatibility: resolved.compatibility }),
     )
   }
-  const configured = { ...resolved.settings, ...credential?.metadata, ...configuration }
+  const configured = { ...resolved.settings, ...credential?.metadata }
   const mapping = Provider.isAISDK(resolved.package)
     ? AISDKNative.map({
         packageName,
@@ -191,7 +190,6 @@ export const fromCatalogModel = (
       draft.settings = Provider.mergeOverlay(draft.settings, {
         ...nativeCredentialSettings(resolved.package ?? "", credential),
         ...credential?.metadata,
-        ...configuration,
       })
     })
     return dependencies.loadAISDK(runtime).pipe(Effect.mapError(() => unsupported(resolved)))

packages/core/src/plugin/host.ts

@@ -190,7 +190,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
           integration.connection.key({
             integrationID: Integration.ID.make(input.integrationID),
             key: input.key,
-            answer: input.answer,
             label: input.label,
           }),
       },
@@ -200,7 +199,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
             integration.oauth.connect({
               integrationID: Integration.ID.make(input.integrationID),
               methodID: Integration.MethodID.make(input.methodID),
-              answer: input.answer,
+              inputs: input.inputs,
               label: input.label,
             }),
           ),
@@ -261,7 +260,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
             update: (id, update) => draft.update(Integration.ID.make(id), update),
             remove: (id) => draft.remove(Integration.ID.make(id)),
             method: {
-              list: (id) => draft.method.list(Integration.ID.make(id)),
+              list: (id) => mutable(draft.method.list(Integration.ID.make(id))),
               update: (input) => draft.method.update(methodImplementation(input)),
               remove: (id, method) =>
                 draft.method.remove(Integration.ID.make(id), Schema.decodeUnknownSync(Integration.Method)(method)),
@@ -364,8 +363,8 @@ function methodImplementation(input: IntegrationMethodRegistration): Integration
     return {
       integrationID: Integration.ID.make(input.integrationID),
       method: { ...input.method, id: Integration.MethodID.make(input.method.id) },
-      authorize: (answer) =>
-        input.authorize(answer).pipe(
+      authorize: (inputs) =>
+        input.authorize(inputs).pipe(
           Effect.map((authorization) => {
             if (authorization.mode === "auto") {
               return {
@@ -386,18 +385,18 @@ function methodImplementation(input: IntegrationMethodRegistration): Integration
   if (input.method.type === "env") {
     return {
       integrationID: Integration.ID.make(input.integrationID),
-      method: input.method,
+      method: { type: "env", names: input.method.names },
     }
   }
   if (input.method.type === "command") {
     return {
       integrationID: Integration.ID.make(input.integrationID),
-      method: { ...input.method, id: Integration.MethodID.make(input.method.id) },
+      method: Schema.decodeUnknownSync(Integration.CommandMethod)(input.method),
     }
   }
   return {
     integrationID: Integration.ID.make(input.integrationID),
-    method: input.method,
+    method: { type: "key", label: input.method.label },
   }
 }
 

packages/core/src/plugin/promise.ts

@@ -11,7 +11,6 @@ import { Provider } from "@opencode-ai/schema/provider"
 import { AbsolutePath } from "@opencode-ai/schema/schema"
 import { Session } from "@opencode-ai/schema/session"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { Skill } from "@opencode-ai/schema/skill"
 import { Workspace } from "@opencode-ai/schema/workspace"
 import { WebSearch } from "@opencode-ai/schema/websearch"
 import { DateTime, Effect, Scope, Stream } from "effect"
@@ -180,8 +179,8 @@ export function fromPromise(plugin: Plugin) {
                         const refresh = input.refresh
                         draft.method.update({
                           ...input,
-                          authorize: (answer) =>
-                            Effect.promise(() => input.authorize(answer)).pipe(
+                          authorize: (inputs) =>
+                            Effect.promise(() => input.authorize(inputs)).pipe(
                               Effect.map((authorization) =>
                                 authorization.mode === "auto"
                                   ? {
@@ -297,7 +296,6 @@ export function fromPromise(plugin: Plugin) {
                   ...input,
                   sessionID: Session.ID.make(input.sessionID),
                   id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
-                  skills: input.skills?.map((skill) => ({ ...skill, id: Skill.ID.make(skill.id) })),
                   delivery: input.delivery ?? undefined,
                   resume: input.resume ?? undefined,
                 }),
@@ -312,7 +310,6 @@ export function fromPromise(plugin: Plugin) {
                   id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
                   agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
                   model: input.model == null ? undefined : model(input.model),
-                  skills: input.skills?.map((skill) => ({ ...skill, id: Skill.ID.make(skill.id) })),
                   arguments: input.arguments ?? undefined,
                   delivery: input.delivery ?? undefined,
                   resume: input.resume ?? undefined,
@@ -362,17 +359,11 @@ type Wire<Value> = unknown extends Value
     ? Value
     : Value extends DateTime.DateTime
       ? number
-      : Value extends readonly [infer Head, ...infer Tail]
-        ? [Wire<Head>, ...WireTuple<Tail>]
-        : Value extends ReadonlyArray<infer Item>
-          ? Array<Wire<Item>>
-          : Value extends object
-            ? { -readonly [Key in keyof Value]: Wire<Value[Key]> }
-            : Value
-
-type WireTuple<Value extends ReadonlyArray<unknown>> = {
-  -readonly [Key in keyof Value]: Wire<Value[Key]>
-}
+      : Value extends ReadonlyArray<infer Item>
+        ? Array<Wire<Item>>
+        : Value extends object
+          ? { -readonly [Key in keyof Value]: Wire<Value[Key]> }
+          : Value
 
 function wire<Value>(value: Value): Wire<Value>
 function wire(value: unknown): unknown {

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

@@ -1,9 +1,6 @@
 import { Effect } from "effect"
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Form } from "@opencode-ai/schema/form"
 import { Provider } from "../../provider"
-import { iife } from "../../util/iife"
-import { configuredSettings } from "./configured"
 
 function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
   if (useChat && sdk.chat) return sdk.chat(modelID)
@@ -16,29 +13,6 @@ function selectLanguage(sdk: any, modelID: string, useChat: boolean) {
 export const AzurePlugin = define({
   id: "opencode.provider.azure",
   effect: Effect.fn(function* (ctx) {
-    const configured = yield* configuredSettings(Provider.ID.azure)
-    const form = iife(() => {
-      if (resolveResourceName(configured) || typeof configured?.baseURL === "string") return
-      return Form.Fields.make([
-        {
-          type: "string",
-          key: "resourceName",
-          title: "Enter Azure Resource Name",
-          placeholder: "e.g. my-models",
-          required: true,
-        },
-      ])
-    })
-    yield* ctx.integration.transform((draft) => {
-      draft.method.update({
-        integrationID: Provider.ID.azure,
-        method: {
-          type: "key",
-          label: "API key",
-          form,
-        },
-      })
-    })
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
         if (item.provider.id !== Provider.ID.azure && Provider.packageName(item.provider.package) !== "@ai-sdk/azure")

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

@@ -2,53 +2,10 @@ import os from "os"
 import { App } from "../../app"
 import { Effect, Option, Schema } from "effect"
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Form } from "@opencode-ai/schema/form"
-import { Provider } from "../../provider"
-import { iife } from "../../util/iife"
-import { configuredSettings } from "./configured"
-
-const providerID = Provider.ID.make("cloudflare-ai-gateway")
 
 export const CloudflareAIGatewayPlugin = define({
   id: "opencode.provider.cloudflare-ai-gateway",
   effect: Effect.fn(function* (ctx) {
-    const configured = yield* configuredSettings(providerID)
-    const form = iife(() => {
-      if (typeof configured?.baseURL === "string") return
-      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID || stringOption(configured ?? {}, "accountId")
-      const gatewayId =
-        process.env.CLOUDFLARE_GATEWAY_ID ||
-        stringOption(configured ?? {}, "gatewayId") ||
-        stringOption(configured ?? {}, "gateway")
-      if (accountId && gatewayId) return
-      const accountIdForm = Form.StringField.make({
-        type: "string",
-        key: "accountId",
-        title: "Enter your Cloudflare Account ID",
-        placeholder: "e.g. 1234567890abcdef1234567890abcdef",
-        required: true,
-      })
-      const gatewayIdForm = Form.StringField.make({
-        type: "string",
-        key: "gatewayId",
-        title: "Enter your Cloudflare AI Gateway ID",
-        placeholder: "e.g. my-gateway",
-        required: true,
-      })
-      if (accountId) return Form.Fields.make([gatewayIdForm])
-      if (gatewayId) return Form.Fields.make([accountIdForm])
-      return Form.Fields.make([accountIdForm, gatewayIdForm])
-    })
-    yield* ctx.integration.transform((draft) => {
-      draft.method.update({
-        integrationID: providerID,
-        method: {
-          type: "key",
-          label: "Gateway API token",
-          form,
-        },
-      })
-    })
     yield* ctx.aisdk.hook(
       "sdk",
       Effect.fn(function* (evt) {
@@ -89,7 +46,7 @@ const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
 
 function gatewayConfig(options: Record<string, unknown>): GatewayConfig | undefined {
   const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId")
-  // Credential projection copies key metadata into options. The form stores the
+  // Credential projection copies key metadata into options. The prompt stores the
   // gateway as gatewayId, while older config examples may use gateway.
   const gatewayId =
     process.env.CLOUDFLARE_GATEWAY_ID ?? stringOption(options, "gatewayId") ?? stringOption(options, "gateway")

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

@@ -2,39 +2,13 @@ import os from "os"
 import { App } from "../../app"
 import { Effect } from "effect"
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Form } from "@opencode-ai/schema/form"
 import { Provider } from "../../provider"
-import { iife } from "../../util/iife"
-import { configuredSettings } from "./configured"
 
 const providerID = Provider.ID.make("cloudflare-workers-ai")
 
 export const CloudflareWorkersAIPlugin = define({
   id: "opencode.provider.cloudflare-workers-ai",
   effect: Effect.fn(function* (ctx) {
-    const configured = yield* configuredSettings(providerID)
-    const form = iife(() => {
-      if (typeof configured?.baseURL === "string" || resolveAccountId(configured ?? {})) return
-      return Form.Fields.make([
-        {
-          type: "string",
-          key: "accountId",
-          title: "Enter your Cloudflare Account ID",
-          placeholder: "e.g. 1234567890abcdef1234567890abcdef",
-          required: true,
-        },
-      ])
-    })
-    yield* ctx.integration.transform((draft) => {
-      draft.method.update({
-        integrationID: providerID,
-        method: {
-          type: "key",
-          label: "API key",
-          form,
-        },
-      })
-    })
     yield* ctx.catalog.transform((evt) => {
       const item = evt.provider.get(providerID)
       if (!item) return

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

@@ -1,15 +0,0 @@
-import { Effect, Option } from "effect"
-import type { Document } from "@opencode-ai/schema/config"
-import { Catalog } from "../../catalog"
-import { Config } from "../../config"
-import { Provider } from "../../provider"
-
-export const configuredSettings = Effect.fn("ProviderPlugin.configuredSettings")(function* (id: Provider.ID) {
-  const catalog = yield* Catalog.Service
-  const current = (yield* catalog.provider.get(id))?.settings
-  const service = yield* Effect.serviceOption(Config.Service)
-  const entries = Option.isSome(service) ? yield* service.value.entries() : []
-  return entries
-    .filter((entry): entry is Document => entry.type === "document")
-    .reduce((settings, entry) => Provider.mergeOverlay(settings, entry.info.providers?.[id]?.settings), current)
-})

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

@@ -1,4 +1,5 @@
 import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/effect/integration"
+import { shouldUseResponsesApi } from "@opencode-ai/ai/providers/github-copilot"
 import { Effect, Option, Schema, Semaphore, Stream } from "effect"
 import { Catalog } from "../../catalog"
 import { Credential } from "../../credential"
@@ -46,33 +47,30 @@ const oauth = (app: App.Info) =>
       id: methodID,
       type: "oauth",
       label: "Login with GitHub Copilot",
-      form: [
+      prompts: [
         {
-          type: "string",
+          type: "select",
           key: "deploymentType",
-          title: "Select GitHub deployment type",
-          required: true,
+          message: "Select GitHub deployment type",
           options: [
-            { label: "GitHub.com", value: "github.com", description: "Public" },
-            { label: "GitHub Enterprise", value: "enterprise", description: "Data residency or self-hosted" },
+            { label: "GitHub.com", value: "github.com", hint: "Public" },
+            { label: "GitHub Enterprise", value: "enterprise", hint: "Data residency or self-hosted" },
           ],
         },
         {
-          type: "string",
+          type: "text",
           key: "enterpriseUrl",
-          title: "Enter your GitHub Enterprise URL or domain",
+          message: "Enter your GitHub Enterprise URL or domain",
           placeholder: "company.ghe.com or https://company.ghe.com",
-          required: true,
-          when: [{ key: "deploymentType", op: "eq", value: "enterprise" }],
+          when: { key: "deploymentType", op: "eq", value: "enterprise" },
         },
       ],
     },
-    authorize: (answer) =>
+    authorize: (inputs) =>
       Effect.gen(function* () {
-        const enterprise = answer.deploymentType === "enterprise"
-        const enterpriseUrl = typeof answer.enterpriseUrl === "string" ? answer.enterpriseUrl : undefined
-        if (enterprise && !enterpriseUrl) return yield* Effect.fail(new Error("Enterprise URL is required"))
-        const domain = enterprise ? normalizeDomain(enterpriseUrl ?? "") : "github.com"
+        const enterprise = inputs.deploymentType === "enterprise"
+        if (enterprise && !inputs.enterpriseUrl) return yield* Effect.fail(new Error("Enterprise URL is required"))
+        const domain = enterprise ? normalizeDomain(inputs.enterpriseUrl ?? "") : "github.com"
         const urls = oauthURLs(domain)
         const device = yield* request(urls.device, {
           method: "POST",
@@ -190,7 +188,6 @@ export const GithubCopilotPlugin = define({
     })
 
     yield* ctx.integration.transform((draft) => {
-      draft.method.remove("github-copilot", { type: "key" })
       draft.method.update(oauth(ctx.app))
     })
     yield* ctx.catalog.transform((evt) => {
@@ -229,26 +226,26 @@ export const GithubCopilotPlugin = define({
       "sdk",
       Effect.fn(function* (evt) {
         if (evt.model.providerID !== Provider.ID.githubCopilot) return
-        if (evt.package !== "@ai-sdk/github-copilot") return
+        if (evt.package !== "@ai-sdk/github-copilot" && evt.package !== "@ai-sdk/anthropic") return
         evt.options.fetch = copilotFetch(
           typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined,
           evt.options.fetch,
+          evt.package === "@ai-sdk/anthropic",
           ctx.app,
         )
+        if (evt.package === "@ai-sdk/anthropic") {
+          evt.options.headers = {
+            ...evt.options.headers,
+            "anthropic-beta": "interleaved-thinking-2025-05-14",
+          }
+          const mod = yield* Effect.promise(() => import("@ai-sdk/anthropic"))
+          evt.sdk = mod.createAnthropic(evt.options)
+          return
+        }
         const mod = yield* Effect.promise(() => import("../../github-copilot/copilot-provider"))
         evt.sdk = mod.createOpenaiCompatible(evt.options)
       }),
     )
-    yield* ctx.session.hook("http.request", (evt) =>
-      Effect.gen(function* () {
-        if (evt.model.providerID !== Provider.ID.githubCopilot) return
-        const token = evt.request.headers.get("x-api-key")
-        if (!token) return
-        const text = yield* Effect.promise(() => evt.request.clone().text())
-        const body = Option.getOrUndefined(decodeBody(text))
-        applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true)
-      }),
-    )
     yield* ctx.aisdk.hook(
       "language",
       Effect.fn(function* (evt) {
@@ -266,9 +263,7 @@ export const GithubCopilotPlugin = define({
           return
         }
         const id = evt.model.modelID ?? evt.model.id
-        const match = /^gpt-(\d+)/.exec(id)
-        evt.language =
-          match && Number(match[1]) >= 5 && !id.startsWith("gpt-5-mini") ? evt.sdk.responses(id) : evt.sdk.chat(id)
+        evt.language = shouldUseResponsesApi(id) ? evt.sdk.responses(id) : evt.sdk.chat(id)
       }),
     )
   }),
@@ -317,39 +312,34 @@ function request(url: string, init: RequestInit) {
 
 type Fetch = (input: Parameters<typeof fetch>[0], init?: RequestInit) => Promise<Response>
 
-export function copilotFetch(token: string | undefined, upstream: Fetch | undefined, app: App.Info): Fetch {
+export function copilotFetch(
+  token: string | undefined,
+  upstream: Fetch | undefined,
+  anthropic: boolean,
+  app: App.Info,
+): Fetch {
   const send = upstream ?? fetch
   return async (input, init) => {
     const requestHeaders = new Headers(init?.headers)
+    if (token) {
+      requestHeaders.delete("authorization")
+      requestHeaders.delete("x-api-key")
+      requestHeaders.set("Authorization", `Bearer ${token}`)
+    }
+    requestHeaders.set("User-Agent", App.useragent(app))
+    requestHeaders.set("Openai-Intent", "conversation-edits")
+    requestHeaders.set("X-GitHub-Api-Version", apiVersion)
+    if (anthropic) requestHeaders.set("anthropic-beta", "interleaved-thinking-2025-05-14")
+
     const url = input instanceof URL ? input.href : typeof input === "string" ? input : input.url
     const body = typeof init?.body === "string" ? Option.getOrUndefined(decodeBody(init.body)) : undefined
-    applyHeaders(requestHeaders, token, app, requestMetadata(url, body), false)
+    const metadata = requestMetadata(url, body)
+    requestHeaders.set("x-initiator", metadata.agent ? "agent" : "user")
+    if (metadata.vision) requestHeaders.set("Copilot-Vision-Request", "true")
     return send(input, { ...init, headers: requestHeaders })
   }
 }
 
-function applyHeaders(
-  headers: Headers,
-  token: string | undefined,
-  app: App.Info,
-  metadata: RequestMetadata,
-  anthropic: boolean,
-) {
-  if (token) {
-    headers.delete("authorization")
-    headers.delete("x-api-key")
-    headers.set("Authorization", `Bearer ${token}`)
-  }
-  headers.set("User-Agent", App.useragent(app))
-  headers.set("Openai-Intent", "conversation-edits")
-  headers.set("X-GitHub-Api-Version", apiVersion)
-  headers.set("x-initiator", metadata.agent ? "agent" : "user")
-  if (metadata.vision) headers.set("Copilot-Vision-Request", "true")
-  if (anthropic) headers.set("anthropic-beta", "interleaved-thinking-2025-05-14")
-}
-
-type RequestMetadata = ReturnType<typeof requestMetadata>
-
 function requestMetadata(url: string, body: unknown) {
   if (!record(body)) return { agent: false, vision: false }
   if (Array.isArray(body.input)) {

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

@@ -43,9 +43,9 @@ function oauth(http: HttpClient.HttpClient) {
       type: "oauth",
       label: "OpenCode Console account",
     },
-    authorize: (answer) =>
+    authorize: (inputs) =>
       Effect.gen(function* () {
-        const server = yield* normalizeServer(answer.server ?? defaultServer)
+        const server = yield* normalizeServer(inputs.server ?? defaultServer)
         const device = yield* post(http, `${server}/auth/device/code`, { client_id: clientID }, Device)
         const verification = URL.canParse(device.verification_uri_complete)
           ? new URL(device.verification_uri_complete)
@@ -226,10 +226,9 @@ function withoutCredentials(body: Readonly<Record<string, unknown>> | undefined)
   return Object.fromEntries(Object.entries(body ?? {}).filter(([key]) => key !== "apiKey" && key !== "headers"))
 }
 
-function normalizeServer(input: unknown) {
+function normalizeServer(input: string) {
   return Effect.try({
     try: () => {
-      if (typeof input !== "string") throw new Error("expected string")
       const url = new URL(input)
       if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("expected HTTP(S)")
       return `${url.origin}${url.pathname.replace(/\/+$/, "")}`

packages/core/src/plugin/supervisor.ts

@@ -233,7 +233,7 @@ const layer = Layer.effect(
     const bus = yield* Bus.Service
     const watcher = yield* Watcher.Service
     const fs = yield* FSUtil.Service
-    const ready = { current: yield* Deferred.make<void>() }
+    const ready = yield* Deferred.make<void>()
     let observed = 0
 
     // Configured local plugin files can live outside config roots, where the
@@ -291,13 +291,7 @@ const layer = Layer.effect(
       bus.subscribe([Event.Updated, SdkPlugins.Updated]),
     ).pipe(
       // Make accepted work visible to flush before coalescing the burst.
-      Stream.mapEffect(() =>
-        Effect.gen(function* () {
-          observed++
-          if (yield* Deferred.isDone(ready.current)) ready.current = yield* Deferred.make<void>()
-          return observed
-        }),
-      ),
+      Stream.mapEffect(() => Effect.sync(() => ++observed)),
     )
     yield* Stream.concat(Stream.succeed(0), updates).pipe(
       // Keep observing updates while activation runs, retaining only the latest generation request.
@@ -306,12 +300,12 @@ const layer = Layer.effect(
       Stream.runForEach((target) =>
         Effect.gen(function* () {
           yield* activate()
-          if (observed === target) yield* Deferred.succeed(ready.current, undefined)
+          if (observed === target) yield* Deferred.succeed(ready, undefined)
         }).pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause }))),
       ),
       Effect.forkScoped({ startImmediately: true }),
     )
-    return Service.of({ flush: Effect.suspend(() => Deferred.await(ready.current)) })
+    return Service.of({ flush: Deferred.await(ready) })
   }),
 )
 

packages/core/src/session.ts

@@ -218,11 +218,10 @@ export interface Interface {
     text: string
     files?: PromptInput.Prompt["files"]
     agents?: PromptInput.Prompt["agents"]
-    skills?: PromptInput.Prompt["skills"]
     metadata?: Record<string, unknown>
     delivery?: SessionPending.Delivery
     resume?: boolean
-  }) => Effect.Effect<SessionPending.User, NotFoundError | PromptConflictError | AttachmentError | SkillNotFoundError>
+  }) => Effect.Effect<SessionPending.User, NotFoundError | PromptConflictError | AttachmentError>
   /** Generates text from current Session context without admitting input or mutating history. */
   readonly generate: (input: {
     sessionID: SessionSchema.ID
@@ -237,17 +236,11 @@ export interface Interface {
     model?: Model.Ref
     files?: PromptInput.Prompt["files"]
     agents?: PromptInput.Prompt["agents"]
-    skills?: PromptInput.Prompt["skills"]
     delivery?: SessionPending.Delivery
     resume?: boolean
   }) => Effect.Effect<
     SessionPending.User,
-    | NotFoundError
-    | PromptConflictError
-    | AttachmentError
-    | SkillNotFoundError
-    | Command.NotFoundError
-    | Command.EvaluationError
+    NotFoundError | PromptConflictError | AttachmentError | Command.NotFoundError | Command.EvaluationError
   >
   readonly shell: (input: {
     id?: Event.ID
@@ -572,11 +565,9 @@ const layer = Layer.effect(
             // Resolved lazily so prompt admission only boots location services when an
             // image attachment actually needs the resizer.
             const image = Image.Service.pipe(Effect.provide(locations.get(session.location)))
-            const skills = Skill.Service.pipe(Effect.provide(locations.get(session.location)))
             const prompt = yield* resolvePrompt(
-              { text: input.text, files: input.files, agents: input.agents, skills: input.skills },
+              { text: input.text, files: input.files, agents: input.agents },
               image,
-              skills,
             ).pipe(Effect.provideService(FSUtil.Service, fs))
             const messageID = input.id ?? SessionMessage.ID.create()
             const admittedInput = SessionPending.Message.make({
@@ -642,7 +633,6 @@ const layer = Layer.effect(
           text: evaluated.text,
           files: input.files,
           agents: input.agents,
-          skills: input.skills,
           delivery: input.delivery,
           resume: input.resume,
         })
@@ -655,7 +645,9 @@ const layer = Layer.effect(
             yield* execution.awaitIdle(input.sessionID)
             const started = yield* Effect.gen(function* () {
               const shell = yield* Shell.Service
-              return yield* shell.create({ command: input.command, cwd: session.location.directory, timeout: 0 })
+              return yield* shell
+                .create({ command: input.command, cwd: session.location.directory, timeout: 0 })
+                .pipe(Effect.orDie)
             }).pipe(Effect.provide(locations.get(session.location)))
             yield* bus.publish(
               SessionEvent.Shell.Started,
@@ -905,28 +897,12 @@ function synthesizeTerminalShellInfo(started: ShellSchema.Info): ShellSchema.Inf
 const resolvePrompt = Effect.fn("Session.resolvePrompt")(function* (
   input: PromptInput.Prompt,
   image: Effect.Effect<Image.Interface>,
-  skills: Effect.Effect<Skill.Interface>,
 ) {
   const fs = yield* FSUtil.Service
   const files = input.files
     ? yield* Effect.forEach(input.files, (file) => materializeAttachment(fs, file, image), { concurrency: 8 })
     : undefined
-  const requested = input.skills
-  const selected = yield* Effect.gen(function* () {
-    if (!requested?.length) return undefined
-    const available = yield* (yield* skills).list()
-    return yield* Effect.forEach(requested, (attachment) => {
-      const skill = available.find((item) => item.id === attachment.id)
-      if (!skill) return Effect.fail(new SkillNotFoundError({ skill: attachment.id }))
-      return Effect.succeed({
-        id: skill.id,
-        name: skill.name,
-        text: Skill.toModelOutput(skill, []),
-        mention: attachment.mention,
-      })
-    })
-  })
-  return Prompt.make({ text: input.text, agents: input.agents, files, skills: selected?.length ? selected : undefined })
+  return Prompt.make({ text: input.text, agents: input.agents, files })
 })
 
 const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024

packages/core/src/session/compaction.ts

@@ -124,8 +124,7 @@ const serialize = (message: SessionMessage.Info) => {
         (file) =>
           `[Attached ${file.mime}: ${file.name ?? (file.source.type === "uri" ? file.source.uri : "inline attachment")}]`,
       ) ?? []
-    const skills = message.skills?.map((skill) => `[Attached skill: ${skill.name}]\n${skill.text}`) ?? []
-    return [`[User]: ${message.text}`, ...skills, ...files].join("\n")
+    return [`[User]: ${message.text}`, ...files].join("\n")
   }
   if (message.type === "assistant") {
     return message.content

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

@@ -4,7 +4,6 @@ import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 
 export interface Adapter {
-  readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined, never, never>
   readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>
   readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
   readonly getAssistant: (
@@ -60,19 +59,15 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.created": () => Effect.void,
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) => {
-        return Effect.gen(function* () {
-          const previous = yield* adapter.getAgent()
-          yield* adapter.appendMessage(
-            SessionMessage.AgentSelected.make({
-              id: SessionMessage.ID.fromEvent(event.id),
-              type: "agent-switched",
-              metadata: event.metadata,
-              agent: event.data.agent,
-              previous,
-              time: { created: event.created },
-            }),
-          )
-        })
+        return adapter.appendMessage(
+          SessionMessage.AgentSelected.make({
+            id: SessionMessage.ID.fromEvent(event.id),
+            type: "agent-switched",
+            metadata: event.metadata,
+            agent: event.data.agent,
+            time: { created: event.created },
+          }),
+        )
       },
       "session.model.selected": (event) => {
         return Effect.gen(function* () {

packages/core/src/session/projector.ts

@@ -6,7 +6,6 @@ import { Database } from "../database/database"
 import { Bus } from "../bus"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Model } from "../model"
-import { Agent } from "../agent"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 import { SessionMessageUpdater } from "./message-updater"
@@ -17,6 +16,7 @@ import { SessionPendingTable, SessionMessageTable, SessionTable } from "./sql"
 import { Slug } from "../util/slug"
 import { Money } from "@opencode-ai/schema/money"
 import type { SessionSchema } from "./schema"
+import { WorkspaceTable } from "../control-plane/workspace.sql"
 
 type DatabaseService = Database.Interface["db"]
 type CurrentDurableEvent = Extract<SessionEvent.Event, { readonly durable: object }>
@@ -231,17 +231,6 @@ function run(db: DatabaseService, event: MessageEvent) {
     }
     const appendMessage = (message: SessionMessage.Info) => insertMessage(db, event, message)
     const adapter: SessionMessageUpdater.Adapter = {
-      getAgent() {
-        return db
-          .select({ agent: SessionTable.agent })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, event.data.sessionID))
-          .get()
-          .pipe(
-            Effect.orDie,
-            Effect.map((row) => (row?.agent ? Agent.ID.make(row.agent) : undefined)),
-          )
-      },
       getModel() {
         return db
           .select({ model: SessionTable.model })
@@ -387,6 +376,13 @@ const layer = Layer.effectDiscard(
           .get()
           .pipe(Effect.orDie)
         if (!stored) return yield* Effect.die(new SessionAlreadyProjected())
+        if (!event.data.location.workspaceID) return
+        yield* db
+          .update(WorkspaceTable)
+          .set({ time_used: Date.now() })
+          .where(eq(WorkspaceTable.id, event.data.location.workspaceID))
+          .run()
+          .pipe(Effect.orDie)
       }),
     )
     yield* bus.project(SessionEvent.Moved, (event) =>
@@ -410,15 +406,12 @@ const layer = Layer.effectDiscard(
       db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie),
     )
     yield* bus.project(SessionEvent.AgentSelected, (event) =>
-      Effect.gen(function* () {
-        yield* run(db, event)
-        yield* db
-          .update(SessionTable)
-          .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
-          .where(eq(SessionTable.id, event.data.sessionID))
-          .run()
-          .pipe(Effect.orDie)
-      }),
+      db
+        .update(SessionTable)
+        .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
+        .where(eq(SessionTable.id, event.data.sessionID))
+        .run()
+        .pipe(Effect.orDie, Effect.andThen(run(db, event))),
     )
     yield* bus.project(SessionEvent.ModelSelected, (event) =>
       Effect.gen(function* () {
@@ -460,7 +453,6 @@ const layer = Layer.effectDiscard(
                 text: input.data.text,
                 files: input.data.files,
                 agents: input.data.agents,
-                skills: input.data.skills,
                 time: { created: event.created },
               }
             : {

packages/core/src/session/runner/to-llm-message.ts

@@ -184,7 +184,6 @@ function toLLMMessage(message: SessionMessage.Info, model: Model.Ref, providerMe
       return []
     case "user":
       const content = [
-        ...(message.skills ?? []).map((skill) => Message.text(skill.text)),
         ...(message.text === "" ? [] : [Message.text(message.text)]),
         ...(message.files ?? []).flatMap(attachmentContent),
       ]

packages/core/src/session/transfer.ts

@@ -2,7 +2,6 @@ export * as SessionTransfer from "./transfer"
 
 import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
 import { Tool } from "@opencode-ai/schema/tool"
-import { Skill } from "@opencode-ai/schema/skill"
 import { eq, isNotNull, isNull, ne, or } from "drizzle-orm"
 import { Context, DateTime, Effect, Layer, Schema } from "effect"
 import path from "path"
@@ -219,14 +218,6 @@ function sanitizeMessage(message: SessionMessage.Info): SessionMessage.Info {
           ? { ...agent.mention, text: redact("agent-mention", String(index), agent.mention.text) }
           : undefined,
       })),
-      skills: message.skills?.map((skill, index) => ({
-        ...skill,
-        name: Skill.Name.make(redact("skill-name", String(index), skill.name)),
-        text: redact("skill", String(index), skill.text),
-        mention: skill.mention
-          ? { ...skill.mention, text: redact("skill-mention", String(index), skill.mention.text) }
-          : undefined,
-      })),
     }
   if (message.type === "synthetic")
     return {

packages/core/src/shell.ts

@@ -5,6 +5,7 @@ import { Context, Deferred, Duration, Effect, Fiber, Layer, Schema, Stream } fro
 import { ChildProcess } from "effect/unstable/process"
 import { produce } from "immer"
 import { Shell } from "@opencode-ai/schema/shell"
+import { AppProcess } from "@opencode-ai/util/process"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Config } from "./config"
 import { Bus } from "./bus"
@@ -50,7 +51,7 @@ export interface Interface {
   readonly create: <E = never, R = never>(
     input: Shell.CreateInput,
     before?: (input: ShellCreateBefore) => Effect.Effect<void, E, R>,
-  ) => Effect.Effect<Shell.Info, E, R>
+  ) => Effect.Effect<Shell.Info, E | AppProcess.AppProcessError, R>
   // Currently running commands only; exited shells are retained for get/output but excluded here.
   readonly list: () => Effect.Effect<Shell.Info[]>
   readonly get: (id: Shell.ID) => Effect.Effect<Shell.Info, NotFoundError>
@@ -213,19 +214,23 @@ export const layer = (options?: ShellSelect.Options) =>
         // Spawn through the Environment and stream combined output to the file. The handle is scope-bound, so
         // the managing fiber keeps its scope open until the command terminates (it awaits `done` at the
         // end). `create` returns once `ready` resolves with the registered session.
-        const ready = Deferred.makeUnsafe<Active>()
+        const ready = Deferred.makeUnsafe<Active, AppProcess.AppProcessError>()
         runFork(
           Effect.scoped(
             Effect.gen(function* () {
-              const handle = yield* environment.spawner.spawn(
-                ChildProcess.make(invocation.shell, args, {
-                  cwd: invocation.cwd,
-                  env: invocation.env,
-                  stdin: "ignore",
-                  detached: process.platform !== "win32",
-                  forceKillAfter: Duration.seconds(3),
-                }),
-              )
+              const handle = yield* environment.spawner
+                .spawn(
+                  ChildProcess.make(invocation.shell, args, {
+                    cwd: invocation.cwd,
+                    env: invocation.env,
+                    stdin: "ignore",
+                    detached: process.platform !== "win32",
+                    forceKillAfter: Duration.seconds(3),
+                  }),
+                )
+                .pipe(
+                  Effect.mapError((cause) => new AppProcess.AppProcessError({ command: invocation.command, cause })),
+                )
               const session: Active = {
                 info: produce(info, (draft) => {
                   draft.pid = handle.pid
@@ -327,7 +332,7 @@ export const layer = (options?: ShellSelect.Options) =>
               // release (kill) the process before its exit is observed.
               yield* Deferred.await(session.done).pipe(Effect.catch(() => Effect.void))
             }),
-          ).pipe(Effect.catch(() => Effect.void)),
+          ).pipe(Effect.catchTag("AppProcessError", (error) => Deferred.fail(ready, error))),
         )
 
         const session = yield* Deferred.await(ready)

packages/core/src/skill.ts

@@ -38,25 +38,6 @@ export { Event } from "@opencode-ai/schema/skill"
 export const available = (skills: ReadonlyArray<Info>, agent: Agent.Info) =>
   skills.filter((skill) => Permission.evaluate("skill", skill.id, agent.permissions).effect !== "deny")
 
-export const toModelOutput = (skill: Info, files: ReadonlyArray<string>) => {
-  const directory = path.dirname(skill.location)
-  return [
-    `<skill_content name="${skill.name}">`,
-    `# Skill: ${skill.name}`,
-    "",
-    skill.content.trim(),
-    "",
-    `Base directory for this skill: ${directory}`,
-    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
-    "Note: file list is sampled.",
-    "",
-    "<skill_files>",
-    ...files.map((file) => `<file>${file}</file>`),
-    "</skill_files>",
-    "</skill_content>",
-  ].join("\n")
-}
-
 const Frontmatter = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
   description: Schema.String.pipe(Schema.optional),

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

@@ -26,7 +26,24 @@ export const description = [
   "The skill ID must match one of the available skills in the instructions.",
 ].join("\n")
 
-export const toModelOutput = Skill.toModelOutput
+export const toModelOutput = (skill: Skill.Info, files: ReadonlyArray<string>) => {
+  const directory = path.dirname(skill.location)
+  return [
+    `<skill_content name="${skill.name}">`,
+    `# Skill: ${skill.name}`,
+    "",
+    skill.content.trim(),
+    "",
+    `Base directory for this skill: ${directory}`,
+    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+    "Note: file list is sampled.",
+    "",
+    "<skill_files>",
+    ...files.map((file) => `<file>${file}</file>`),
+    "</skill_files>",
+    "</skill_content>",
+  ].join("\n")
+}
 
 const unableToLoad = (name: string, error?: unknown) =>
   new ToolFailure({ message: `Unable to load skill ${name}`, error })
@@ -70,7 +87,7 @@ export const Plugin = {
                 return {
                   name: skill.name,
                   directory,
-                  output: Skill.toModelOutput(skill, files),
+                  output: toModelOutput(skill, files),
                 }
               }).pipe(Effect.mapError((error) => unableToLoad(input.id, error)))
             }).pipe(

packages/core/src/workspace.ts

@@ -1,219 +1,6 @@
 export * as Workspace from "./workspace"
 
 import { Workspace } from "@opencode-ai/schema/workspace"
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { eq } from "drizzle-orm"
-import { Clock, Context, Duration, Effect, Exit, Layer, Ref, Schedule, Schema, Scope } from "effect"
-import { systemError } from "effect/PlatformError"
-import { make } from "effect/unstable/process/ChildProcessSpawner"
-import type { Driver as EnvironmentDriver } from "./environment/driver"
-import { Database } from "./database/database"
-import { KeyedMutex } from "./effect/keyed-mutex"
-import { WorkspaceDriver } from "./workspace/driver"
-import { WorkspaceTable } from "./workspace/sql"
 
 export const ID = Workspace.ID
-export type ID = Workspace.ID
-
-export class Info extends Schema.Class<Info>("Workspace.Info")({
-  id: ID,
-  provider: Schema.String,
-  binding: WorkspaceDriver.Binding,
-  createdAt: Schema.Number,
-  lastUsedAt: Schema.Number,
-}) {}
-
-export class NotFound extends Schema.TaggedErrorClass<NotFound>()("Workspace.NotFound", { workspaceID: ID }) {}
-
-export interface Interface {
-  readonly create: (provider: string) => Effect.Effect<Info, WorkspaceDriver.Error | WorkspaceDriver.ProviderNotFound>
-  readonly connect: (
-    workspaceID: ID,
-  ) => Effect.Effect<EnvironmentDriver, NotFound | WorkspaceDriver.Error | WorkspaceDriver.ProviderNotFound>
-  readonly destroy: (
-    workspaceID: ID,
-  ) => Effect.Effect<void, NotFound | WorkspaceDriver.Error | WorkspaceDriver.ProviderNotFound>
-}
-
-export interface Options {
-  readonly idleThreshold?: Duration.Input
-  readonly pollInterval?: Duration.Input
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Workspace") {}
-
-interface Connection {
-  readonly driver: WorkspaceDriver.Interface
-  readonly environment: EnvironmentDriver
-  readonly saveBinding: (binding: WorkspaceDriver.Binding) => Effect.Effect<void>
-  readonly lastActivity: Ref.Ref<number>
-  readonly active: Ref.Ref<number>
-  readonly scope: Scope.Closeable
-}
-
-export const configured = (options: Options = {}) =>
-  makeGlobalNode({
-    service: Service,
-    layer: layer(options),
-    deps: [Database.node, WorkspaceDriver.node],
-  })
-
-const layer = (options: Options) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const db = (yield* Database.Service).db
-      const registry = yield* WorkspaceDriver.RegistryService
-      const lifetime = yield* Scope.Scope
-      const connections = new Map<ID, Connection>()
-      const locks = KeyedMutex.makeUnsafe<ID>()
-      const idleThreshold = Duration.toMillis(options.idleThreshold ?? Duration.minutes(20))
-
-      const load = Effect.fn("Workspace.load")(function* (workspaceID: ID) {
-        const row = yield* db
-          .select()
-          .from(WorkspaceTable)
-          .where(eq(WorkspaceTable.id, workspaceID))
-          .get()
-          .pipe(Effect.orDie)
-        if (!row) return yield* new NotFound({ workspaceID })
-        return row
-      })
-
-      const open = Effect.fn("Workspace.open")(function* (workspaceID: ID) {
-        const existing = connections.get(workspaceID)
-        if (existing) return existing
-
-        const row = yield* load(workspaceID)
-        const driver = yield* registry.get(row.provider)
-        const saveBinding = (value: WorkspaceDriver.Binding) =>
-          db
-            .update(WorkspaceTable)
-            .set({ binding: value })
-            .where(eq(WorkspaceTable.id, workspaceID))
-            .run()
-            .pipe(Effect.orDie)
-        const scope = yield* Scope.fork(lifetime)
-        const environment = yield* driver.connect({ workspaceID, binding: row.binding, saveBinding }).pipe(
-          Effect.provideService(Scope.Scope, scope),
-          Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))),
-        )
-        const now = yield* Clock.currentTimeMillis
-        const connection: Connection = {
-          driver,
-          environment,
-          saveBinding,
-          lastActivity: yield* Ref.make(now),
-          active: yield* Ref.make(0),
-          scope,
-        }
-        connections.set(workspaceID, connection)
-        yield* db
-          .update(WorkspaceTable)
-          .set({ last_used_at: now })
-          .where(eq(WorkspaceTable.id, workspaceID))
-          .run()
-          .pipe(Effect.orDie)
-        return connection
-      })
-
-      yield* Effect.gen(function* () {
-        const now = yield* Clock.currentTimeMillis
-        yield* Effect.forEach(
-          [...connections.entries()],
-          ([workspaceID, expected]) =>
-            locks.withLock(workspaceID)(
-              Effect.gen(function* () {
-                const connection = connections.get(workspaceID)
-                if (connection !== expected || (yield* Ref.get(connection.active)) > 0) return
-                const lastActivity = yield* Ref.get(connection.lastActivity)
-                if (now - lastActivity < idleThreshold) return
-                const row = yield* load(workspaceID)
-                // Deliberate: a racing spawn blocks, then wakes cleanly. Unlocking mid-suspend could reattach a sandbox being terminated.
-                yield* connection.driver.suspendForIdle({
-                  workspaceID,
-                  binding: row.binding,
-                  saveBinding: connection.saveBinding,
-                })
-                yield* db
-                  .update(WorkspaceTable)
-                  .set({ last_used_at: lastActivity })
-                  .where(eq(WorkspaceTable.id, workspaceID))
-                  .run()
-                  .pipe(Effect.orDie)
-                connections.delete(workspaceID)
-                yield* Scope.close(connection.scope, Exit.void)
-              }).pipe(Effect.catchCause((cause) => Effect.logError("workspace idle suspension failed", cause))),
-            ),
-          { concurrency: "unbounded", discard: true },
-        )
-      }).pipe(Effect.repeat(Schedule.spaced(options.pollInterval ?? Duration.minutes(1))), Effect.forkScoped)
-
-      return Service.of({
-        create: Effect.fn("Workspace.create")(function* (provider) {
-          const driver = yield* registry.get(provider)
-          const workspaceID = ID.create()
-          const result = yield* driver.create({ workspaceID })
-          const now = yield* Clock.currentTimeMillis
-          yield* db
-            .insert(WorkspaceTable)
-            .values({ id: workspaceID, provider, binding: result.binding, created_at: now, last_used_at: now })
-            .run()
-            .pipe(Effect.orDie)
-          return new Info({ id: workspaceID, provider, binding: result.binding, createdAt: now, lastUsedAt: now })
-        }),
-        connect: Effect.fn("Workspace.connect")(function* (workspaceID) {
-          const spawner = make((command) =>
-            Effect.acquireRelease(
-              locks.withLock(workspaceID)(
-                Effect.gen(function* () {
-                  const connection = yield* open(workspaceID).pipe(
-                    Effect.mapError((cause) =>
-                      systemError({
-                        _tag: "Unknown",
-                        module: "Workspace",
-                        method: "spawn",
-                        description: `Failed to wake workspace ${workspaceID}`,
-                        cause,
-                      }),
-                    ),
-                  )
-                  yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis)
-                  yield* Ref.update(connection.active, (active) => active + 1)
-                  return connection
-                }),
-              ),
-              (connection) =>
-                locks.withLock(workspaceID)(
-                  Effect.gen(function* () {
-                    yield* Ref.update(connection.active, (active) => active - 1)
-                    yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis)
-                  }),
-                ),
-            ).pipe(Effect.flatMap((connection) => connection.environment.spawner.spawn(command))),
-          )
-          // Overrides are connection-bound; per-spawn routing is required before any driver ships them, so they are deliberately omitted.
-          return { spawner }
-        }),
-        destroy: Effect.fn("Workspace.destroy")(function* (workspaceID) {
-          yield* locks.withLock(workspaceID)(
-            Effect.gen(function* () {
-              const row = yield* load(workspaceID)
-              const connection = connections.get(workspaceID)
-              connections.delete(workspaceID)
-              if (connection) yield* Scope.close(connection.scope, Exit.void)
-              const driver = yield* registry.get(row.provider)
-              yield* driver.destroy({ workspaceID, binding: row.binding })
-              yield* db.delete(WorkspaceTable).where(eq(WorkspaceTable.id, workspaceID)).run().pipe(Effect.orDie)
-            }),
-          )
-        }),
-      })
-    }),
-  )
-
-export const node = configured()
-
-// TODO(workspace-plan): add the boot janitor and ~23h safety snapshot rotation in a later PR.
-// TODO(workspace-plan): make cold wake interruptible with a re-pin loop against janitor races.
-// TODO(workspace-plan): consider RcMap at end-of-series consolidation; idle suspend and destroy need distinct finalizers.
+export type ID = typeof ID.Type

packages/core/src/workspace/driver.ts

@@ -1,70 +0,0 @@
-export * as WorkspaceDriver from "./driver"
-
-import { Workspace } from "@opencode-ai/schema/workspace"
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer, Schema } from "effect"
-import type { Scope } from "effect"
-import type { Driver as EnvironmentDriver } from "../environment/driver"
-
-/**
- * Smallest provider-owned JSON value required to reconnect to the same
- * provider resource. Core stores it opaquely and hands it back; only the
- * owning driver reads inside.
- */
-export const Binding = Schema.Record(Schema.String, Schema.Json)
-export type Binding = typeof Binding.Type
-
-export class Error extends Schema.TaggedErrorClass<Error>()("WorkspaceDriver.Error", {
-  message: Schema.optional(Schema.String),
-  cause: Schema.optional(Schema.Defect()),
-}) {}
-
-export class ProviderNotFound extends Schema.TaggedErrorClass<ProviderNotFound>()("WorkspaceDriver.ProviderNotFound", {
-  provider: Schema.String,
-}) {}
-
-export interface Interface {
-  readonly create: (input: {
-    readonly workspaceID: Workspace.ID
-  }) => Effect.Effect<{ readonly binding: Binding }, Error>
-  readonly connect: (input: {
-    readonly workspaceID: Workspace.ID
-    readonly binding: Binding
-    readonly saveBinding: (binding: Binding) => Effect.Effect<void>
-  }) => Effect.Effect<EnvironmentDriver, Error, Scope.Scope>
-  readonly suspendForIdle: (input: {
-    readonly workspaceID: Workspace.ID
-    readonly binding: Binding
-    readonly saveBinding: (binding: Binding) => Effect.Effect<void>
-  }) => Effect.Effect<void, Error>
-  readonly destroy: (input: {
-    readonly workspaceID: Workspace.ID
-    readonly binding: Binding
-  }) => Effect.Effect<void, Error>
-}
-
-export const make = (driver: Interface) => driver
-
-export interface Registry {
-  readonly get: (provider: string) => Effect.Effect<Interface, ProviderNotFound>
-}
-
-export class RegistryService extends Context.Service<RegistryService, Registry>()(
-  "@opencode/WorkspaceDriverRegistry",
-) {}
-
-export const registry = (drivers: Readonly<Record<string, Interface>>): Registry => ({
-  get: (provider) => {
-    const driver = drivers[provider]
-    return driver ? Effect.succeed(driver) : Effect.fail(new ProviderNotFound({ provider }))
-  },
-})
-
-export const registryNode = (drivers: Readonly<Record<string, Interface>>) =>
-  makeGlobalNode({
-    service: RegistryService,
-    layer: Layer.succeed(RegistryService, RegistryService.of(registry(drivers))),
-    deps: [],
-  })
-
-export const node = registryNode({})

packages/core/src/workspace/sql.ts

@@ -1,11 +0,0 @@
-import { Workspace } from "@opencode-ai/schema/workspace"
-import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core"
-import type { WorkspaceDriver } from "./driver"
-
-export const WorkspaceTable = sqliteTable("workspace", {
-  id: text().$type<Workspace.ID>().primaryKey(),
-  provider: text().notNull(),
-  binding: text({ mode: "json" }).$type<WorkspaceDriver.Binding>().notNull(),
-  created_at: integer().notNull(),
-  last_used_at: integer().notNull(),
-})

packages/core/test/file-mutation.test.ts

@@ -9,12 +9,11 @@ import { Environment } from "@opencode-ai/core/environment"
 import { Location } from "@opencode-ai/core/location"
 import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { type EnvironmentFilesTransform, transformEnvironmentFiles } from "./fixture/environment"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { it } from "./lib/effect"
 
-function provide(directory: string, transformFiles: EnvironmentFilesTransform = () => ({})) {
+function provide(directory: string, environmentLayer = LayerNode.compile(Environment.node)) {
   const activeLocation = Layer.succeed(
     Location.Service,
     Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
@@ -22,7 +21,7 @@ function provide(directory: string, transformFiles: EnvironmentFilesTransform =
   return Effect.provide(
     AppNodeBuilder.build(LayerNode.group([LocationMutation.node, FileMutation.node]), [
       [Location.node, activeLocation],
-      [Environment.node, transformEnvironmentFiles(activeLocation, transformFiles)],
+      [Environment.node, environmentLayer],
     ]),
   )
 }
@@ -241,8 +240,18 @@ describe("FileMutation", () => {
   )
 })
 
-function instrumentWrites(
-  run: <E>(write: Effect.Effect<void, E>, target: string) => Effect.Effect<void, E>,
-): EnvironmentFilesTransform {
-  return (files) => ({ write: (target, content) => run(files.write(target, content), target) })
+function instrumentWrites(run: <E>(write: Effect.Effect<void, E>, target: string) => Effect.Effect<void, E>) {
+  return Layer.effect(
+    Environment.Service,
+    Effect.gen(function* () {
+      const environment = yield* Environment.Service
+      return Environment.Service.of({
+        ...environment,
+        files: {
+          ...environment.files,
+          write: (target, content) => run(environment.files.write(target, content), target),
+        },
+      })
+    }),
+  ).pipe(Layer.provide(LayerNode.compile(Environment.node)))
 }

packages/core/test/fixture/environment.ts

@@ -1,22 +0,0 @@
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Environment } from "@opencode-ai/core/environment"
-import { Location } from "@opencode-ai/core/location"
-import { Effect, Layer } from "effect"
-
-export type EnvironmentFilesTransform = (files: Environment.Files) => Partial<Environment.Files>
-
-export function transformEnvironmentFiles(
-  location: Layer.Layer<Location.Service>,
-  transform: EnvironmentFilesTransform = () => ({}),
-) {
-  return Layer.effect(
-    Environment.Service,
-    Effect.gen(function* () {
-      const current = yield* Environment.Service
-      return Environment.Service.of({
-        ...current,
-        files: { ...current.files, ...transform(current.files) },
-      })
-    }),
-  ).pipe(Layer.provide(AppNodeBuilder.build(Environment.node, [[Location.node, location]])))
-}

packages/core/test/github-copilot/openai-responses-language-model.test.ts

@@ -1,7 +1,7 @@
 import { OpenAIResponsesLanguageModel } from "@opencode-ai/core/github-copilot/responses/openai-responses-language-model"
 import { convertToOpenAIResponsesInput } from "@opencode-ai/core/github-copilot/responses/convert-to-openai-responses-input"
 import { describe, test, expect, mock } from "bun:test"
-import type { LanguageModelV3Prompt, LanguageModelV3StreamPart } from "@ai-sdk/provider"
+import type { LanguageModelV3Prompt } from "@ai-sdk/provider"
 
 const TEST_PROMPT: LanguageModelV3Prompt = [{ role: "user", content: [{ type: "text", text: "Hello" }] }]
 
@@ -11,16 +11,6 @@ function createMockFetch(body: unknown) {
   )
 }
 
-function createStreamFetch(events: ReadonlyArray<Record<string, unknown>>) {
-  return mock(
-    async () =>
-      new Response(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(""), {
-        status: 200,
-        headers: { "Content-Type": "text/event-stream" },
-      }),
-  )
-}
-
 function createModel(fetchFn: ReturnType<typeof mock>) {
   return new OpenAIResponsesLanguageModel("test-model", {
     provider: "copilot",
@@ -87,173 +77,10 @@ describe("doGenerate", () => {
     expect(providerMetadata?.copilot?.responseId).toBe("resp_1")
     expect(providerMetadata?.openai).toBeUndefined()
   })
-
-  test("defaults to stateless encrypted reasoning and keeps previousResponseId opt-in", async () => {
-    const requests: Array<Record<string, unknown>> = []
-    const fetchFn = mock(async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
-      requests.push(JSON.parse(init?.body as string))
-      return new Response(
-        JSON.stringify({
-          id: "resp_1",
-          created_at: 0,
-          model: "gpt-5.5",
-          output: [],
-          usage: { input_tokens: 1, output_tokens: 1 },
-        }),
-        { status: 200, headers: { "Content-Type": "application/json" } },
-      )
-    })
-    const model = createModel(fetchFn)
-
-    await model.doGenerate({ prompt: TEST_PROMPT, includeRawChunks: false } as any)
-    await model.doGenerate({
-      prompt: TEST_PROMPT,
-      includeRawChunks: false,
-      providerOptions: { copilot: { previousResponseId: "resp_previous", store: false } },
-    } as any)
-    await model.doGenerate({
-      prompt: TEST_PROMPT,
-      includeRawChunks: false,
-      providerOptions: { copilot: { store: true } },
-    } as any)
-
-    expect(requests[0]?.previous_response_id).toBeUndefined()
-    expect(requests[0]?.store).toBe(false)
-    expect(requests[0]?.include).toEqual(["reasoning.encrypted_content"])
-    expect(requests[1]?.previous_response_id).toBe("resp_previous")
-    expect(requests[1]?.store).toBe(false)
-    expect(requests[1]?.include).toEqual(["reasoning.encrypted_content"])
-    expect(requests[2]?.store).toBe(true)
-    expect(requests[2]?.include).toEqual(["reasoning.encrypted_content"])
-  })
-})
-
-describe("doStream", () => {
-  test("streams sequential Copilot reasoning summary blocks", async () => {
-    const model = createModel(
-      createStreamFetch([
-        {
-          type: "response.output_item.added",
-          output_index: 0,
-          item: { type: "reasoning", id: "rs_1", encrypted_content: null },
-        },
-        {
-          type: "response.output_item.added",
-          output_index: 0,
-          item: { type: "reasoning", id: "rs_rotated", encrypted_content: null },
-        },
-        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 0 },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "First" },
-        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 0 },
-        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
-        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 1, delta: "Second" },
-        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 1 },
-        {
-          type: "response.output_item.done",
-          output_index: 0,
-          item: { type: "reasoning", id: "rs_rotated", encrypted_content: "encrypted-state" },
-        },
-      ]),
-    )
-    const result = await model.doStream({
-      prompt: TEST_PROMPT,
-      includeRawChunks: false,
-      providerOptions: { copilot: { store: false } },
-    } as any)
-    const reader = result.stream.getReader()
-    const events: LanguageModelV3StreamPart[] = []
-    while (true) {
-      const item = await reader.read()
-      if (item.done) break
-      if (item.value.type.startsWith("reasoning-")) events.push(item.value)
-    }
-
-    expect(events).toMatchObject([
-      {
-        type: "reasoning-start",
-        id: "rs_1:0",
-        providerMetadata: { copilot: { itemId: "rs_1", reasoningEncryptedContent: null } },
-      },
-      { type: "reasoning-delta", id: "rs_1:0", delta: "First" },
-      { type: "reasoning-end", id: "rs_1:0", providerMetadata: { copilot: { itemId: "rs_1" } } },
-      {
-        type: "reasoning-start",
-        id: "rs_1:1",
-        providerMetadata: { copilot: { itemId: "rs_1", reasoningEncryptedContent: null } },
-      },
-      { type: "reasoning-delta", id: "rs_1:1", delta: "Second" },
-      {
-        type: "reasoning-end",
-        id: "rs_1:1",
-        providerMetadata: { copilot: { itemId: "rs_rotated", reasoningEncryptedContent: "encrypted-state" } },
-      },
-    ])
-
-    const deltas = new Map(
-      events.filter((event) => event.type === "reasoning-delta").map((event) => [event.id, event.delta] as const),
-    )
-    const { input } = await convertToOpenAIResponsesInput({
-      prompt: [
-        {
-          role: "assistant",
-          content: events
-            .filter((event) => event.type === "reasoning-end")
-            .map((event) => ({
-              type: "reasoning" as const,
-              text: deltas.get(event.id) ?? "",
-              providerOptions: event.providerMetadata,
-            })),
-        },
-      ],
-      systemMessageMode: "system",
-      store: false,
-    })
-    expect(input).toEqual([
-      {
-        type: "reasoning",
-        id: "rs_rotated",
-        encrypted_content: "encrypted-state",
-        summary: [],
-      },
-    ])
-  })
-
-  test("closes reasoning when a Copilot stream ends before output_item.done", async () => {
-    const model = createModel(
-      createStreamFetch([
-        {
-          type: "response.output_item.added",
-          output_index: 0,
-          item: { type: "reasoning", id: "rs_1", encrypted_content: null },
-        },
-        { type: "response.reasoning_summary_text.delta", item_id: "rs_rotated", summary_index: 0, delta: "First" },
-      ]),
-    )
-    const result = await model.doStream({
-      prompt: TEST_PROMPT,
-      includeRawChunks: false,
-      providerOptions: { copilot: { store: false } },
-    } as any)
-    const reader = result.stream.getReader()
-    const events: LanguageModelV3StreamPart[] = []
-    while (true) {
-      const item = await reader.read()
-      if (item.done) break
-      if (item.value.type.startsWith("reasoning-")) events.push(item.value)
-    }
-
-    expect(events.map((event) => event.type)).toEqual(["reasoning-start", "reasoning-delta", "reasoning-end"])
-    expect(events.at(-1)).toMatchObject({
-      type: "reasoning-end",
-      id: "rs_1:0",
-      providerMetadata: { copilot: { itemId: "rs_1" } },
-    })
-  })
 })
 
 describe("convertToOpenAIResponsesInput", () => {
-  test("omits response item IDs from stateless function calls", async () => {
+  test("echoes a stale tool-call itemId from the copilot namespace as the function_call id", async () => {
     const { input } = await convertToOpenAIResponsesInput({
       prompt: [
         {
@@ -279,11 +106,12 @@ describe("convertToOpenAIResponsesInput", () => {
         call_id: "call_1",
         name: "bash",
         arguments: JSON.stringify({ command: "ls" }),
+        id: "fc_999",
       },
     ])
   })
 
-  test("preserves response item IDs for stored function calls", async () => {
+  test("omits the function_call id once the stale copilot itemId has been stripped", async () => {
     const { input } = await convertToOpenAIResponsesInput({
       prompt: [
         {
@@ -294,16 +122,16 @@ describe("convertToOpenAIResponsesInput", () => {
               toolCallId: "call_1",
               toolName: "bash",
               input: { command: "ls" },
-              providerOptions: { copilot: { itemId: "fc_999" } },
+              providerOptions: {},
             },
           ],
         },
       ],
       systemMessageMode: "system",
-      store: true,
+      store: false,
     })
 
-    expect((input[0] as any).id).toBe("fc_999")
+    expect((input[0] as any).id).toBeUndefined()
   })
 
   test("preserves reasoning items keyed by the copilot namespace instead of dropping them", async () => {
@@ -330,34 +158,12 @@ describe("convertToOpenAIResponsesInput", () => {
         type: "reasoning",
         id: "rs_1",
         encrypted_content: "enc_1",
-        summary: [],
+        summary: [{ type: "summary_text", text: "thinking..." }],
       },
     ])
   })
 
-  test("drops encrypted reasoning with no completed copilot itemId", async () => {
-    const { input, warnings } = await convertToOpenAIResponsesInput({
-      prompt: [
-        {
-          role: "assistant",
-          content: [
-            {
-              type: "reasoning",
-              text: "thinking...",
-              providerOptions: { copilot: { reasoningEncryptedContent: "enc_1" } },
-            },
-          ],
-        },
-      ],
-      systemMessageMode: "system",
-      store: false,
-    })
-
-    expect(input).toEqual([])
-    expect(warnings).toHaveLength(1)
-  })
-
-  test("drops reasoning with neither a copilot itemId nor encrypted content", async () => {
+  test("drops reasoning items with no copilot itemId and warns, as before", async () => {
     const { input, warnings } = await convertToOpenAIResponsesInput({
       prompt: [
         {

packages/core/test/integration.test.ts

@@ -140,11 +140,7 @@ describe("Integration", () => {
       yield* integrations.transform((editor) =>
         editor.method.update({
           integrationID,
-          method: {
-            type: "key",
-            label: "API key",
-            form: [{ type: "string", key: "accountId", title: "Account ID", required: true }],
-          },
+          method: { type: "key", label: "API key" },
         }),
       )
       const updated = yield* bus
@@ -152,17 +148,9 @@ describe("Integration", () => {
         .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
 
-      expect(
-        yield* integrations.connection.key({ integrationID, key: "secret" }).pipe(
-          Effect.flip,
-          Effect.map((error) => error.cause),
-        ),
-      ).toEqual(expect.objectContaining({ message: "Missing required form field: accountId" }))
-
       yield* integrations.connection.key({
         integrationID,
         key: "secret",
-        answer: { accountId: "account" },
         label: "Work",
       })
 
@@ -170,7 +158,7 @@ describe("Integration", () => {
         expect.objectContaining({
           integrationID,
           label: "Work",
-          value: Credential.Key.make({ type: "key", key: "secret", configuration: { accountId: "account" } }),
+          value: Credential.Key.make({ type: "key", key: "secret" }),
         }),
       ])
       expect((yield* Fiber.join(updated)).length).toBe(1)
@@ -255,6 +243,7 @@ describe("Integration", () => {
       const attempt = yield* integrations.oauth.connect({
         integrationID,
         methodID,
+        inputs: {},
         label: "Personal",
       })
       expect(attempt.mode).toBe("code")
@@ -300,7 +289,7 @@ describe("Integration", () => {
         }),
       )
 
-      const attempt = yield* integrations.oauth.connect({ integrationID, methodID })
+      const attempt = yield* integrations.oauth.connect({ integrationID, methodID, inputs: {} })
       expect(
         yield* integrations.oauth.complete({ integrationID, attemptID: attempt.attemptID }).pipe(Effect.flip),
       ).toBeInstanceOf(Integration.CodeRequiredError)
@@ -338,7 +327,7 @@ describe("Integration", () => {
         }),
       )
 
-      const attempt = yield* integrations.oauth.connect({ integrationID, methodID })
+      const attempt = yield* integrations.oauth.connect({ integrationID, methodID, inputs: {} })
       yield* Effect.yieldNow
       expect(yield* integrations.oauth.status({ integrationID, attemptID: attempt.attemptID })).toEqual({
         status: "complete",
@@ -376,7 +365,7 @@ describe("Integration", () => {
         }),
       )
 
-      const attempt = yield* integrations.oauth.connect({ integrationID, methodID })
+      const attempt = yield* integrations.oauth.connect({ integrationID, methodID, inputs: {} })
       const exit = yield* integrations.oauth
         .complete({ integrationID, attemptID: attempt.attemptID, code: "1234" })
         .pipe(Effect.exit)
@@ -412,7 +401,7 @@ describe("Integration", () => {
         }),
       )
 
-      const attempt = yield* integrations.oauth.connect({ integrationID, methodID })
+      const attempt = yield* integrations.oauth.connect({ integrationID, methodID, inputs: {} })
       expect(attempt.time.expires - attempt.time.created).toBe(Duration.toMillis(Duration.minutes(10)))
       yield* TestClock.adjust(Duration.minutes(10))
       yield* Effect.yieldNow
@@ -453,7 +442,7 @@ describe("Integration", () => {
             }),
           )
 
-          const attempt = yield* integrations.oauth.connect({ integrationID, methodID })
+          const attempt = yield* integrations.oauth.connect({ integrationID, methodID, inputs: {} })
           expect(attempt.time).toEqual({ created, expires: expiresAt })
         })
       })

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

@@ -305,13 +305,11 @@ describe("LocationServiceMap", () => {
           )
           yield* Deferred.await(started)
 
-          const flushFiber = yield* PluginSupervisor.Service.use((supervisor) => supervisor.flush).pipe(
+          yield* PluginSupervisor.Service.use((supervisor) => supervisor.flush).pipe(
             Effect.provide(context),
-            Effect.forkChild({ startImmediately: true }),
+            Effect.timeout("1 second"),
           )
-          expect(flushFiber.pollUnsafe()).toBeUndefined()
           yield* Deferred.succeed(release, undefined)
-          yield* Fiber.join(flushFiber)
           yield* Deferred.await(completed)
         }),
       ),

packages/core/test/model-resolver.test.ts

@@ -736,11 +736,7 @@ describe("ModelResolver", () => {
           headers: { "x-aisdk": "header" },
           body: { custom: true },
         }),
-        Credential.Key.make({
-          type: "key",
-          key: "fallback-secret",
-          configuration: { accountId: "account" },
-        }),
+        Credential.Key.make({ type: "key", key: "fallback-secret" }),
         {
           loadAISDK: (runtime) =>
             Effect.sync(() => {
@@ -749,7 +745,7 @@ describe("ModelResolver", () => {
                 modelID: "mistral-api-model",
                 providerID: "test-provider",
                 package: Provider.aisdk("@ai-sdk/mistral"),
-                settings: { project: "test", apiKey: "fallback-secret", accountId: "account" },
+                settings: { project: "test", apiKey: "fallback-secret" },
                 headers: { "x-aisdk": "header" },
                 body: { custom: true },
               })

packages/core/test/plugin/host.ts

@@ -1,5 +1,5 @@
 import { Plugin } from "@opencode-ai/plugin/effect"
-import type { IntegrationMethod, IntegrationMethodRegistration } from "@opencode-ai/plugin/effect/integration"
+import type { IntegrationMethodRegistration } from "@opencode-ai/plugin/effect/integration"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
@@ -15,6 +15,7 @@ import { Effect, Stream } from "effect"
 type Overrides = Partial<Omit<Plugin.Context, "options" | "session">> & {
   readonly session?: Partial<Plugin.Context["session"]>
 }
+
 export function host(overrides: Overrides = {}): Plugin.Context {
   return {
     app: overrides.app ?? { name: "test", version: "test", channel: "test" },
@@ -277,7 +278,7 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
           update: (id, update) => draft.update(Integration.ID.make(id), update),
           remove: (id) => draft.remove(Integration.ID.make(id)),
           method: {
-            list: (id) => draft.method.list(Integration.ID.make(id)),
+            list: (id) => draft.method.list(Integration.ID.make(id)).map(method),
             update: (input) => {
               if ("authorize" in input) {
                 const methodID = Integration.MethodID.make(input.method.id)
@@ -285,8 +286,8 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
                 draft.method.update({
                   integrationID: Integration.ID.make(input.integrationID),
                   method: { ...input.method, id: methodID },
-                  authorize: (answer) =>
-                    input.authorize(answer).pipe(
+                  authorize: (inputs) =>
+                    input.authorize(inputs).pipe(
                       Effect.map((authorization) => {
                         if (authorization.mode === "auto") {
                           return {
@@ -335,7 +336,7 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
               if (input.method.type === "env") {
                 draft.method.update({
                   integrationID: Integration.ID.make(input.integrationID),
-                  method: input.method,
+                  method: { ...input.method, names: [...input.method.names] },
                 })
                 return
               }
@@ -345,6 +346,7 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
                   method: {
                     ...input.method,
                     id: Integration.MethodID.make(input.method.id),
+                    command: [...input.method.command],
                   },
                 })
                 return
@@ -399,11 +401,35 @@ function oauthCredential(value: Credential.OAuth) {
   return Credential.OAuth.make({ ...value, methodID: Integration.MethodID.make(value.methodID) })
 }
 
-function internalMethod(value: IntegrationMethod): Integration.Method {
-  if (value.type === "oauth" || value.type === "command") {
-    return { ...value, id: Integration.MethodID.make(value.id) }
+function method(value: Integration.Method) {
+  if (value.type === "env") return { type: value.type, names: [...value.names] }
+  if (value.type === "key") return { type: value.type, label: value.label }
+  if (value.type === "command") return { ...value, command: [...value.command] }
+  return {
+    type: value.type,
+    id: value.id,
+    label: value.label,
+    prompts: value.prompts?.map((prompt) => {
+      if (prompt.type === "text") return { ...prompt }
+      return { ...prompt, options: prompt.options.map((option) => ({ ...option })) }
+    }),
+  }
+}
+
+function internalMethod(value: IntegrationMethodRegistration["method"]): Integration.Method {
+  if (value.type === "env") return value
+  if (value.type === "key") return value
+  if (value.type === "command") {
+    return {
+      ...value,
+      id: Integration.MethodID.make(value.id),
+      command: [...value.command],
+    }
+  }
+  return {
+    ...value,
+    id: Integration.MethodID.make(value.id),
   }
-  return value
 }
 
 function agentInfo(value: Agent.Info) {

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

@@ -8,7 +8,6 @@ import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { AzurePlugin } from "@opencode-ai/core/plugin/provider/azure"
 import { Provider } from "@opencode-ai/core/provider"
-import { Integration } from "@opencode-ai/core/integration"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
@@ -61,27 +60,6 @@ function fakeSelectorSdk(calls: string[]) {
 }
 
 describe("AzurePlugin", () => {
-  it.effect("registers a resource name form when the environment does not provide one", () =>
-    withEnv({ AZURE_RESOURCE_NAME: undefined, AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: undefined }, () =>
-      Effect.gen(function* () {
-        yield* addPlugin()
-        expect((yield* (yield* Integration.Service).get(Integration.ID.make("azure")))?.methods).toContainEqual({
-          type: "key",
-          label: "API key",
-          form: [
-            {
-              type: "string",
-              key: "resourceName",
-              title: "Enter Azure Resource Name",
-              placeholder: "e.g. my-models",
-              required: true,
-            },
-          ],
-        })
-      }),
-    ),
-  )
-
   it.effect("resolves resourceName from env", () =>
     withEnv({ AZURE_RESOURCE_NAME: "from-env" }, () =>
       Effect.gen(function* () {
@@ -217,17 +195,7 @@ describe("AzurePlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((catalog) =>
-          catalog.provider.update(Provider.ID.azure, (provider) => {
-            provider.settings = { ...provider.settings, baseURL: "https://proxy.example.com/openai" }
-          }),
-        )
         yield* addPlugin()
-        expect((yield* (yield* Integration.Service).get(Integration.ID.make("azure")))?.methods).toContainEqual({
-          type: "key",
-          label: "API key",
-        })
         const result = yield* aisdk.runSDK({
           model: Model.Info.make({
             ...Model.Info.default(Provider.ID.azure, Model.ID.make("deployment")),

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

@@ -1,13 +1,11 @@
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { describe, expect, mock } from "bun:test"
 import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { CloudflareAIGatewayPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-ai-gateway"
 import { Provider } from "@opencode-ai/core/provider"
-import { Integration } from "@opencode-ai/core/integration"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
@@ -104,24 +102,6 @@ mock.module("ai-gateway-provider/providers/unified", () => ({
 }))
 
 describe("CloudflareAIGatewayPlugin", () => {
-  it.effect("registers account and gateway forms when the environment does not provide them", () =>
-    withEnv({ CLOUDFLARE_ACCOUNT_ID: undefined, CLOUDFLARE_GATEWAY_ID: undefined }, () =>
-      Effect.gen(function* () {
-        yield* addPlugin()
-        expect(
-          (yield* (yield* Integration.Service).get(Integration.ID.make("cloudflare-ai-gateway")))?.methods,
-        ).toContainEqual({
-          type: "key",
-          label: "Gateway API token",
-          form: [
-            expect.objectContaining({ type: "string", key: "accountId", required: true }),
-            expect.objectContaining({ type: "string", key: "gatewayId", required: true }),
-          ],
-        })
-      }),
-    ),
-  )
-
   it.effect("requires account, gateway, and token before creating the unified SDK", () =>
     withEnv(
       {
@@ -377,16 +357,7 @@ describe("CloudflareAIGatewayPlugin", () => {
           resetCalls()
           const plugin = yield* Plugin.Service
           const aisdk = yield* AISDK.Service
-          const catalog = yield* Catalog.Service
-          yield* catalog.transform((catalog) =>
-            catalog.provider.update(Provider.ID.make("cloudflare-ai-gateway"), (provider) => {
-              provider.settings = { ...provider.settings, baseURL: "https://proxy.example/v1" }
-            }),
-          )
           yield* addPlugin()
-          expect(
-            (yield* (yield* Integration.Service).get(Integration.ID.make("cloudflare-ai-gateway")))?.methods,
-          ).toContainEqual({ type: "key", label: "Gateway API token" })
 
           const result = yield* aisdk.runSDK({
             model: Model.Info.make({

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

@@ -7,7 +7,6 @@ import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { CloudflareWorkersAIPlugin } from "@opencode-ai/core/plugin/provider/cloudflare-workers-ai"
 import { Provider } from "@opencode-ai/core/provider"
-import { Integration } from "@opencode-ai/core/integration"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
@@ -80,29 +79,6 @@ function cloudflareHeaders(sdk: unknown, modelID = "@cf/model") {
 }
 
 describe("CloudflareWorkersAIPlugin", () => {
-  it.effect("registers an account form when the environment does not provide one", () =>
-    withEnv({ CLOUDFLARE_ACCOUNT_ID: undefined }, () =>
-      Effect.gen(function* () {
-        yield* addPlugin()
-        expect(
-          (yield* (yield* Integration.Service).get(Integration.ID.make("cloudflare-workers-ai")))?.methods,
-        ).toContainEqual({
-          type: "key",
-          label: "API key",
-          form: [
-            {
-              type: "string",
-              key: "accountId",
-              title: "Enter your Cloudflare Account ID",
-              placeholder: "e.g. 1234567890abcdef1234567890abcdef",
-              required: true,
-            },
-          ],
-        })
-      }),
-    ),
-  )
-
   it.effect("maps account ID to endpoint URL and creates an OpenAI-compatible SDK", () =>
     withEnv({ CLOUDFLARE_ACCOUNT_ID: "acct", CLOUDFLARE_API_KEY: "key" }, () =>
       Effect.gen(function* () {
@@ -115,9 +91,6 @@ describe("CloudflareWorkersAIPlugin", () => {
           }),
         )
         yield* addPlugin()
-        expect(
-          (yield* (yield* Integration.Service).get(Integration.ID.make("cloudflare-workers-ai")))?.methods,
-        ).toContainEqual({ type: "key", label: "API key" })
         const provider = required(yield* catalog.provider.get(Provider.ID.make("cloudflare-workers-ai")))
         const sdk = yield* aisdk.runSDK({
           model: Model.Info.make({
@@ -162,16 +135,7 @@ describe("CloudflareWorkersAIPlugin", () => {
       Effect.gen(function* () {
         const plugin = yield* Plugin.Service
         const aisdk = yield* AISDK.Service
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((catalog) =>
-          catalog.provider.update(Provider.ID.make("cloudflare-workers-ai"), (provider) => {
-            provider.settings = { ...provider.settings, baseURL: "https://proxy.example/v1" }
-          }),
-        )
         yield* addPlugin()
-        expect(
-          (yield* (yield* Integration.Service).get(Integration.ID.make("cloudflare-workers-ai")))?.methods,
-        ).toContainEqual({ type: "key", label: "API key" })
         const result = yield* aisdk.runSDK({
           model: Model.Info.make({
             ...Model.Info.default(Provider.ID.make("cloudflare-workers-ai"), Model.ID.make("@cf/model")),

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

@@ -1,14 +1,11 @@
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { App } from "@opencode-ai/core/app"
-import { Agent } from "@opencode-ai/schema/agent"
-import { Session } from "@opencode-ai/schema/session"
 import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { copilotBaseURL, copilotFetch, GithubCopilotPlugin } from "@opencode-ai/core/plugin/provider/github-copilot"
 import { Provider } from "@opencode-ai/core/provider"
 import { Integration } from "@opencode-ai/core/integration"
@@ -60,37 +57,11 @@ describe("GithubCopilotPlugin", () => {
         id: Integration.MethodID.make("device"),
         type: "oauth",
         label: "Login with GitHub Copilot",
-        form: expect.any(Array),
+        prompts: expect.any(Array),
       })
     }),
   )
 
-  it.effect("removes the generic key method", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      yield* integrations.transform((draft) => {
-        draft.method.update({
-          integrationID: Integration.ID.make("github-copilot"),
-          method: { type: "key" },
-        })
-        draft.method.update({
-          integrationID: Integration.ID.make("github-copilot"),
-          method: { type: "env", names: ["GITHUB_TOKEN"] },
-        })
-      })
-      yield* addPlugin()
-      expect((yield* integrations.get(Integration.ID.make("github-copilot")))?.methods).toEqual([
-        { type: "env", names: ["GITHUB_TOKEN"] },
-        {
-          id: Integration.MethodID.make("device"),
-          type: "oauth",
-          label: "Login with GitHub Copilot",
-          form: expect.any(Array),
-        },
-      ])
-    }),
-  )
-
   it.live("adds Copilot authentication and request metadata headers", () =>
     Effect.gen(function* () {
       const requests: Headers[] = []
@@ -100,6 +71,7 @@ describe("GithubCopilotPlugin", () => {
           requests.push(new Headers(init?.headers))
           return Response.json({ ok: true })
         },
+        false,
         App.make({ name: "test", version: "1.2.3", channel: "beta" }),
       )
       yield* Effect.promise(() =>
@@ -120,27 +92,6 @@ describe("GithubCopilotPlugin", () => {
     }),
   )
 
-  it.effect("adds Copilot authentication to native Anthropic requests", () =>
-    Effect.gen(function* () {
-      yield* addPlugin()
-      const event = yield* (yield* PluginHooks.Service).trigger("session", "http.request", {
-        sessionID: Session.ID.make("ses_test"),
-        agent: Agent.ID.make("build"),
-        model: Model.Ref.make({ providerID: Provider.ID.githubCopilot, id: Model.ID.make("claude-sonnet-4.5") }),
-        request: new Request("https://api.githubcopilot.com/v1/messages", {
-          method: "POST",
-          headers: { "Content-Type": "application/json", "x-api-key": "token" },
-          body: JSON.stringify({ messages: [{ role: "user", content: [{ type: "text", text: "hello" }] }] }),
-        }),
-      })
-      expect(event.request.headers.get("authorization")).toBe("Bearer token")
-      expect(event.request.headers.has("x-api-key")).toBe(false)
-      expect(event.request.headers.get("x-initiator")).toBe("user")
-      expect(event.request.headers.get("anthropic-beta")).toBe("interleaved-thinking-2025-05-14")
-      expect(event.request.headers.get("x-github-api-version")).toBe("2026-06-01")
-    }),
-  )
-
   it.effect("creates the bundled Copilot SDK for the GitHub Copilot package", () =>
     Effect.gen(function* () {
       const plugin = yield* Plugin.Service

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

@@ -128,7 +128,7 @@ describe("OpencodePlugin", () => {
           const attempt = yield* integrations.oauth.connect({
             integrationID,
             methodID: Integration.MethodID.make("device"),
-            answer: { server: `${server.url.origin}/console///?ignored=true#ignored` },
+            inputs: { server: `${server.url.origin}/console///?ignored=true#ignored` },
           })
           expect(attempt.url).toBe(`${server.url.origin}/verify`)
           yield* eventually(
@@ -155,7 +155,7 @@ describe("OpencodePlugin", () => {
         .connect({
           integrationID: Integration.ID.make("opencode"),
           methodID: Integration.MethodID.make("device"),
-          answer: { server: "ftp://console.example.com" },
+          inputs: { server: "ftp://console.example.com" },
         })
         .pipe(Effect.flip)
       expect(error).toBeInstanceOf(Integration.AuthorizationError)
@@ -163,21 +163,6 @@ describe("OpencodePlugin", () => {
     }),
   )
 
-  it.effect("rejects non-string OpenCode servers", () =>
-    Effect.gen(function* () {
-      yield* addPlugin()
-      const error = yield* (yield* Integration.Service).oauth
-        .connect({
-          integrationID: Integration.ID.make("opencode"),
-          methodID: Integration.MethodID.make("device"),
-          answer: { server: true },
-        })
-        .pipe(Effect.flip)
-      expect(error).toBeInstanceOf(Integration.AuthorizationError)
-      expect(String(error.cause)).toContain("Invalid OpenCode server URL: expected string")
-    }),
-  )
-
   it.live("loads providers and models from the connected OpenCode server", () =>
     Effect.acquireUseRelease(
       Effect.sync(() => {

packages/core/test/plugin/websearch.test.ts

@@ -129,10 +129,7 @@ describe("built-in web search providers", () => {
       yield* WebSearchParallel.Plugin.effect(
         host({ integration: integrationHost(integrations), websearch: webSearchHost(websearch) }),
       )
-      yield* integrations.connection.key({
-        integrationID: Integration.ID.make("parallel"),
-        key: "parallel-secret",
-      })
+      yield* integrations.connection.key({ integrationID: Integration.ID.make("parallel"), key: "parallel-secret" })
 
       const output = yield* websearch.query({
         query: "effect layers",

packages/core/test/ripgrep.test.ts

@@ -3,15 +3,12 @@ import fs from "fs/promises"
 import path from "path"
 import { Effect } from "effect"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Location } from "@opencode-ai/core/location"
 import { Ripgrep } from "@opencode-ai/core/ripgrep"
 import { RelativePath } from "@opencode-ai/core/schema"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
-import { tempLocationLayer } from "./fixture/location"
 
-const it = testEffect(AppNodeBuilder.build(Ripgrep.node, [[Location.node, tempLocationLayer]]))
+const it = testEffect(LayerNode.compile(Ripgrep.node))
 
 describe("Ripgrep", () => {
   it.live("globs files as an array", () =>

packages/core/test/session-projector.test.ts

@@ -358,7 +358,6 @@ describe("SessionProjector", () => {
           directory: "/project",
           title: "test",
           version: "test",
-          agent: build,
           model: previousModel,
         })
         .run()
@@ -367,11 +366,7 @@ describe("SessionProjector", () => {
 
       yield* bus.publish(SessionEvent.AgentSelected, {
         sessionID,
-        agent: Agent.ID.make("plan"),
-      })
-      yield* bus.publish(SessionEvent.AgentSelected, {
-        sessionID,
-        agent: Agent.ID.make("general"),
+        agent: build,
       })
       yield* bus.publish(SessionEvent.ModelSelected, {
         sessionID,
@@ -454,7 +449,6 @@ describe("SessionProjector", () => {
       )
 
       expect(messages.map((message) => message.type)).toEqual([
-        "agent-switched",
         "agent-switched",
         "model-switched",
         "synthetic",
@@ -465,10 +459,6 @@ describe("SessionProjector", () => {
         text: "synthetic context",
         metadata: { source: "projector-test" },
       })
-      expect(messages.filter((message) => message.type === "agent-switched")).toMatchObject([
-        { agent: "plan", previous: "build" },
-        { agent: "general", previous: "plan" },
-      ])
       expect(messages.find((message) => message.type === "model-switched")).toMatchObject({ previous: previousModel })
       expect(messages.find((message) => message.type === "shell")).toMatchObject({
         command: "pwd",
@@ -484,7 +474,7 @@ describe("SessionProjector", () => {
       expect(
         yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie),
       ).toMatchObject({
-        agent: "general",
+        agent: "build",
         model,
         time_updated: DateTime.toEpochMillis(created),
       })

packages/core/test/session-runner-message.test.ts

@@ -3,8 +3,7 @@ import { Message } from "@opencode-ai/ai"
 import { Model } from "@opencode-ai/core/model"
 import { Provider } from "@opencode-ai/core/provider"
 import { SessionMessage } from "@opencode-ai/core/session/message"
-import { AgentAttachment, Base64, FileAttachment, SkillAttachment } from "@opencode-ai/schema/prompt"
-import { Skill } from "@opencode-ai/schema/skill"
+import { AgentAttachment, Base64, FileAttachment } from "@opencode-ai/schema/prompt"
 import { toLLMMessages } from "@opencode-ai/core/session/runner/to-llm-message"
 import { Agent } from "@opencode-ai/core/agent"
 import { Shell } from "@opencode-ai/schema/shell"
@@ -185,40 +184,6 @@ Recent work
     })
   })
 
-  test("lowers selected skill instructions with the original user prompt", () => {
-    const messages = toLLMMessages(
-      [
-        SessionMessage.User.make({
-          id: id("user-skill"),
-          type: "user",
-          text: "Design this API",
-          skills: [
-            SkillAttachment.make({
-              id: Skill.ID.make("api-design"),
-              name: Skill.Name.make("API design"),
-              text: "Start from the ideal call site.",
-            }),
-          ],
-          time: { created },
-        }),
-      ],
-      model,
-    )
-
-    expect(messages).toHaveLength(1)
-    expect(messages[0]).toMatchObject({
-      id: id("user-skill"),
-      role: "user",
-      content: [
-        {
-          type: "text",
-          text: "Start from the ideal call site.",
-        },
-        { type: "text", text: "Design this API" },
-      ],
-    })
-  })
-
   test("decodes inline text attachment content", () => {
     const messages = toLLMMessages(
       [

packages/core/test/session-skill.test.ts

@@ -15,7 +15,6 @@ import { SessionExecution } from "@opencode-ai/core/session/execution"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionStore } from "@opencode-ai/core/session/store"
-import { SessionPending } from "@opencode-ai/core/session/pending"
 import { Skill } from "@opencode-ai/core/skill"
 import { testEffect } from "./lib/effect"
 
@@ -56,41 +55,6 @@ const it = testEffect(
 )
 
 describe("Session.skill", () => {
-  it.effect("attaches a resolved skill snapshot to a normal prompt", () =>
-    Effect.gen(function* () {
-      const sessions = yield* Session.Service
-      const database = yield* Database.Service
-      const bus = yield* Bus.Service
-      const session = yield* sessions.create({ location })
-      const id = SessionMessage.ID.make("msg_skill_attachment")
-
-      yield* sessions.prompt({
-        id,
-        sessionID: session.id,
-        text: "Apply this guidance",
-        skills: [{ id: Skill.ID.make("effect"), mention: { start: 20, end: 27, text: "/effect" } }],
-        resume: false,
-      })
-      yield* SessionPending.promote(database.db, bus, session.id, "steer")
-
-      expect(yield* sessions.messages({ sessionID: session.id })).toContainEqual(
-        expect.objectContaining({
-          id,
-          type: "user",
-          text: "Apply this guidance",
-          skills: [
-            {
-              id: "effect",
-              name: "Effect",
-              text: expect.stringContaining("Use Effect"),
-              mention: { start: 20, end: 27, text: "/effect" },
-            },
-          ],
-        }),
-      )
-    }),
-  )
-
   it.effect("projects the caller-supplied message ID", () =>
     Effect.gen(function* () {
       const sessions = yield* Session.Service

packages/core/test/shared-schema.test.ts

@@ -90,10 +90,15 @@ test("Core reuses the canonical shared schemas", async () => {
     [coreFileSystem.Match, FileSystem.Match],
     [coreIntegration.ID, Integration.ID],
     [coreIntegration.MethodID, Integration.MethodID],
+    [coreIntegration.When, Integration.When],
+    [coreIntegration.TextPrompt, Integration.TextPrompt],
+    [coreIntegration.SelectPrompt, Integration.SelectPrompt],
+    [coreIntegration.Prompt, Integration.Prompt],
     [coreIntegration.OAuthMethod, Integration.OAuthMethod],
     [coreIntegration.KeyMethod, Integration.KeyMethod],
     [coreIntegration.EnvMethod, Integration.EnvMethod],
     [coreIntegration.Method, Integration.Method],
+    [coreIntegration.Inputs, Integration.Inputs],
     [coreIntegration.Ref, Integration.Ref],
     [coreLocation.Ref, Location.Ref],
     [coreAI.ProviderMetadata, AI.ProviderMetadata],

packages/core/test/tool-edit.test.ts

@@ -14,7 +14,6 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { Tool } from "@opencode-ai/core/tool"
 import { EditTool } from "@opencode-ai/core/tool/plugin/edit"
-import { transformEnvironmentFiles } from "./fixture/environment"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -81,6 +80,29 @@ const reset = () => {
   formatFile = () => Effect.succeed(false)
 }
 
+const environment = Layer.effect(
+  Environment.Service,
+  Effect.gen(function* () {
+    const current = yield* Environment.Service
+    return Environment.Service.of({
+      ...current,
+      files: {
+        ...current.files,
+        read: (target, range) =>
+          current.files
+            .read(target, range)
+            .pipe(
+              Effect.tap((result) =>
+                Effect.sync(() => reads++).pipe(Effect.andThen(Effect.suspend(() => afterRead(target, result.bytes)))),
+              ),
+            ),
+        write: (target, content) =>
+          Effect.sync(() => writes.push(target)).pipe(Effect.andThen(current.files.write(target, content))),
+      },
+    })
+  }),
+).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+
 const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) => Effect.Effect<A, E, R>) => {
   const activeLocation = Layer.succeed(
     Location.Service,
@@ -93,23 +115,7 @@ const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) =
       AppNodeBuilder.build(
         LayerNode.group([Tool.node, Tool.node, LocationMutation.node, FileMutation.node, editToolNode]),
         [
-          [
-            Environment.node,
-            transformEnvironmentFiles(activeLocation, (files) => ({
-              read: (target, range) =>
-                files
-                  .read(target, range)
-                  .pipe(
-                    Effect.tap((result) =>
-                      Effect.sync(() => reads++).pipe(
-                        Effect.andThen(Effect.suspend(() => afterRead(target, result.bytes))),
-                      ),
-                    ),
-                  ),
-              write: (target, content) =>
-                Effect.sync(() => writes.push(target)).pipe(Effect.andThen(files.write(target, content))),
-            })),
-          ],
+          [Environment.node, environment],
           [Location.node, activeLocation],
           [Formatter.node, formatter],
           [Permission.node, permission],

packages/core/test/tool-patch.test.ts

@@ -14,7 +14,6 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { Tool } from "@opencode-ai/core/tool"
 import { PatchTool } from "@opencode-ai/core/tool/plugin/patch"
-import { transformEnvironmentFiles } from "./fixture/environment"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -83,6 +82,34 @@ const reset = () => {
   formatFile = () => Effect.succeed(false)
 }
 
+const environment = Layer.effect(
+  Environment.Service,
+  Effect.gen(function* () {
+    const current = yield* Environment.Service
+    return Environment.Service.of({
+      ...current,
+      files: {
+        ...current.files,
+        read: (target, range) =>
+          Effect.sync(() => {
+            if (!editApproved) readsBeforeEditApproval++
+          }).pipe(Effect.andThen(current.files.read(target, range))),
+        remove: (target) => {
+          if (failRemoveTarget && path.basename(target) === failRemoveTarget) return Effect.die("forced remove failure")
+          if (failRemoveErrorTarget && path.basename(target) === failRemoveErrorTarget)
+            return Effect.fail(new Environment.Failed({ path: target, cause: new Error("forced remove failure") }))
+          return current.files.remove(target)
+        },
+        write: (target, content) => {
+          if (failWriteTarget && path.basename(target) === failWriteTarget)
+            return Effect.fail(new Environment.Failed({ path: target, cause: new Error("forced write failure") }))
+          return current.files.write(target, content)
+        },
+      },
+    })
+  }),
+).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+
 const withTool = <A, E, R>(
   directory: string,
   body: (registry: Tool.Interface) => Effect.Effect<A, E, R>,
@@ -99,27 +126,7 @@ const withTool = <A, E, R>(
   }).pipe(
     Effect.provide(
       AppNodeBuilder.build(LayerNode.group([Tool.node, FileMutation.node, patchToolNode]), [
-        [
-          Environment.node,
-          transformEnvironmentFiles(activeLocation, (files) => ({
-            read: (target, range) =>
-              Effect.sync(() => {
-                if (!editApproved) readsBeforeEditApproval++
-              }).pipe(Effect.andThen(files.read(target, range))),
-            remove: (target) => {
-              if (failRemoveTarget && path.basename(target) === failRemoveTarget)
-                return Effect.die("forced remove failure")
-              if (failRemoveErrorTarget && path.basename(target) === failRemoveErrorTarget)
-                return Effect.fail(new Environment.Failed({ path: target, cause: new Error("forced remove failure") }))
-              return files.remove(target)
-            },
-            write: (target, content) => {
-              if (failWriteTarget && path.basename(target) === failWriteTarget)
-                return Effect.fail(new Environment.Failed({ path: target, cause: new Error("forced write failure") }))
-              return files.write(target, content)
-            },
-          })),
-        ],
+        [Environment.node, environment],
         [Location.node, activeLocation],
         [Formatter.node, formatter],
         [Permission.node, permission],

packages/core/test/tool-shell.test.ts

@@ -286,6 +286,31 @@ describe("ShellTool", () => {
     ),
   )
 
+  it.live(
+    "reports a command that fails to spawn",
+    () =>
+      Effect.acquireUseRelease(
+        Effect.promise(() => tmpdir()),
+        (tmp) => {
+          reset()
+          const command = "printf before\0after"
+          return withSession(tmp.path, (registry) =>
+            executeTool(registry, call({ command })).pipe(
+              Effect.andThen((settled) =>
+                Effect.sync(() => {
+                  expect(settled.status).toBe("error")
+                  if (settled.status !== "error") return
+                  expect(settled.error?.message).toContain("Command failed")
+                }),
+              ),
+            ),
+          )
+        },
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
+      ),
+    { timeout: 2_000 },
+  )
+
   it.live("permissions compound commands separately", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

packages/core/test/tool-skill.test.ts

@@ -105,9 +105,9 @@ describe("SkillTool", () => {
               }),
             ).toMatchObject({
               status: "completed",
-              content: [{ type: "text", text: Skill.toModelOutput(info, [reference]) }],
+              content: [{ type: "text", text: SkillTool.toModelOutput(info, [reference]) }],
             })
-            expect(Skill.toModelOutput(info, [reference])).toContain(`Base directory for this skill: ${directory}`)
+            expect(SkillTool.toModelOutput(info, [reference])).toContain(`Base directory for this skill: ${directory}`)
             expect(
               yield* executeTool(registry, {
                 sessionID,
@@ -116,8 +116,8 @@ describe("SkillTool", () => {
               }),
             ).toEqual({
               status: "completed",
-              output: { name: "Effect", directory, output: Skill.toModelOutput(info, [reference]) },
-              content: [{ type: "text", text: Skill.toModelOutput(info, [reference]) }],
+              output: { name: "Effect", directory, output: SkillTool.toModelOutput(info, [reference]) },
+              content: [{ type: "text", text: SkillTool.toModelOutput(info, [reference]) }],
               metadata: { name: "Effect", directory },
             })
             expect(assertions).toMatchObject([
@@ -168,7 +168,7 @@ describe("SkillTool", () => {
               }),
             ).toMatchObject({
               status: "completed",
-              content: [{ type: "text", text: Skill.toModelOutput(flat, []) }],
+              content: [{ type: "text", text: SkillTool.toModelOutput(flat, []) }],
             })
           }).pipe(Effect.provide(skillToolLayer))
         }),

packages/core/test/tool-write.test.ts

@@ -14,7 +14,6 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { Tool } from "@opencode-ai/core/tool"
 import { WriteTool } from "@opencode-ai/core/tool/plugin/write"
-import { transformEnvironmentFiles } from "./fixture/environment"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -69,6 +68,21 @@ const reset = () => {
   denyAction = undefined
 }
 
+const environment = Layer.effect(
+  Environment.Service,
+  Effect.gen(function* () {
+    const current = yield* Environment.Service
+    return Environment.Service.of({
+      ...current,
+      files: {
+        ...current.files,
+        write: (target, content) =>
+          Effect.sync(() => writes.push(target)).pipe(Effect.andThen(current.files.write(target, content))),
+      },
+    })
+  }),
+).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+
 const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) => Effect.Effect<A, E, R>) => {
   const activeLocation = Layer.succeed(
     Location.Service,
@@ -81,13 +95,7 @@ const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) =
       AppNodeBuilder.build(
         LayerNode.group([Tool.node, Tool.node, LocationMutation.node, FileMutation.node, writeToolNode]),
         [
-          [
-            Environment.node,
-            transformEnvironmentFiles(activeLocation, (files) => ({
-              write: (target, content) =>
-                Effect.sync(() => writes.push(target)).pipe(Effect.andThen(files.write(target, content))),
-            })),
-          ],
+          [Environment.node, environment],
           [Location.node, activeLocation],
           [Formatter.node, formatter],
           [Permission.node, permission],

packages/core/test/workspace.test.ts

@@ -1,106 +0,0 @@
-import { beforeEach, expect } from "bun:test"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Database } from "@opencode-ai/core/database/database"
-import { makeMemoryDriver } from "@opencode-ai/core/environment"
-import { Workspace } from "@opencode-ai/core/workspace"
-import { WorkspaceDriver } from "@opencode-ai/core/workspace/driver"
-import { WorkspaceTable } from "@opencode-ai/core/workspace/sql"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { eq } from "drizzle-orm"
-import { Effect } from "effect"
-import { TestClock } from "effect/testing"
-import { ChildProcess } from "effect/unstable/process"
-import { testEffect } from "./lib/effect"
-
-const calls: Array<{ readonly operation: string; readonly binding?: WorkspaceDriver.Binding }> = []
-const memory = makeMemoryDriver()
-let failConnect = false
-
-const driver = WorkspaceDriver.make({
-  create: ({ workspaceID }) => {
-    calls.push({ operation: "create" })
-    return Effect.succeed({ binding: { workspaceID, generation: 0 } })
-  },
-  connect: ({ binding }) => {
-    calls.push({ operation: "connect", binding })
-    if (failConnect) return Effect.fail(new WorkspaceDriver.Error({ message: "wake failed" }))
-    return Effect.succeed(memory)
-  },
-  suspendForIdle: ({ binding, saveBinding }) => {
-    calls.push({ operation: "suspendForIdle", binding })
-    return saveBinding({ ...binding, generation: Number(binding.generation) + 1, suspended: true })
-  },
-  destroy: ({ binding }) => {
-    calls.push({ operation: "destroy", binding })
-    return Effect.void
-  },
-})
-
-const it = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([Database.node, Workspace.configured({ idleThreshold: "5 minutes", pollInterval: "1 minute" })]),
-    [[WorkspaceDriver.node, WorkspaceDriver.registryNode({ fake: driver })]],
-  ),
-)
-
-beforeEach(() => {
-  calls.splice(0)
-  failConnect = false
-})
-
-it.effect("persists the workspace lifecycle and reconnects after idle suspension", () =>
-  Effect.gen(function* () {
-    const workspace = yield* Workspace.Service
-    const created = yield* workspace.create("fake")
-
-    expect(created.id.startsWith("wrk_")).toBe(true)
-    expect(created.binding).toEqual({ workspaceID: created.id, generation: 0 })
-
-    const environment = yield* workspace.connect(created.id)
-    expect(calls.map((call) => call.operation)).toEqual(["create"])
-
-    yield* TestClock.adjust("4 minutes")
-    yield* Effect.scoped(environment.spawner.spawn(ChildProcess.make("activity"))).pipe(Effect.exit)
-    yield* TestClock.adjust("4 minutes")
-    expect(calls.map((call) => call.operation)).toEqual(["create", "connect"])
-
-    yield* TestClock.adjust("2 minutes")
-    expect(calls.map((call) => call.operation)).toEqual(["create", "connect", "suspendForIdle"])
-
-    const stored = yield* Database.Service.use(({ db }) =>
-      db.select().from(WorkspaceTable).where(eq(WorkspaceTable.id, created.id)).get(),
-    ).pipe(Effect.orDie)
-    expect(stored?.binding).toEqual({ workspaceID: created.id, generation: 1, suspended: true })
-    expect(stored?.last_used_at).toBe(4 * 60 * 1000)
-
-    yield* Effect.scoped(environment.spawner.spawn(ChildProcess.make("wake"))).pipe(Effect.exit)
-    expect(calls.map((call) => call.operation)).toEqual(["create", "connect", "suspendForIdle", "connect"])
-    expect(calls.at(-1)?.binding).toEqual({ workspaceID: created.id, generation: 1, suspended: true })
-
-    yield* workspace.destroy(created.id)
-    expect(calls.at(-1)?.operation).toBe("destroy")
-  }),
-)
-
-it.effect("surfaces wake failures through the spawn error channel", () =>
-  Effect.gen(function* () {
-    const workspace = yield* Workspace.Service
-    const created = yield* workspace.create("fake")
-    const environment = yield* workspace.connect(created.id)
-    yield* Effect.scoped(environment.spawner.spawn(ChildProcess.make("connect"))).pipe(Effect.exit)
-
-    yield* TestClock.adjust("6 minutes")
-    failConnect = true
-
-    const error = yield* Effect.scoped(environment.spawner.spawn(ChildProcess.make("wake"))).pipe(Effect.flip)
-    expect(error).toMatchObject({
-      _tag: "PlatformError",
-      reason: {
-        _tag: "Unknown",
-        module: "Workspace",
-        method: "spawn",
-        description: `Failed to wake workspace ${created.id}`,
-      },
-    })
-  }),
-)

packages/httpapi-codegen/src/index.ts

@@ -1316,15 +1316,7 @@ export function write(
         }).pipe(Effect.flatMap((content) => fs.writeFileString(join(directory, file.path), content))),
       { concurrency: 8, discard: true },
     )
-    // Format the manifest with the same prettier settings as the repo-wide
-    // format pass, so `check:generated` stays clean after the generate bot
-    // reformats the tree.
-    const manifestJson = JSON.stringify(output.files.map((file) => file.path).sort())
-    const manifestContent = yield* Effect.tryPromise({
-      try: () => format(manifestJson, { filepath: manifest, parser: "json", printWidth: 120 }),
-      catch: (error) => new GenerationError({ reason: `Failed to format ${manifest}: ${String(error)}` }),
-    })
-    yield* fs.writeFileString(manifest, manifestContent)
+    yield* fs.writeFileString(manifest, JSON.stringify(output.files.map((file) => file.path).sort(), null, 2) + "\n")
   })
 }
 

packages/httpapi-codegen/test/write.test.ts

@@ -16,7 +16,7 @@ describe("HttpApiCodegen.write", () => {
 
       expect(writes).toEqual([
         { path: "/generated/session.ts", content: "export const session = {}\n" },
-        { path: "/generated/.httpapi-codegen.json", content: '["session.ts"]\n' },
+        { path: "/generated/.httpapi-codegen.json", content: '[\n  "session.ts"\n]\n' },
       ])
     }).pipe(
       Effect.provideService(

packages/plugin/src/effect/integration.ts

@@ -1,43 +1,19 @@
-import type { ConnectionInfo } from "@opencode-ai/client"
+import type {
+  ConnectionInfo,
+  IntegrationCommandMethod,
+  IntegrationEnvMethod,
+  IntegrationKeyMethod,
+  IntegrationMethod,
+  IntegrationOAuthMethod,
+} from "@opencode-ai/client"
 import type { IntegrationApi } from "@opencode-ai/client/effect/api"
 import { Credential } from "@opencode-ai/schema/credential"
-import { Form } from "@opencode-ai/schema/form"
 import type { Effect, Scope } from "effect"
 import type { Transform } from "./registration.js"
 
+type IntegrationInputs = Record<string, string>
 type IntegrationRef = { id: string; name: string }
 
-export interface IntegrationOAuthMethod {
-  readonly id: string
-  readonly type: "oauth"
-  readonly label: string
-  readonly form?: Form.Fields
-}
-
-export interface IntegrationCommandMethod {
-  readonly id: string
-  readonly type: "command"
-  readonly label: string
-  readonly command: ReadonlyArray<string>
-}
-
-export interface IntegrationKeyMethod {
-  readonly type: "key"
-  readonly label?: string
-  readonly form?: Form.Fields
-}
-
-export interface IntegrationEnvMethod {
-  readonly type: "env"
-  readonly names: ReadonlyArray<string>
-}
-
-export type IntegrationMethod =
-  | IntegrationOAuthMethod
-  | IntegrationCommandMethod
-  | IntegrationKeyMethod
-  | IntegrationEnvMethod
-
 export type IntegrationOAuthAuthorization = {
   readonly url: string
   readonly instructions: string
@@ -55,7 +31,7 @@ export type IntegrationOAuthAuthorization = {
 export type IntegrationOAuthMethodRegistration = {
   readonly integrationID: string
   readonly method: IntegrationOAuthMethod
-  readonly authorize: (answer: Form.Answer) => Effect.Effect<IntegrationOAuthAuthorization, unknown, Scope.Scope>
+  readonly authorize: (inputs: IntegrationInputs) => Effect.Effect<IntegrationOAuthAuthorization, unknown, Scope.Scope>
   readonly refresh?: (credential: Credential.OAuth) => Effect.Effect<Credential.OAuth, unknown>
   readonly label?: (credential: Credential.OAuth) => string | undefined
 }

packages/plugin/src/promise/integration.ts

@@ -1,42 +1,18 @@
-import type { ConnectionInfo } from "@opencode-ai/client"
+import type {
+  ConnectionInfo,
+  IntegrationCommandMethod,
+  IntegrationEnvMethod,
+  IntegrationKeyMethod,
+  IntegrationMethod,
+  IntegrationOAuthMethod,
+} from "@opencode-ai/client"
 import type { IntegrationApi } from "@opencode-ai/client/promise/api"
 import { Credential } from "@opencode-ai/schema/credential"
-import { Form } from "@opencode-ai/schema/form"
 import type { Transform } from "./registration.js"
 
+type IntegrationInputs = Record<string, string>
 type IntegrationRef = { id: string; name: string }
 
-export interface IntegrationOAuthMethod {
-  readonly id: string
-  readonly type: "oauth"
-  readonly label: string
-  readonly form?: Form.Fields
-}
-
-export interface IntegrationCommandMethod {
-  readonly id: string
-  readonly type: "command"
-  readonly label: string
-  readonly command: ReadonlyArray<string>
-}
-
-export interface IntegrationKeyMethod {
-  readonly type: "key"
-  readonly label?: string
-  readonly form?: Form.Fields
-}
-
-export interface IntegrationEnvMethod {
-  readonly type: "env"
-  readonly names: ReadonlyArray<string>
-}
-
-export type IntegrationMethod =
-  | IntegrationOAuthMethod
-  | IntegrationCommandMethod
-  | IntegrationKeyMethod
-  | IntegrationEnvMethod
-
 export type IntegrationOAuthAuthorization = {
   readonly url: string
   readonly instructions: string
@@ -55,7 +31,7 @@ export type IntegrationOAuthAuthorization = {
 export type IntegrationOAuthMethodRegistration = {
   readonly integrationID: string
   readonly method: IntegrationOAuthMethod
-  readonly authorize: (answer: Form.Answer) => Promise<IntegrationOAuthAuthorization>
+  readonly authorize: (inputs: IntegrationInputs) => Promise<IntegrationOAuthAuthorization>
   readonly refresh?: (credential: Credential.OAuth) => Promise<Credential.OAuth>
   readonly label?: (credential: Credential.OAuth) => string | undefined
 }
@@ -63,10 +39,7 @@ export type IntegrationOAuthMethodRegistration = {
 export type IntegrationMethodRegistration =
   | IntegrationOAuthMethodRegistration
   | { readonly integrationID: string; readonly method: IntegrationCommandMethod }
-  | {
-      readonly integrationID: string
-      readonly method: IntegrationKeyMethod
-    }
+  | { readonly integrationID: string; readonly method: IntegrationKeyMethod }
   | { readonly integrationID: string; readonly method: IntegrationEnvMethod }
 
 export interface IntegrationDraft {

packages/protocol/src/groups/integration.ts

@@ -1,11 +1,12 @@
 import { Integration } from "@opencode-ai/schema/integration"
 import { Location } from "@opencode-ai/schema/location"
-import { Form } from "@opencode-ai/schema/form"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
 import { InvalidRequestError } from "../errors.js"
 import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
+const Inputs = Schema.Record(Schema.String, Schema.String)
+
 export const IntegrationGroup = HttpApiGroup.make("server.integration")
   .add(
     HttpApiEndpoint.get("integration.list", "/api/integration", {
@@ -58,7 +59,6 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
       query: LocationQuery,
       payload: Schema.Struct({
         key: Schema.String,
-        answer: Schema.optional(Form.Answer),
         label: Schema.optional(Schema.String),
       }),
       success: HttpApiSchema.NoContent,
@@ -79,7 +79,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
       query: LocationQuery,
       payload: Schema.Struct({
         methodID: Integration.MethodID,
-        answer: Schema.optional(Form.Answer),
+        inputs: Inputs,
         label: Schema.optional(Schema.String),
       }),
       success: Location.response(Integration.Attempt),

packages/protocol/src/groups/session.ts

@@ -345,7 +345,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
           model: Model.Ref.pipe(Schema.optional),
           files: PromptInput.Prompt.fields.files,
           agents: PromptInput.Prompt.fields.agents,
-          skills: PromptInput.Prompt.fields.skills,
           delivery: SessionPending.Delivery.pipe(Schema.optional),
           resume: Schema.Boolean.pipe(Schema.optional),
         }),

packages/schema/src/credential.ts

@@ -5,7 +5,6 @@ import { optional } from "./schema.js"
 import { IntegrationMethodID } from "./integration-id.js"
 import { ascending } from "./identifier.js"
 import { NonNegativeInt, statics } from "./schema.js"
-import { Form } from "./form.js"
 
 export const ID = Schema.String.pipe(
   Schema.brand("Credential.ID"),
@@ -28,7 +27,6 @@ export const Key = Schema.Struct({
   type: Schema.Literal("key"),
   key: Schema.String,
   metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
-  configuration: optional(Form.Answer),
 }).annotate({ identifier: "Credential.Key" })
 
 export const Value = Schema.Union([OAuth, Key])

packages/schema/src/integration.ts

@@ -7,7 +7,6 @@ import { Connection } from "./connection.js"
 import { ascending } from "./identifier.js"
 import { statics } from "./schema.js"
 import { IntegrationID, IntegrationMethodID } from "./integration-id.js"
-import { Form } from "./form.js"
 
 export const ID = IntegrationID
 export type ID = typeof ID.Type
@@ -15,12 +14,46 @@ export type ID = typeof ID.Type
 export const MethodID = IntegrationMethodID
 export type MethodID = typeof MethodID.Type
 
+export interface When extends Schema.Schema.Type<typeof When> {}
+export const When = Schema.Struct({
+  key: Schema.String,
+  op: Schema.Literals(["eq", "neq"]),
+  value: Schema.String,
+}).annotate({ identifier: "Integration.When" })
+
+export interface TextPrompt extends Schema.Schema.Type<typeof TextPrompt> {}
+export const TextPrompt = Schema.Struct({
+  type: Schema.Literal("text"),
+  key: Schema.String,
+  message: Schema.String,
+  placeholder: optional(Schema.String),
+  when: optional(When),
+}).annotate({ identifier: "Integration.TextPrompt" })
+
+export interface SelectPrompt extends Schema.Schema.Type<typeof SelectPrompt> {}
+export const SelectPrompt = Schema.Struct({
+  type: Schema.Literal("select"),
+  key: Schema.String,
+  message: Schema.String,
+  options: Schema.Array(
+    Schema.Struct({
+      label: Schema.String,
+      value: Schema.String,
+      hint: optional(Schema.String),
+    }),
+  ),
+  when: optional(When),
+}).annotate({ identifier: "Integration.SelectPrompt" })
+
+export const Prompt = Schema.Union([TextPrompt, SelectPrompt]).pipe(Schema.toTaggedUnion("type"))
+export type Prompt = typeof Prompt.Type
+
 export interface OAuthMethod extends Schema.Schema.Type<typeof OAuthMethod> {}
 export const OAuthMethod = Schema.Struct({
   id: MethodID,
   type: Schema.Literal("oauth"),
   label: Schema.String,
-  form: optional(Form.Fields),
+  prompts: optional(Schema.Array(Prompt)),
 }).annotate({ identifier: "Integration.OAuthMethod" })
 
 export interface CommandMethod extends Schema.Schema.Type<typeof CommandMethod> {}
@@ -35,7 +68,6 @@ export interface KeyMethod extends Schema.Schema.Type<typeof KeyMethod> {}
 export const KeyMethod = Schema.Struct({
   type: Schema.Literal("key"),
   label: optional(Schema.String),
-  form: optional(Form.Fields),
 }).annotate({ identifier: "Integration.KeyMethod" })
 
 export interface EnvMethod extends Schema.Schema.Type<typeof EnvMethod> {}
@@ -49,6 +81,9 @@ export const Method = Schema.Union([OAuthMethod, CommandMethod, KeyMethod, EnvMe
   .annotate({ identifier: "Integration.Method" })
 export type Method = typeof Method.Type
 
+export const Inputs = Schema.Record(Schema.String, Schema.String).annotate({ identifier: "Integration.Inputs" })
+export type Inputs = typeof Inputs.Type
+
 const Updated = ephemeral({
   type: "integration.updated",
   schema: {},

packages/schema/src/prompt-input.ts

@@ -3,7 +3,6 @@ export * as PromptInput from "./prompt-input.js"
 import { Schema } from "effect"
 import { AgentAttachment, PromptMention } from "./prompt.js"
 import { optional, statics } from "./schema.js"
-import { Skill } from "./skill.js"
 
 export interface FileAttachment extends Schema.Schema.Type<typeof FileAttachment> {}
 export const FileAttachment = Schema.Struct({
@@ -20,15 +19,8 @@ export const FileAttachment = Schema.Struct({
   )
 
 export interface Prompt extends Schema.Schema.Type<typeof Prompt> {}
-export interface SkillAttachment extends Schema.Schema.Type<typeof SkillAttachment> {}
-export const SkillAttachment = Schema.Struct({
-  id: Skill.ID,
-  mention: PromptMention.pipe(optional),
-}).annotate({ identifier: "PromptInput.SkillAttachment" })
-
 export const Prompt = Schema.Struct({
   text: Schema.String,
   files: Schema.Array(FileAttachment).pipe(optional),
   agents: Schema.Array(AgentAttachment).pipe(optional),
-  skills: Schema.Array(SkillAttachment).pipe(optional),
 }).annotate({ identifier: "PromptInput" })

packages/schema/src/prompt.ts

@@ -1,7 +1,6 @@
 import { Schema } from "effect"
 import { optional } from "./schema.js"
 import { statics } from "./schema.js"
-import { Skill } from "./skill.js"
 
 export interface PromptMention extends Schema.Schema.Type<typeof PromptMention> {}
 export const PromptMention = Schema.Struct({
@@ -53,31 +52,21 @@ export const AgentAttachment = Schema.Struct({
   mention: PromptMention.pipe(optional),
 }).annotate({ identifier: "Prompt.AgentAttachment" })
 
-export interface SkillAttachment extends Schema.Schema.Type<typeof SkillAttachment> {}
-export const SkillAttachment = Schema.Struct({
-  id: Skill.ID,
-  name: Skill.Name,
-  text: Schema.String,
-  mention: PromptMention.pipe(optional),
-}).annotate({ identifier: "Prompt.SkillAttachment" })
-
 export interface Prompt extends Schema.Schema.Type<typeof Prompt> {}
 export const Prompt = Schema.Struct({
   text: Schema.String,
   files: Schema.Array(FileAttachment).pipe(optional),
   agents: Schema.Array(AgentAttachment).pipe(optional),
-  skills: Schema.Array(SkillAttachment).pipe(optional),
 })
   .annotate({ identifier: "Prompt" })
   .pipe(
     statics((schema) => ({
       equivalence: Schema.toEquivalence(schema),
-      fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents" | "skills">) =>
+      fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) =>
         schema.make({
           text: input.text,
           ...(input.files === undefined ? {} : { files: input.files }),
           ...(input.agents === undefined ? {} : { agents: input.agents }),
-          ...(input.skills === undefined ? {} : { skills: input.skills }),
         }),
     })),
   )

packages/schema/src/session-message.ts

@@ -42,7 +42,6 @@ export const AgentSelected = Schema.Struct({
   ...Base,
   type: Schema.tag("agent-switched"),
   agent: Agent.ID,
-  previous: Agent.ID.pipe(optional),
 }).annotate({ identifier: "Session.Message.AgentSelected" })
 
 export interface ModelSelected extends Schema.Schema.Type<typeof ModelSelected> {}
@@ -59,7 +58,6 @@ export const User = Schema.Struct({
   text: Prompt.fields.text,
   files: Prompt.fields.files,
   agents: Prompt.fields.agents,
-  skills: Prompt.fields.skills,
   type: Schema.tag("user"),
 }).annotate({ identifier: "Session.Message.User" })
 

packages/server/src/handlers/integration.ts

@@ -58,7 +58,6 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
             service.connection.key({
               integrationID: ctx.params.integrationID,
               key: ctx.payload.key,
-              answer: ctx.payload.answer,
               label: ctx.payload.label,
             }),
           )
@@ -74,7 +73,7 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
               service.oauth.connect({
                 integrationID: ctx.params.integrationID,
                 methodID: ctx.payload.methodID,
-                answer: ctx.payload.answer,
+                inputs: ctx.payload.inputs,
                 label: ctx.payload.label,
               }),
             ),

packages/server/src/handlers/session.ts

@@ -313,7 +313,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
                 text: ctx.payload.text,
                 files: ctx.payload.files,
                 agents: ctx.payload.agents,
-                skills: ctx.payload.skills,
                 metadata: ctx.payload.metadata,
                 delivery: ctx.payload.delivery,
                 resume: ctx.payload.resume,
@@ -338,9 +337,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
                 Effect.catchTag("Session.AttachmentError", (error) =>
                   Effect.fail(new InvalidRequestError({ message: error.message, field: "files" })),
                 ),
-                Effect.catchTag("Session.SkillNotFoundError", (error) =>
-                  Effect.fail(new InvalidRequestError({ message: `Skill not found: ${error.skill}`, field: "skills" })),
-                ),
               ),
           }
         }),
@@ -359,7 +355,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
                 model: ctx.payload.model,
                 files: ctx.payload.files,
                 agents: ctx.payload.agents,
-                skills: ctx.payload.skills,
                 delivery: ctx.payload.delivery,
                 resume: ctx.payload.resume,
               })
@@ -399,9 +394,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
                 Effect.catchTag("Session.AttachmentError", (error) =>
                   Effect.fail(new InvalidRequestError({ message: error.message, field: "files" })),
                 ),
-                Effect.catchTag("Session.SkillNotFoundError", (error) =>
-                  Effect.fail(new InvalidRequestError({ message: `Skill not found: ${error.skill}`, field: "skills" })),
-                ),
               ),
           }
         }),

packages/server/src/handlers/shell.ts

@@ -21,7 +21,9 @@ export const ShellHandler = HttpApiBuilder.group(Api, "server.shell", (handlers)
         Effect.fn(function* (ctx) {
           const shell = yield* Shell.Service
           const location = yield* Location.Service
-          return yield* response(shell.create({ ...ctx.payload, cwd: ctx.payload.cwd || location.directory }))
+          return yield* response(
+            shell.create({ ...ctx.payload, cwd: ctx.payload.cwd || location.directory }).pipe(Effect.orDie),
+          )
         }),
       )
       .handle(

packages/server/src/options.ts

@@ -1,5 +1,6 @@
 import { Database } from "@opencode-ai/core/database/database"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
+import { Observability } from "@opencode-ai/util/observability"
 import { Schema } from "effect"
 
 export const ServerOptions = Schema.Struct({
@@ -21,6 +22,7 @@ export const ServerOptions = Schema.Struct({
     }),
   ),
   models: Schema.optional(ModelsDev.Options),
+  observability: Schema.optional(Observability.Options),
   config: Schema.optional(
     Schema.Struct({
       directory: Schema.optional(Schema.String),

packages/server/src/routes.ts

@@ -7,6 +7,7 @@ import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Bus } from "@opencode-ai/core/bus"
 import { EventLogger } from "@opencode-ai/core/event-logger"
 import { FileSystemSearch } from "@opencode-ai/core/filesystem/search"
+import { Observability } from "@opencode-ai/util/observability"
 import { Credential } from "@opencode-ai/core/credential"
 import { Config } from "@opencode-ai/core/config"
 import { Command } from "@opencode-ai/core/command"
@@ -27,7 +28,6 @@ import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
 import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
 import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
 import { WellKnown } from "@opencode-ai/core/wellknown"
-import { WorkspaceDriver } from "@opencode-ai/core/workspace/driver"
 import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { HttpRouter } from "effect/unstable/http"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
@@ -43,7 +43,6 @@ import { formLocationLayer } from "./middleware/form-location"
 import { sessionLocationLayer } from "./middleware/session-location"
 import { ServerInfo } from "./server-info"
 import type { ServerOptions } from "./options"
-import { modalWorkspaceDriver, provider as modalProvider } from "./workspace/modal-workspace"
 
 const applicationServices = LayerNode.group([
   Database.node,
@@ -116,10 +115,6 @@ function makeRoutes<AuthError, AuthServices>(
     ],
     [PluginRuntime.node, PluginRuntime.layerWithCell(pluginRuntimeCell)],
     [PluginRuntime.providerNode, PluginRuntime.providerNodeWithCell(pluginRuntimeCell)],
-    [
-      WorkspaceDriver.node,
-      WorkspaceDriver.registryNode({ [modalProvider]: modalWorkspaceDriver({ app: "opencode-workspaces" }) }),
-    ],
   ]
   const serviceLayer = options.simulation
     ? Layer.unwrap(
@@ -130,6 +125,13 @@ function makeRoutes<AuthError, AuthServices>(
         }),
       )
     : AppNodeBuilder.build(applicationServices, replacements)
+  const observability = Observability.layer({
+    ...options.observability,
+    client: options.app?.name,
+    version: options.app?.version,
+    channel: options.app?.channel,
+  })
+
   return serviceLayer.pipe(
     Layer.flatMap((context) => {
       const services = Layer.succeedContext(context)
@@ -153,5 +155,6 @@ function makeRoutes<AuthError, AuthServices>(
       )
       return Layer.merge(api, V1Migration.layer.pipe(Layer.provide(services)))
     }),
+    Layer.provide(observability),
   )
 }

packages/server/src/workspace/modal-workspace.ts

@@ -1,128 +0,0 @@
-import { WorkspaceDriver } from "@opencode-ai/core/workspace/driver"
-import { Effect, Option, Schema } from "effect"
-import type { App, Image, ModalClient, ModalClientParams, Sandbox } from "modal"
-import { createModalSandboxWithClient, makeModalDriver, type ModalImageSpec, openModalClient } from "./modal"
-
-export const provider = "modal"
-
-export const ModalBinding = Schema.Struct({
-  sandboxId: Schema.optional(Schema.String),
-  snapshotImageId: Schema.optional(Schema.String),
-})
-export type ModalBinding = typeof ModalBinding.Type
-
-export interface ModalWorkspaceOptions {
-  readonly app: string
-  readonly client?: ModalClientParams
-  readonly image?: ModalImageSpec
-}
-
-export const modalWorkspaceDriver = (options: ModalWorkspaceOptions): WorkspaceDriver.Interface => {
-  const decodeBinding = Schema.decodeUnknownOption(ModalBinding)
-  let clientPromise: Promise<ModalClient> | undefined
-  let appPromise: Promise<App> | undefined
-  // The SDK client and app handle are shared for the process lifetime of this driver.
-  const client = () => (clientPromise ??= openModalClient(options.client))
-  const app = () =>
-    (appPromise ??= client().then((value) => value.apps.fromName(options.app, { createIfMissing: true })))
-
-  const attempt = <A>(run: () => Promise<A>) =>
-    Effect.tryPromise({ try: run, catch: (cause) => new WorkspaceDriver.Error({ cause }) })
-
-  const binding = (value: WorkspaceDriver.Binding): ModalBinding => Option.getOrElse(decodeBinding(value), () => ({}))
-
-  const live = async (lookup: () => Promise<Sandbox>) => {
-    const { NotFoundError } = await import("modal")
-    const sandbox = await lookup().catch((error) => {
-      if (error instanceof NotFoundError) return undefined
-      throw error
-    })
-    if (sandbox && (await sandbox.poll()) === null) return sandbox
-  }
-
-  const findLive = async (modalClient: ModalClient, value: ModalBinding, workspaceID: string) => {
-    if (value.sandboxId) {
-      const sandboxID = value.sandboxId
-      const sandbox = await live(() => modalClient.sandboxes.fromId(sandboxID))
-      if (sandbox) return sandbox
-    }
-    // Name fallback is valid only before the first snapshot; afterward a live named sandbox is stale by design.
-    if (value.snapshotImageId) return
-    return live(() => modalClient.sandboxes.fromName(options.app, workspaceID))
-  }
-
-  const createSandbox = async (workspaceID: string, image?: Image) => {
-    const { AlreadyExistsError } = await import("modal")
-    const modalClient = await client()
-    return createModalSandboxWithClient(
-      modalClient,
-      await app(),
-      {
-        image: options.image,
-        sandbox: {
-          name: workspaceID,
-          tags: { workspace: workspaceID },
-          timeoutMs: 24 * 60 * 60 * 1000,
-        },
-      },
-      image,
-    ).catch((error) => {
-      if (error instanceof AlreadyExistsError) return modalClient.sandboxes.fromName(options.app, workspaceID)
-      throw error
-    })
-  }
-
-  const deleteImage = (modalClient: ModalClient, imageID?: string) =>
-    imageID ? attempt(() => modalClient.images.delete(imageID)).pipe(Effect.ignore) : Effect.void
-
-  const terminate = (sandbox?: Sandbox) =>
-    sandbox ? attempt(() => sandbox.terminate({ wait: true })).pipe(Effect.ignore) : Effect.void
-
-  return WorkspaceDriver.make({
-    create: ({ workspaceID }) =>
-      attempt(async () => {
-        const sandbox = await createSandbox(workspaceID)
-        return { binding: { sandboxId: sandbox.sandboxId } }
-      }),
-    connect: ({ workspaceID, binding: value, saveBinding }) =>
-      Effect.gen(function* () {
-        const modalBinding = binding(value)
-        const modalClient = yield* attempt(client)
-        const sandbox = yield* attempt(async () => {
-          const existing = await findLive(modalClient, modalBinding, workspaceID)
-          const image =
-            existing || !modalBinding.snapshotImageId
-              ? undefined
-              : await modalClient.images.fromId(modalBinding.snapshotImageId)
-          return existing ?? createSandbox(workspaceID, image)
-        })
-        if (modalBinding.sandboxId !== sandbox.sandboxId) {
-          yield* saveBinding({ ...modalBinding, sandboxId: sandbox.sandboxId })
-        }
-        return makeModalDriver(sandbox)
-      }),
-    suspendForIdle: ({ workspaceID, binding: value, saveBinding }) =>
-      Effect.gen(function* () {
-        const modalBinding = binding(value)
-        const modalClient = yield* attempt(client)
-        const sandbox = yield* attempt(() => findLive(modalClient, modalBinding, workspaceID))
-        if (!sandbox) return
-        const snapshot = yield* attempt(() => sandbox.snapshotFilesystem({ ttlMs: null }))
-        yield* saveBinding({ snapshotImageId: snapshot.imageId })
-        yield* Effect.all([deleteImage(modalClient, modalBinding.snapshotImageId), terminate(sandbox)], {
-          concurrency: "unbounded",
-          discard: true,
-        })
-      }),
-    destroy: ({ workspaceID, binding: value }) =>
-      Effect.gen(function* () {
-        const modalBinding = binding(value)
-        const modalClient = yield* attempt(client)
-        const sandbox = yield* attempt(() => findLive(modalClient, modalBinding, workspaceID))
-        yield* Effect.all([terminate(sandbox), deleteImage(modalClient, modalBinding.snapshotImageId)], {
-          concurrency: "unbounded",
-          discard: true,
-        })
-      }),
-  })
-}

packages/server/src/workspace/modal.ts

@@ -3,7 +3,7 @@ import { systemError } from "effect/PlatformError"
 import type { Command, KillOptions } from "effect/unstable/process/ChildProcess"
 import { ExitCode, make, makeHandle, ProcessId } from "effect/unstable/process/ChildProcessSpawner"
 import type { Driver } from "@opencode-ai/core/environment"
-import type { App, Image, ModalClient, ModalClientParams, Sandbox, SandboxCreateParams } from "modal"
+import type { ModalClientParams, Sandbox, SandboxCreateParams } from "modal"
 
 const INNER_WRAPPER = `
 pidfile=$1
@@ -44,14 +44,11 @@ export interface ModalImageSpec {
   readonly dockerfileCommands: ReadonlyArray<string>
 }
 
-export interface ModalSandboxCreateOptions {
-  readonly image?: ModalImageSpec
-  readonly sandbox?: SandboxCreateParams
-}
-
-export interface ModalSandboxOptions extends ModalSandboxCreateOptions {
+export interface ModalSandboxOptions {
   readonly app: string
   readonly client?: ModalClientParams
+  readonly image?: ModalImageSpec
+  readonly sandbox?: SandboxCreateParams
 }
 
 /**
@@ -67,11 +64,19 @@ export const ubuntuImage: ModalImageSpec = {
 
 /** Creates a Modal sandbox lazily, keeping the SDK off the server startup path when Modal is unused. */
 export const createModalSandbox = async (options: ModalSandboxOptions) => {
-  const client = await openModalClient(options.client)
+  const { ModalClient } = await import("modal")
+  const client = new ModalClient(options.client)
   const app = await client.apps.fromName(options.app, { createIfMissing: true })
-  const sandbox = await createModalSandboxWithClient(client, app, {
-    image: options.image,
-    sandbox: options.sandbox,
+  const imageSpec = options.image ?? ubuntuImage
+  const image = client.images.fromRegistry(imageSpec.registry).dockerfileCommands([...imageSpec.dockerfileCommands])
+  // Always Modal's Full-VM runtime (beta, enabled per account): a real kernel
+  // with real device nodes, so workspaces can run Docker and other
+  // kernel-dependent workloads. Costs versus gVisor, measured Aug 2026:
+  // per-exec floor ~285-535ms versus ~90-165ms, and filesystem snapshots only
+  // (no memory snapshots — acceptable; fs-snapshot is the persistence design).
+  const sandbox = await client.sandboxes.create(app, image, {
+    ...options.sandbox,
+    experimentalOptions: { ...options.sandbox?.experimentalOptions, vm_runtime: true },
   })
   return {
     driver: makeModalDriver(sandbox),
@@ -80,32 +85,6 @@ export const createModalSandbox = async (options: ModalSandboxOptions) => {
   }
 }
 
-export const openModalClient = async (params?: ModalClientParams) => {
-  const { ModalClient } = await import("modal")
-  return new ModalClient(params)
-}
-
-export const createModalSandboxWithClient = async (
-  client: ModalClient,
-  app: App,
-  options: ModalSandboxCreateOptions,
-  existingImage?: Image,
-) => {
-  const imageSpec = options.image ?? ubuntuImage
-  const image =
-    existingImage ??
-    client.images.fromRegistry(imageSpec.registry).dockerfileCommands([...imageSpec.dockerfileCommands])
-  // Always Modal's Full-VM runtime (beta, enabled per account): a real kernel
-  // with real device nodes, so workspaces can run Docker and other
-  // kernel-dependent workloads. Costs versus gVisor, measured Aug 2026:
-  // per-exec floor ~285-535ms versus ~90-165ms, and filesystem snapshots only
-  // (no memory snapshots — acceptable; fs-snapshot is the persistence design).
-  return client.sandboxes.create(app, image, {
-    ...options.sandbox,
-    experimentalOptions: { ...options.sandbox?.experimentalOptions, vm_runtime: true },
-  })
-}
-
 /**
  * Adapts Modal exec to the Environment driver. Files intentionally has no native
  * overrides: exec latency dominates payload work (VM runtime floor measured

packages/server/test/workspace-modal.test.ts

@@ -1,54 +0,0 @@
-import fs from "node:fs"
-import os from "node:os"
-import path from "node:path"
-import { expect, test } from "bun:test"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { makeFiles } from "@opencode-ai/core/environment"
-import { Workspace } from "@opencode-ai/core/workspace"
-import { WorkspaceDriver } from "@opencode-ai/core/workspace/driver"
-import { Effect, Layer } from "effect"
-import { TestClock } from "effect/testing"
-import { modalWorkspaceDriver, provider } from "../src/workspace/modal-workspace"
-
-const enabled =
-  !!process.env.OPENCODE_TEST_MODAL &&
-  ((!!process.env.MODAL_TOKEN_ID && !!process.env.MODAL_TOKEN_SECRET) ||
-    fs.existsSync(path.join(os.homedir(), ".modal.toml")))
-
-const testLayer = Layer.provideMerge(
-  AppNodeBuilder.build(Workspace.configured({ idleThreshold: "1 minute", pollInterval: "1 minute" }), [
-    [
-      WorkspaceDriver.node,
-      WorkspaceDriver.registryNode({ [provider]: modalWorkspaceDriver({ app: "opencode-workspace-tests" }) }),
-    ],
-  ]),
-  TestClock.layer(),
-)
-const modalTest = enabled ? test : test.skip
-
-modalTest(
-  "wakes a workspace from its filesystem snapshot",
-  () =>
-    Effect.runPromise(
-      Effect.gen(function* () {
-        const workspace = yield* Workspace.Service
-        yield* Effect.acquireUseRelease(
-          workspace.create(provider),
-          (created) =>
-            Effect.gen(function* () {
-              const environment = yield* workspace.connect(created.id)
-              const files = makeFiles(environment)
-              const file = `/tmp/opencode-workspace-${crypto.randomUUID()}.txt`
-              yield* files.write(file, new TextEncoder().encode("survived snapshot"))
-
-              yield* TestClock.adjust("2 minutes")
-
-              const restored = yield* files.read(file)
-              expect(new TextDecoder().decode(restored.bytes)).toBe("survived snapshot")
-            }),
-          (created) => workspace.destroy(created.id).pipe(Effect.ignore),
-        )
-      }).pipe(Effect.scoped, Effect.provide(testLayer)),
-    ),
-  180_000,
-)

packages/theme/src/tui/syntax.ts

@@ -12,7 +12,6 @@ export function generateSyntax(theme: ResolvedThemeTokens, mode: Mode) {
     rule(["prompt"], theme.hue.accent[step]),
     rule(["extmark.file"], feedback.warning.default, { bold: true }),
     rule(["extmark.agent"], theme.categorical[0][step], { bold: true }),
-    rule(["extmark.skill"], theme.categorical[1][step], { bold: true }),
     // V1 migration preserves its selected/inverse foreground in this action state.
     rule(["extmark.paste"], theme.text.action.primary.focused, {
       background: feedback.warning.default,

packages/tui/src/app.tsx

@@ -118,7 +118,6 @@ const sessionTabBindingCommands = [
   "session.tab.select.7",
   "session.tab.select.8",
   "session.tab.select.9",
-  "session.tab.select.10",
 ] as const
 
 const pinnedSessionBindingCommands = [
@@ -715,7 +714,7 @@ function App(props: { pair?: DialogPairCredentials }) {
         enabled: sessionTabs.enabled,
         run: () => sessionTabs.reopen(),
       },
-      ...Array.from({ length: 10 }, (_, i) => ({
+      ...Array.from({ length: 9 }, (_, i) => ({
         name: `session.tab.select.${i + 1}`,
         title: `Switch to tab ${i + 1}`,
         category: "Session",

packages/tui/src/component/dialog-integration.tsx

@@ -5,10 +5,6 @@ import type {
   IntegrationInfo,
   IntegrationOauthConnectOutput,
   IntegrationOAuthMethod,
-  FormAnswer,
-  FormField,
-  FormFields,
-  FormValue,
 } from "@opencode-ai/client"
 import open from "open"
 import { createMemo, createSignal, onCleanup, onMount, Show } from "solid-js"
@@ -22,7 +18,6 @@ import { DialogPrompt } from "../ui/dialog-prompt"
 import { DialogSelect } from "../ui/dialog-select"
 import { Link } from "../ui/link"
 import { useToast } from "../ui/toast"
-import { formLabel, formToggleMultiselect, formValidateValue, type FormAnswerField } from "../util/form"
 
 const INTEGRATION_PRIORITY: Record<string, number> = {
   opencode: 0,
@@ -37,10 +32,6 @@ type ConnectMethod = Exclude<IntegrationInfo["methods"][number], { type: "env" }
 type IntegrationAttempt = IntegrationOauthConnectOutput["data"]
 type CommandAttempt = IntegrationCommandConnectOutput["data"]
 type OnIntegrationConnected = (providerID?: string) => void
-const CANCELLED = Symbol("cancelled")
-const CUSTOM = Symbol("custom")
-const OPEN = Symbol("open")
-const SUBMIT = Symbol("submit")
 
 export function integrationOptions(list: IntegrationInfo[]) {
   return list.toSorted(
@@ -190,7 +181,7 @@ function openMethod(
   onConnected?: OnIntegrationConnected,
 ) {
   if (method.type === "key") {
-    void beginKey(integration, method, dialog, onConnected)
+    dialog.replace(() => <KeyMethod integration={integration} method={method} onConnected={onConnected} />)
     return
   }
   if (method.type === "command") {
@@ -200,21 +191,6 @@ function openMethod(
   void beginOAuth(integration, method, dialog, onConnected)
 }
 
-async function beginKey(
-  integration: IntegrationInfo,
-  method: Extract<ConnectMethod, { type: "key" }>,
-  dialog: ReturnType<typeof useDialog>,
-  onConnected?: OnIntegrationConnected,
-) {
-  const answer = method.form
-    ? await formAnswer(dialog, method.label ?? `Connect ${integration.name}`, method.form)
-    : undefined
-  if (answer === null) return
-  dialog.replace(() => (
-    <KeyMethod integration={integration} method={method} answer={answer} onConnected={onConnected} />
-  ))
-}
-
 function CommandStarting(props: {
   integration: IntegrationInfo
   method: Extract<ConnectMethod, { type: "command" }>
@@ -360,7 +336,6 @@ function CommandView(props: { title: string; output: string; message: string })
 function KeyMethod(props: {
   integration: IntegrationInfo
   method: Extract<ConnectMethod, { type: "key" }>
-  answer?: FormAnswer
   onConnected?: OnIntegrationConnected
 }) {
   const data = useData()
@@ -381,7 +356,6 @@ function KeyMethod(props: {
             integrationID: props.integration.id,
             location: location(data),
             key,
-            ...(props.answer ? { answer: props.answer } : {}),
           })
           .then(() => connected(props.integration, data, dialog, toast, props.onConnected))
           .catch((cause) => setError(message(cause)))
@@ -399,17 +373,17 @@ async function beginOAuth(
   dialog: ReturnType<typeof useDialog>,
   onConnected?: OnIntegrationConnected,
 ) {
-  const answer = method.form ? await formAnswer(dialog, method.label, method.form) : undefined
-  if (answer === null) return
+  const inputs = method.prompts?.length ? await promptInputs(dialog, method.prompts) : {}
+  if (inputs === null) return
   dialog.replace(() => (
-    <OAuthStarting integration={integration} method={method} answer={answer} onConnected={onConnected} />
+    <OAuthStarting integration={integration} method={method} inputs={inputs} onConnected={onConnected} />
   ))
 }
 
 function OAuthStarting(props: {
   integration: IntegrationInfo
   method: IntegrationOAuthMethod
-  answer?: FormAnswer
+  inputs: Record<string, string>
   onConnected?: OnIntegrationConnected
 }) {
   const data = useData()
@@ -423,7 +397,7 @@ function OAuthStarting(props: {
         integrationID: props.integration.id,
         location: location(data),
         methodID: props.method.id,
-        ...(props.answer ? { answer: props.answer } : {}),
+        inputs: props.inputs,
       })
       .then((result) => {
         if (result.data.mode === "code") {
@@ -647,234 +621,49 @@ function OAuthView(props: {
   )
 }
 
-async function formAnswer(dialog: ReturnType<typeof useDialog>, title: string, fields: FormFields) {
-  const answer: FormAnswer = {}
-  for (const field of fields) {
-    if (!active(field, answer)) continue
-    const value = await fieldAnswer(dialog, title, field)
-    if (value === CANCELLED) return null
-    if (value !== undefined) answer[field.key] = value
-  }
-  return answer
-}
-
-function active(field: FormField, answer: FormAnswer) {
-  if (field.type === "external" || !field.when) return true
-  return field.when.every((when) => {
-    const value = answer[when.key]
-    if (value === undefined) return false
-    const hit = Array.isArray(value) ? value.includes(String(when.value)) : value === when.value
-    return when.op === "eq" ? hit : !hit
-  })
-}
-
-function fieldAnswer(
+async function promptInputs(
   dialog: ReturnType<typeof useDialog>,
-  title: string,
-  field: FormField,
-): Promise<FormValue | undefined | typeof CANCELLED> {
-  if (field.type === "external") return externalAnswer(dialog, title, field)
-  if (field.type === "multiselect") return multiselectAnswer(dialog, title, field)
-  if (field.type === "boolean" || (field.type === "string" && field.options)) {
-    return selectAnswer(dialog, title, field)
-  }
-  return textAnswer(dialog, title, field)
-}
-
-async function selectAnswer(
-  dialog: ReturnType<typeof useDialog>,
-  title: string,
-  field: Extract<FormAnswerField, { type: "boolean" | "string" }>,
-): Promise<FormValue | undefined | typeof CANCELLED> {
-  const options =
-    field.type === "boolean"
-      ? field.default === false
-        ? [
-            { title: "No", value: false as FormValue },
-            { title: "Yes", value: true as FormValue },
-          ]
-        : [
-            { title: "Yes", value: true as FormValue },
-            { title: "No", value: false as FormValue },
-          ]
-      : (field.options ?? []).map((option) => ({
-          title: option.label,
-          value: option.value as FormValue,
-          description: option.description,
-        }))
-  const choice = await new Promise<FormValue | typeof CUSTOM | undefined | typeof CANCELLED>((resolve) => {
-    dialog.replace(
-      () => (
-        <DialogSelect<FormValue | typeof CUSTOM | undefined>
-          title={formLabel(field) || title}
-          options={[
-            ...options,
-            ...(field.type === "string" && field.custom
-              ? [{ title: "Type your own answer", value: CUSTOM as typeof CUSTOM }]
-              : []),
-            ...(!field.required ? [{ title: "Skip", value: undefined }] : []),
-          ]}
-          current={field.type === "string" ? field.default : undefined}
-          onSelect={(option) => resolve(option.value)}
-        />
-      ),
-      () => resolve(CANCELLED),
-    )
-  })
-  if (choice === CUSTOM) {
-    if (field.type !== "string") return CANCELLED
-    return textAnswer(dialog, title, field, "")
-  }
-  return choice
-}
-
-function textAnswer(
-  dialog: ReturnType<typeof useDialog>,
-  title: string,
-  field: Extract<FormAnswerField, { type: "string" | "number" | "integer" }>,
-  initial = field.default === undefined ? undefined : String(field.default),
-): Promise<FormValue | undefined | typeof CANCELLED> {
-  return new Promise<FormValue | undefined | typeof CANCELLED>((resolve) => {
-    dialog.replace(
-      () => {
-        const theme = useTheme("elevated")
-        const [error, setError] = createSignal<string>()
-        return (
-          <DialogPrompt
-            title={formLabel(field) || title}
-            placeholder={field.type === "string" ? field.placeholder : undefined}
-            value={initial}
-            onConfirm={(input) => {
-              const text = input.trim()
-              const value = text === "" && !field.required ? undefined : field.type === "string" ? text : Number(text)
-              const invalid = formValidateValue(field, value)
-              if (invalid) {
-                setError(invalid)
-                return
-              }
-              resolve(value)
-            }}
-            description={() => (
-              <box gap={1}>
-                <Show when={field.description}>
-                  {(description) => <text fg={theme.text.subdued}>{description()}</text>}
-                </Show>
-                <Show when={error()}>{(value) => <text fg={theme.text.feedback.error.default}>{value()}</text>}</Show>
-              </box>
-            )}
-          />
-        )
-      },
-      () => resolve(CANCELLED),
-    )
-  })
-}
-
-async function multiselectAnswer(
-  dialog: ReturnType<typeof useDialog>,
-  title: string,
-  field: Extract<FormAnswerField, { type: "multiselect" }>,
-): Promise<FormValue | typeof CANCELLED> {
-  const selected = field.default ? [...field.default] : []
-  while (true) {
-    const invalid = formValidateValue(field, selected)
-    const choice = await new Promise<string | typeof CUSTOM | typeof SUBMIT | typeof CANCELLED>((resolve) => {
-      dialog.replace(
-        () => (
-          <DialogSelect<string | typeof CUSTOM | typeof SUBMIT>
-            title={formLabel(field) || title}
-            options={[
-              ...field.options.map((option) => ({
-                title: `[${selected.includes(option.value) ? "x" : " "}] ${option.label}`,
+  prompts: NonNullable<IntegrationOAuthMethod["prompts"]>,
+) {
+  const inputs: Record<string, string> = {}
+  for (const prompt of prompts) {
+    if (prompt.when) {
+      const value = inputs[prompt.when.key]
+      if (value === undefined) continue
+      const matches = prompt.when.op === "eq" ? value === prompt.when.value : value !== prompt.when.value
+      if (!matches) continue
+    }
+    if (prompt.type === "select") {
+      const value = await new Promise<string | null>((resolve) => {
+        dialog.replace(
+          () => (
+            <DialogSelect
+              title={prompt.message}
+              options={prompt.options.map((option) => ({
+                title: option.label,
                 value: option.value,
-                description: option.description,
-                disabled:
-                  !selected.includes(option.value) && field.maxItems !== undefined && selected.length >= field.maxItems,
-              })),
-              ...(field.custom ? [{ title: "Type your own answer", value: CUSTOM as typeof CUSTOM }] : []),
-              {
-                title: "Continue",
-                value: SUBMIT as typeof SUBMIT,
-                description: invalid,
-                disabled: invalid !== undefined,
-              },
-            ]}
-            onSelect={(option) => resolve(option.value)}
-          />
-        ),
-        () => resolve(CANCELLED),
-      )
-    })
-    if (choice === CANCELLED) return CANCELLED
-    if (choice === SUBMIT) return selected
-    if (choice === CUSTOM) {
-      const value = await customAnswer(dialog, title, field)
-      if (value === CANCELLED) return CANCELLED
-      if (value && !selected.includes(value)) selected.push(value)
+                description: option.hint,
+              }))}
+              onSelect={(option) => resolve(option.value)}
+            />
+          ),
+          () => resolve(null),
+        )
+      })
+      if (value === null) return null
+      inputs[prompt.key] = value
       continue
     }
-    selected.splice(0, selected.length, ...formToggleMultiselect(selected, choice))
-  }
-}
-
-function customAnswer(
-  dialog: ReturnType<typeof useDialog>,
-  title: string,
-  field: Extract<FormAnswerField, { type: "multiselect" }>,
-): Promise<string | typeof CANCELLED> {
-  return new Promise<string | typeof CANCELLED>((resolve) => {
-    dialog.replace(
-      () => (
-        <DialogPrompt
-          title={formLabel(field) || title}
-          placeholder="Type your own answer"
-          onConfirm={(value) => {
-            if (value) resolve(value)
-          }}
-        />
-      ),
-      () => resolve(CANCELLED),
-    )
-  })
-}
-
-async function externalAnswer(
-  dialog: ReturnType<typeof useDialog>,
-  title: string,
-  field: Extract<FormField, { type: "external" }>,
-): Promise<true | typeof CANCELLED> {
-  let opened = false
-  while (true) {
-    const choice = await new Promise<true | typeof OPEN | typeof CANCELLED>((resolve) => {
+    const value = await new Promise<string | null>((resolve) => {
       dialog.replace(
-        () => (
-          <DialogSelect<true | typeof OPEN>
-            title={formLabel(field) || title}
-            options={[
-              { title: opened ? "Open link again" : "Open link", value: OPEN as typeof OPEN, description: field.url },
-              { title: "I finished", value: true as const, description: field.description, disabled: !opened },
-            ]}
-            onSelect={(option) => resolve(option.value)}
-          />
-        ),
-        () => resolve(CANCELLED),
+        () => <DialogPrompt title={prompt.message} placeholder={prompt.placeholder} onConfirm={resolve} />,
+        () => resolve(null),
       )
     })
-    if (choice === CANCELLED) return CANCELLED
-    if (choice === true) return true
-    const result = await new Promise<boolean | typeof CANCELLED>((resolve) => {
-      dialog.replace(
-        () => <OAuthView title={formLabel(field) || title} message="Opening link..." />,
-        () => resolve(CANCELLED),
-      )
-      void open(field.url).then(
-        () => resolve(true),
-        () => resolve(false),
-      )
-    })
-    if (result === CANCELLED) return CANCELLED
-    opened ||= result
+    if (value === null) return null
+    inputs[prompt.key] = value
   }
+  return inputs
 }
 
 async function connected(

packages/tui/src/component/prompt/autocomplete.tsx

@@ -19,9 +19,8 @@ import { Locale } from "../../util/locale"
 import type { PromptInfo, PromptPartRef } from "../../prompt/history"
 import { useFrecency } from "../../prompt/frecency"
 import { Keymap } from "../../context/keymap"
-import { displayCharAt, mentionTriggerIndex, slashTriggerIndex } from "../../prompt/display"
+import { displayCharAt, mentionTriggerIndex } from "../../prompt/display"
 import type { FileSystemEntry } from "@opencode-ai/client"
-import { Skill } from "@opencode-ai/schema/skill"
 import { stringWidth } from "../../util/string-width"
 import { parseFileLineRange, stripFileLineRange } from "../../prompt/parse"
 import { moveSelection, revealSelectionOffset } from "../../ui/select-controller"
@@ -40,7 +39,6 @@ export type AutocompleteOption = {
   isDirectory?: boolean
   onSelect?: () => void
   path?: string
-  kind?: "skill"
 }
 
 export function Autocomplete(props: {
@@ -53,8 +51,6 @@ export function Autocomplete(props: {
   ref: (ref: AutocompleteRef) => void
   fileStyleId: number
   agentStyleId: number
-  skillStyleId: number
-  hasSkill: (id: string) => boolean
   promptPartTypeId: () => number
 }) {
   const editor = useEditorContext()
@@ -144,17 +140,14 @@ export function Autocomplete(props: {
     text: string,
     part:
       | { type: "file"; value: NonNullable<PromptInfo["files"]>[number]; path?: string }
-      | { type: "agent"; value: NonNullable<PromptInfo["agents"]>[number] }
-      | { type: "skill"; value: NonNullable<PromptInfo["skills"]>[number] },
+      | { type: "agent"; value: NonNullable<PromptInfo["agents"]>[number] },
   ) {
-    if (part.type === "skill" && props.hasSkill(part.value.id)) return
     const input = props.input()
     const currentCursorOffset = input.cursorOffset
 
     const charAfterCursor = displayCharAt(props.value, currentCursorOffset)
     const needsSpace = charAfterCursor !== " "
-    const prefix = part.type === "skill" ? "/" : "@"
-    const append = prefix + text + (needsSpace ? " " : "")
+    const append = "@" + text + (needsSpace ? " " : "")
 
     input.cursorOffset = store.index
     const startCursor = input.logicalCursor
@@ -164,12 +157,11 @@ export function Autocomplete(props: {
     input.deleteRange(startCursor.row, startCursor.col, endCursor.row, endCursor.col)
     input.insertText(append)
 
-    const virtualText = prefix + text
+    const virtualText = "@" + text
     const extmarkStart = store.index
     const extmarkEnd = extmarkStart + stringWidth(virtualText)
 
-    const styleId =
-      part.type === "file" ? props.fileStyleId : part.type === "skill" ? props.skillStyleId : props.agentStyleId
+    const styleId = part.type === "file" ? props.fileStyleId : props.agentStyleId
 
     const extmarkId = input.extmarks.create({
       start: extmarkStart,
@@ -203,20 +195,6 @@ export function Autocomplete(props: {
         return
       }
 
-      if (part.type === "skill") {
-        const skills = (draft.skills ??= [])
-        if (skills.some((skill) => skill.id === part.value.id)) return
-        if (part.value.mention) {
-          part.value.mention.start = extmarkStart
-          part.value.mention.end = extmarkEnd
-          part.value.mention.text = virtualText
-        }
-        const index = skills.length
-        skills.push(part.value)
-        props.setExtmark({ type: "skill", index }, extmarkId)
-        return
-      }
-
       const agents = (draft.agents ??= [])
       if (part.value.mention) {
         part.value.mention.start = extmarkStart
@@ -455,12 +433,7 @@ export function Autocomplete(props: {
       results.push({
         display: "/" + skill.id,
         description: skill.description,
-        kind: "skill",
-        onSelect: () =>
-          insertPart(skill.id, {
-            type: "skill",
-            value: { id: Skill.ID.make(skill.id), mention: { start: 0, end: 0, text: "" } },
-          }),
+        onSelect: () => insertSlash(skill.id),
       })
     }
 
@@ -490,11 +463,7 @@ export function Autocomplete(props: {
     // it shouldn't be additionally sorted by fuzzysort as it will loose the results
     const fileOptions: AutocompleteOption[] = store.visible === "@" ? fileSearch.options : []
     const nonFileOptions: AutocompleteOption[] =
-      store.visible === "@"
-        ? [...referenceAliasesValue, ...agentsValue, ...mcpResources()]
-        : store.index === 0
-          ? [...commandsValue]
-          : commandsValue.filter((item) => item.kind === "skill")
+      store.visible === "@" ? [...referenceAliasesValue, ...agentsValue, ...mcpResources()] : [...commandsValue]
 
     if (!searchValue) {
       return [...nonFileOptions, ...fileOptions]
@@ -551,7 +520,7 @@ export function Autocomplete(props: {
   function select() {
     const selected = options()[store.selected]
     if (!selected) return
-    hide(true)
+    hide()
     selected.onSelect?.()
   }
 
@@ -639,18 +608,14 @@ export function Autocomplete(props: {
     })
   }
 
-  function hide(removeToken = false) {
-    if (removeToken && store.visible === "/") {
-      const input = props.input()
-      const cursorOffset = input.cursorOffset
-      input.cursorOffset = store.index
-      const start = input.logicalCursor
-      input.cursorOffset = cursorOffset
-      const end = input.logicalCursor
-      input.deleteRange(start.row, start.col, end.row, end.col)
+  function hide() {
+    const text = props.input().plainText
+    if (store.visible === "/" && !text.endsWith(" ") && text.startsWith("/")) {
+      const cursor = props.input().logicalCursor
+      props.input().deleteRange(0, 0, cursor.row, cursor.col)
       // Sync the prompt store immediately since onContentChange is async
       props.setPrompt((draft) => {
-        draft.text = input.plainText
+        draft.text = props.input().plainText
       })
     }
     setStore("visible", false)
@@ -675,7 +640,9 @@ export function Autocomplete(props: {
             // Typed text before the trigger
             props.input().cursorOffset <= store.index ||
             // There is a space between the trigger and the cursor
-            props.input().getTextRange(store.index, props.input().cursorOffset).match(/\s/)
+            props.input().getTextRange(store.index, props.input().cursorOffset).match(/\s/) ||
+            // "/<command>" is not the sole content
+            (store.visible === "/" && value.match(/^\S+\s+\S+\s*$/))
           ) {
             hide()
           }
@@ -686,10 +653,10 @@ export function Autocomplete(props: {
         const offset = props.input().cursorOffset
         if (offset === 0) return
 
-        const slash = slashTriggerIndex(value, offset)
-        if (slash !== undefined) {
+        // Check for "/" at position 0 - reopen slash commands
+        if (value.startsWith("/") && !value.slice(0, offset).match(/\s/)) {
           show("/")
-          setStore("index", slash)
+          setStore("index", 0)
           return
         }