feat(core): add Cloudflare connection prompts

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

@@ -561,7 +561,13 @@ function ProviderConnection(props: {
           if (!alive.value) return
           dispatch({ type: "auth.error", error: formatError(e, language.t("common.requestFailed")) })
         })
+      return
     }
+    if (method.prompts?.length && !inputs) {
+      dispatch({ type: "auth.prompt" })
+      return
+    }
+    dispatch({ type: "auth.inputs", inputs: inputs ?? {} })
   }
 
   function AuthPromptsView() {
@@ -572,7 +578,7 @@ function ProviderConnection(props: {
 
     const prompts = createMemo(() => {
       const value = method()
-      return value?.type === "oauth" ? (value.prompts ?? []) : []
+      return value?.prompts ?? []
     })
     const matches = (prompt: NonNullable<ReturnType<typeof prompts>[number]>, value: Record<string, string>) => {
       if (!prompt.when) return true
@@ -820,6 +826,7 @@ function ProviderConnection(props: {
         integrationID: props.provider,
         location: location(),
         key: apiKey,
+        inputs: store.promptInputs ?? {},
       })
       await complete()
     }

packages/app/src/components/dialog-select-mcp.tsx

@@ -10,6 +10,7 @@ const statusLabels = {
   connected: "mcp.status.connected",
   failed: "mcp.status.failed",
   needs_auth: "mcp.status.needs_auth",
+  needs_client_registration: "mcp.status.needs_client_registration",
   disabled: "mcp.status.disabled",
 } as const
 
@@ -56,7 +57,7 @@ export const DialogSelectMcp: Component = () => {
           }
           const error = () => {
             const s = mcpStatus()
-            if (s?.status === "failed") return s.error
+            if (s?.status === "failed" || s?.status === "needs_client_registration") return s.error
           }
           const enabled = () => status() === "connected"
           return (

packages/app/src/components/status-popover-body.tsx

@@ -426,7 +426,8 @@ export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
                             "bg-icon-success-base": status() === "connected",
                             "bg-icon-critical-base": status() === "failed",
                             "bg-border-weak-base": status() === "disabled",
-                            "bg-icon-warning-base": status() === "needs_auth",
+                            "bg-icon-warning-base":
+                              status() === "needs_auth" || status() === "needs_client_registration",
                           }}
                         />
                         <span class="flex flex-col min-w-0 flex-1">

packages/app/src/components/status-popover-indicator.test.ts

@@ -35,6 +35,7 @@ describe("hasNonBlockingServiceIssue", () => {
   test("detects MCP failures that do not block chatting", () => {
     expect(hasNonBlockingServiceIssue({ mcp: ["failed"], lsp: [] })).toBe(true)
     expect(hasNonBlockingServiceIssue({ mcp: ["needs_auth"], lsp: [] })).toBe(true)
+    expect(hasNonBlockingServiceIssue({ mcp: ["needs_client_registration"], lsp: [] })).toBe(true)
     expect(hasNonBlockingServiceIssue({ mcp: ["connected", "pending", "disabled"], lsp: [] })).toBe(false)
   })
 
@@ -47,6 +48,7 @@ describe("hasNonBlockingServiceIssue", () => {
 describe("hasServiceNeedingAttention", () => {
   test("detects MCP states that need user attention", () => {
     expect(hasServiceNeedingAttention({ mcp: ["needs_auth"] })).toBe(true)
+    expect(hasServiceNeedingAttention({ mcp: ["needs_client_registration"] })).toBe(true)
   })
 
   test("ignores states that do not need user attention", () => {

packages/app/src/components/status-popover-indicator.ts

@@ -2,7 +2,7 @@ import type { LspStatus } from "@/types"
 import type { McpServer } from "@opencode-ai/client/promise"
 
 export function hasServiceNeedingAttention(input: { mcp: Array<McpServer["status"]["status"]> }) {
-  return input.mcp.some((status) => status === "needs_auth")
+  return input.mcp.some((status) => status === "needs_auth" || status === "needs_client_registration")
 }
 
 export function hasNonBlockingServiceIssue(input: {

packages/app/src/context/global-sync/mcp.ts

@@ -13,6 +13,7 @@ export async function toggleMcp(input: {
     needs_auth: input.authenticate,
     disabled: input.connect,
     failed: input.connect,
+    needs_client_registration: input.connect,
   }[input.status]()
   await input.refresh()
 }

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

@@ -34,6 +34,7 @@ function icon(status: McpServer["status"]) {
     case "needs_auth":
       return "⚠"
     case "failed":
+    case "needs_client_registration":
       return "✗"
     default:
       return "○"
@@ -44,6 +45,8 @@ function describe(status: McpServer["status"]) {
   switch (status.status) {
     case "needs_auth":
       return "needs authentication"
+    case "needs_client_registration":
+      return `needs client registration: ${status.error}`
     case "failed":
       return `failed: ${status.error}`
     default:

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

@@ -992,6 +992,7 @@ export type Endpoint10_3Input = {
   readonly integrationID: Integration.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly key: string
+  readonly inputs?: { readonly [x: string]: string } | undefined
   readonly label?: string | undefined
 }
 export type Endpoint10_3Output = void

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

@@ -664,7 +664,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"], label: input["label"] },
+      payload: { key: input["key"], inputs: input["inputs"], label: input["label"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 

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

@@ -963,7 +963,7 @@ export function make(options: ClientOptions) {
               method: "POST",
               path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
               query: { location: input["location"] },
-              body: { key: input["key"], label: input["label"] },
+              body: { key: input["key"], inputs: input["inputs"], label: input["label"] },
               successStatus: 204,
               declaredStatuses: [400, 401],
               empty: true,

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

@@ -197,8 +197,6 @@ 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 }
@@ -259,6 +257,8 @@ export type McpStatusFailed = { status: "failed"; error: string }
 
 export type McpStatusNeedsAuth = { status: "needs_auth" }
 
+export type McpStatusNeedsClientRegistration = { status: "needs_client_registration"; error: string }
+
 export type McpResource = { server: string; name: string; uri: string; description?: string; mimeType?: string }
 
 export type McpResourceTemplate = {
@@ -1259,7 +1259,13 @@ export type ConnectionInfo = ConnectionCredentialInfo | ConnectionEnvInfo
 
 export type McpServer = {
   name: string
-  status: McpStatusConnected | McpStatusPending | McpStatusDisabled | McpStatusFailed | McpStatusNeedsAuth
+  status:
+    | McpStatusConnected
+    | McpStatusPending
+    | McpStatusDisabled
+    | McpStatusFailed
+    | McpStatusNeedsAuth
+    | McpStatusNeedsClientRegistration
   integrationID?: string
 }
 
@@ -1630,6 +1636,12 @@ export type IntegrationOAuthMethod = {
   prompts?: Array<IntegrationTextPrompt | IntegrationSelectPrompt>
 }
 
+export type IntegrationKeyMethod = {
+  type: "key"
+  label?: string
+  prompts?: Array<IntegrationTextPrompt | IntegrationSelectPrompt>
+}
+
 export type FormField =
   | FormStringField
   | FormNumberField
@@ -1693,43 +1705,44 @@ export type AgentInfo = {
 export type ConfigEntry =
   | {
       type: "document"
-      path?: string
+      path?: string | null
       info: {
-        $schema?: string
-        shell?: string
-        model?: string | { providerID: string; model: string; variant?: string }
-        default_agent?: string
-        autoupdate?: boolean | "notify"
-        share?: "manual" | "auto" | "disabled"
-        enterprise?: { url?: string }
-        username?: string
-        permissions?: PermissionRuleset
+        $schema?: string | null
+        shell?: string | null
+        model?: string | { providerID: string; model: string; variant?: string | null } | null
+        default_agent?: string | null
+        autoupdate?: boolean | "notify" | null
+        share?: "manual" | "auto" | "disabled" | null
+        enterprise?: { url?: string | null } | null
+        username?: string | null
+        permissions?: PermissionRuleset | null
         agents?: {
           [x: string]: {
-            model?: string | { providerID: string; model: string; variant?: string }
-            request?: { headers?: { [x: string]: string }; body?: { [x: string]: JsonValue } }
-            system?: string
-            description?: string
-            mode?: "subagent" | "primary" | "all"
-            hidden?: boolean
-            color?: string
-            steps?: number
-            disabled?: boolean
-            permissions?: PermissionRuleset
+            model?: string | { providerID: string; model: string; variant?: string | null } | null
+            request?: { headers?: { [x: string]: string } | null; body?: { [x: string]: JsonValue } | null } | null
+            system?: string | null
+            description?: string | null
+            mode?: "subagent" | "primary" | "all" | null
+            hidden?: boolean | null
+            color?: string | null
+            steps?: number | null
+            disabled?: boolean | null
+            permissions?: PermissionRuleset | null
           }
-        }
-        snapshots?: boolean
-        watcher?: { ignore?: Array<string> }
+        } | null
+        snapshots?: boolean | null
+        watcher?: { ignore?: Array<string> | null } | null
         formatter?:
           | boolean
           | {
               [x: string]: {
-                disabled?: boolean
-                command?: Array<string>
-                environment?: { [x: string]: string }
-                extensions?: Array<string>
+                disabled?: boolean | null
+                command?: Array<string> | null
+                environment?: { [x: string]: string } | null
+                extensions?: Array<string> | null
               }
             }
+          | null
         lsp?:
           | boolean
           | {
@@ -1737,117 +1750,125 @@ export type ConfigEntry =
                 | { disabled: true }
                 | {
                     command: Array<string>
-                    extensions?: Array<string>
-                    disabled?: boolean
-                    env?: { [x: string]: string }
-                    initialization?: { [x: string]: JsonValue }
+                    extensions?: Array<string> | null
+                    disabled?: boolean | null
+                    env?: { [x: string]: string } | null
+                    initialization?: { [x: string]: JsonValue } | null
                   }
             }
+          | null
         media?: {
-          image?: { auto_resize?: boolean; max_width?: number; max_height?: number; max_base64_bytes?: number }
-        }
-        tool_output?: { max_lines?: number; max_bytes?: number }
+          image?: {
+            auto_resize?: boolean | null
+            max_width?: number | null
+            max_height?: number | null
+            max_base64_bytes?: number | null
+          } | null
+        } | null
+        tool_output?: { max_lines?: number | null; max_bytes?: number | null } | null
         mcp?: {
-          timeout?: { startup?: number; catalog?: number; execution?: number }
+          timeout?: { startup?: number | null; catalog?: number | null; execution?: number | null } | null
           servers?: {
             [x: string]:
               | {
                   type: "local"
                   command: Array<string>
-                  cwd?: string
-                  environment?: { [x: string]: string }
-                  disabled?: boolean
-                  codemode?: boolean
-                  timeout?: { startup?: number; catalog?: number; execution?: number }
+                  cwd?: string | null
+                  environment?: { [x: string]: string } | null
+                  disabled?: boolean | null
+                  codemode?: boolean | null
+                  timeout?: { startup?: number | null; catalog?: number | null; execution?: number | null } | null
                 }
               | {
                   type: "remote"
                   url: string
-                  headers?: { [x: string]: string }
+                  headers?: { [x: string]: string } | null
                   oauth?:
                     | {
-                        client_id?: string
-                        client_secret?: string
-                        scope?: string
-                        callback_port?: number
-                        redirect_uri?: string
+                        client_id?: string | null
+                        client_secret?: string | null
+                        scope?: string | null
+                        callback_port?: number | null
+                        redirect_uri?: string | null
                       }
                     | false
-                  disabled?: boolean
-                  codemode?: boolean
-                  timeout?: { startup?: number; catalog?: number; execution?: number }
+                    | null
+                  disabled?: boolean | null
+                  codemode?: boolean | null
+                  timeout?: { startup?: number | null; catalog?: number | null; execution?: number | null } | null
                 }
-          }
-        }
-        compaction?: { auto?: boolean; keep?: { tokens?: number }; buffer?: number }
-        skills?: Array<string>
+          } | null
+        } | null
+        compaction?: { auto?: boolean | null; keep?: { tokens?: number | null } | null; buffer?: number | null } | null
+        skills?: Array<string> | null
         commands?: {
           [x: string]: {
             template: string
-            description?: string
-            agent?: string
-            model?: string | { providerID: string; model: string; variant?: string }
-            subtask?: boolean
+            description?: string | null
+            agent?: string | null
+            model?: string | { providerID: string; model: string; variant?: string | null } | null
+            subtask?: boolean | null
           }
-        }
-        instructions?: Array<string>
+        } | null
+        instructions?: Array<string> | null
         references?: {
           [x: string]:
             | string
-            | { repository: string; branch?: string; description?: string; hidden?: boolean }
-            | { path: string; description?: string; hidden?: boolean }
-        }
-        websearch?: { provider: string }
-        plugins?: Array<string | { package: string; options?: { [x: string]: JsonValue } }>
-        warming?: boolean | { prompt?: string; interval?: string; duration?: string }
+            | { repository: string; branch?: string | null; description?: string | null; hidden?: boolean | null }
+            | { path: string; description?: string | null; hidden?: boolean | null }
+        } | null
+        websearch?: { provider: string } | null
+        plugins?: Array<string | { package: string; options?: { [x: string]: JsonValue } | null }> | null
+        warming?: boolean | { prompt?: string | null; interval?: string | null; duration?: string | null } | null
         providers?: {
           [x: string]: {
-            name?: string
-            env?: Array<string>
-            package?: string
-            settings?: { [x: string]: JsonValue }
-            headers?: { [x: string]: string }
-            body?: { [x: string]: JsonValue }
+            name?: string | null
+            env?: Array<string> | null
+            package?: string | null
+            settings?: { [x: string]: JsonValue } | null
+            headers?: { [x: string]: string } | null
+            body?: { [x: string]: JsonValue } | null
             models?: {
               [x: string]: {
-                modelID?: string
-                family?: string
-                name?: string
-                compatibility?: ModelCompatibility
-                package?: string
-                settings?: { [x: string]: JsonValue }
-                headers?: { [x: string]: string }
-                body?: { [x: string]: JsonValue }
-                capabilities?: ModelCapabilities
+                modelID?: string | null
+                family?: string | null
+                name?: string | null
+                compatibility?: ModelCompatibility | null
+                package?: string | null
+                settings?: { [x: string]: JsonValue } | null
+                headers?: { [x: string]: string } | null
+                body?: { [x: string]: JsonValue } | null
+                capabilities?: ModelCapabilities | null
                 variants?: Array<{
                   id: string
-                  settings?: { [x: string]: JsonValue }
-                  headers?: { [x: string]: string }
-                  body?: { [x: string]: JsonValue }
-                }>
+                  settings?: { [x: string]: JsonValue } | null
+                  headers?: { [x: string]: string } | null
+                  body?: { [x: string]: JsonValue } | null
+                }> | null
                 cost?:
                   | {
-                      tier?: { type: "context"; size: number }
+                      tier?: { type: "context"; size: number } | null
                       input: MoneyUSDPerMillionTokens
                       output: MoneyUSDPerMillionTokens
-                      cache?: { read?: MoneyUSDPerMillionTokens; write?: MoneyUSDPerMillionTokens }
+                      cache?: { read?: MoneyUSDPerMillionTokens | null; write?: MoneyUSDPerMillionTokens | null } | null
                     }
                   | Array<{
-                      tier?: { type: "context"; size: number }
+                      tier?: { type: "context"; size: number } | null
                       input: MoneyUSDPerMillionTokens
                       output: MoneyUSDPerMillionTokens
-                      cache?: { read?: MoneyUSDPerMillionTokens; write?: MoneyUSDPerMillionTokens }
+                      cache?: { read?: MoneyUSDPerMillionTokens | null; write?: MoneyUSDPerMillionTokens | null } | null
                     }>
-                disabled?: boolean
-                limit?: { context?: number; input?: number; output?: number }
+                  | null
+                disabled?: boolean | null
+                limit?: { context?: number | null; input?: number | null; output?: number | null } | null
               }
-            }
+            } | null
           }
-        }
+        } | null
         experimental?: {
-          subagent_depth?: number
-          policies?: Array<{ action: "provider.use"; resource: string; effect: "allow" | "deny" }>
-        }
+          subagent_depth?: number | null
+          policies?: Array<{ action: "provider.use"; resource: string; effect: "allow" | "deny" }> | null
+        } | null
       }
     }
   | { type: "directory"; path: string }
@@ -3102,8 +3123,21 @@ export type IntegrationConnectKeyInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   }["location"]
-  readonly key: { readonly key: string; readonly label?: string | undefined }["key"]
-  readonly label?: { readonly key: string; readonly label?: string | undefined }["label"]
+  readonly key: {
+    readonly key: string
+    readonly inputs?: { readonly [x: string]: string } | undefined
+    readonly label?: string | undefined
+  }["key"]
+  readonly inputs?: {
+    readonly key: string
+    readonly inputs?: { readonly [x: string]: string } | undefined
+    readonly label?: string | undefined
+  }["inputs"]
+  readonly label?: {
+    readonly key: string
+    readonly inputs?: { readonly [x: string]: string } | undefined
+    readonly label?: string | undefined
+  }["label"]
 }
 
 export type IntegrationConnectKeyOutput = void
@@ -3233,28 +3267,41 @@ export type McpAddInput = {
       | {
           readonly type: "local"
           readonly command: ReadonlyArray<string>
-          readonly cwd?: string
-          readonly environment?: { readonly [x: string]: string }
-          readonly disabled?: boolean
-          readonly codemode?: boolean
-          readonly timeout?: { readonly startup?: number; readonly catalog?: number; readonly execution?: number }
+          readonly cwd?: string | undefined
+          readonly environment?: { readonly [x: string]: string } | undefined
+          readonly disabled?: boolean | undefined
+          readonly codemode?: boolean | undefined
+          readonly timeout?:
+            | {
+                readonly startup?: number | undefined
+                readonly catalog?: number | undefined
+                readonly execution?: number | undefined
+              }
+            | undefined
         }
       | {
           readonly type: "remote"
           readonly url: string
-          readonly headers?: { readonly [x: string]: string }
+          readonly headers?: { readonly [x: string]: string } | undefined
           readonly oauth?:
             | {
-                readonly client_id?: string
-                readonly client_secret?: string
-                readonly scope?: string
-                readonly callback_port?: number
-                readonly redirect_uri?: string
+                readonly client_id?: string | undefined
+                readonly client_secret?: string | undefined
+                readonly scope?: string | undefined
+                readonly callback_port?: number | undefined
+                readonly redirect_uri?: string | undefined
               }
             | false
-          readonly disabled?: boolean
-          readonly codemode?: boolean
-          readonly timeout?: { readonly startup?: number; readonly catalog?: number; readonly execution?: number }
+            | undefined
+          readonly disabled?: boolean | undefined
+          readonly codemode?: boolean | undefined
+          readonly timeout?:
+            | {
+                readonly startup?: number | undefined
+                readonly catalog?: number | undefined
+                readonly execution?: number | undefined
+              }
+            | undefined
         }
   }["config"]
 }

packages/core/src/integration.ts

@@ -175,6 +175,8 @@ export interface Interface extends State.Transformable<Draft> {
       readonly integrationID: ID
       /** Secret entered by the user. */
       readonly key: string
+      /** Provider-specific values collected before the secret. */
+      readonly inputs?: Inputs
       /** User-facing label for the stored credential. */
       readonly label?: string
     }) => Effect.Effect<void, AuthorizationError>
@@ -704,7 +706,11 @@ const layer = Layer.effect(
           yield* credentials.create({
             integrationID: input.integrationID,
             label: input.label,
-            value: Credential.Key.make({ type: "key", key: input.key }),
+            value: Credential.Key.make({
+              type: "key",
+              key: input.key,
+              metadata: input.inputs && Object.keys(input.inputs).length > 0 ? input.inputs : undefined,
+            }),
           })
           yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: input.integrationID })
           yield* bus.publish(Integration.Event.Updated, {})

packages/core/src/plugin/host.ts

@@ -192,6 +192,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
           integration.connection.key({
             integrationID: Integration.ID.make(input.integrationID),
             key: input.key,
+            inputs: input.inputs,
             label: input.label,
           }),
       },
@@ -398,7 +399,7 @@ function methodImplementation(input: IntegrationMethodRegistration): Integration
   }
   return {
     integrationID: Integration.ID.make(input.integrationID),
-    method: { type: "key", label: input.method.label },
+    method: { type: "key", label: input.method.label, prompts: input.method.prompts },
   }
 }
 

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

@@ -6,6 +6,37 @@ import { define } from "@opencode-ai/plugin/effect/plugin"
 export const CloudflareAIGatewayPlugin = define({
   id: "opencode.provider.cloudflare-ai-gateway",
   effect: Effect.fn(function* (ctx) {
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update({
+        integrationID: "cloudflare-ai-gateway",
+        method: {
+          type: "key",
+          label: "Gateway API token",
+          prompts: [
+            ...(process.env.CLOUDFLARE_ACCOUNT_ID
+              ? []
+              : [
+                  {
+                    type: "text" as const,
+                    key: "accountId",
+                    message: "Enter your Cloudflare Account ID",
+                    placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+                  },
+                ]),
+            ...(process.env.CLOUDFLARE_GATEWAY_ID
+              ? []
+              : [
+                  {
+                    type: "text" as const,
+                    key: "gatewayId",
+                    message: "Enter your Cloudflare AI Gateway ID",
+                    placeholder: "e.g. my-gateway",
+                  },
+                ]),
+          ],
+        },
+      })
+    })
     yield* ctx.aisdk.hook(
       "sdk",
       Effect.fn(function* (evt) {

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

@@ -9,6 +9,25 @@ const providerID = Provider.ID.make("cloudflare-workers-ai")
 export const CloudflareWorkersAIPlugin = define({
   id: "opencode.provider.cloudflare-workers-ai",
   effect: Effect.fn(function* (ctx) {
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "API key",
+          prompts: process.env.CLOUDFLARE_ACCOUNT_ID
+            ? undefined
+            : [
+                {
+                  type: "text",
+                  key: "accountId",
+                  message: "Enter your Cloudflare Account ID",
+                  placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+                },
+              ],
+        },
+      })
+    })
     yield* ctx.catalog.transform((evt) => {
       const item = evt.provider.get(providerID)
       if (!item) return

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

@@ -221,7 +221,7 @@ export const OpenAIPlugin = define({
           }
           draft.cost = []
           // Match Codex CLI so context consumption and subscription usage stay consistent between clients.
-          draft.limit = { ...draft.limit, context: 400_000, input: 272_000 }
+          draft.limit = { ...draft.limit, context: 272_000, input: 272_000 }
         })
       }
     })

packages/core/src/session/compaction.ts

@@ -20,7 +20,7 @@ import type { Info } from "../model"
 import { SessionUsage } from "./usage"
 
 const DEFAULT_BUFFER = 20_000
-const DEFAULT_KEEP_TOKENS = 15_000
+const DEFAULT_KEEP_TOKENS = 8_000
 const OUTPUT_TOKEN_MAX = 32_000
 const TOOL_OUTPUT_MAX_CHARS = 2_000
 const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.

packages/core/src/v1/config/migrate.ts

@@ -1,8 +1,5 @@
 export * as ConfigMigrateV1 from "./migrate"
 
-import { Info } from "@opencode-ai/schema/config"
-import { ConfigAgent } from "@opencode-ai/schema/config/agent"
-import { Schema } from "effect"
 import { ConfigV1 } from "./config"
 import { ConfigAgentV1 } from "./agent"
 import { ConfigCommandV1 } from "./command"
@@ -13,12 +10,6 @@ import { ConfigProviderOptionsV1 } from "./provider-options"
 import { Provider } from "../../provider"
 import { Model } from "../../model"
 
-const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
-const decodeInfo = Schema.decodeUnknownSync(Schema.fromJsonString(Info), decodeOptions)
-const encodeInfo = Schema.encodeSync(Info)
-const decodeAgent = Schema.decodeUnknownSync(Schema.fromJsonString(ConfigAgent.Info), decodeOptions)
-const encodeAgent = Schema.encodeSync(ConfigAgent.Info)
-
 const keys = new Set([
   "logLevel",
   "server",
@@ -57,46 +48,42 @@ export function isV1(input: unknown) {
 }
 
 export function migrate(info: typeof ConfigV1.Info.Type) {
-  return encodeInfo(
-    decodeInfo(
-      JSON.stringify({
-        $schema: info.$schema,
-        shell: info.shell,
-        model: modelSelection(info.model),
-        default_agent: info.default_agent,
-        autoupdate: info.autoupdate,
-        share: info.share ?? (info.autoshare ? "auto" : undefined),
-        enterprise: info.enterprise,
-        username: info.username,
-        permissions: permissions(info.permission, info.tools),
-        agents: agents(info),
-        snapshots: info.snapshot,
-        watcher: info.watcher,
-        formatter: info.formatter,
-        lsp: info.lsp,
-        media: info.attachment,
-        tool_output: info.tool_output,
-        mcp: mcp(info),
-        compaction: info.compaction && {
-          auto: info.compaction.auto,
-          prune: info.compaction.prune,
-          keep: {
-            tokens: info.compaction.preserve_recent_tokens,
-          },
-          buffer: info.compaction.reserved,
-        },
-        skills: info.skills && [...(info.skills.paths ?? []), ...(info.skills.urls ?? [])],
-        commands: commands(info.command),
-        instructions: info.instructions,
-        references: info.references ?? info.reference,
-        experimental: experimental(info),
-        plugins: info.plugin?.map((plugin) =>
-          typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] },
-        ),
-        providers: providers(info.provider),
-      }),
+  return {
+    $schema: info.$schema,
+    shell: info.shell,
+    model: modelSelection(info.model),
+    default_agent: info.default_agent,
+    autoupdate: info.autoupdate,
+    share: info.share ?? (info.autoshare ? "auto" : undefined),
+    enterprise: info.enterprise,
+    username: info.username,
+    permissions: permissions(info.permission, info.tools),
+    agents: agents(info),
+    snapshots: info.snapshot,
+    watcher: info.watcher,
+    formatter: info.formatter,
+    lsp: info.lsp,
+    media: info.attachment,
+    tool_output: info.tool_output,
+    mcp: mcp(info),
+    compaction: info.compaction && {
+      auto: info.compaction.auto,
+      prune: info.compaction.prune,
+      keep: {
+        tokens: info.compaction.preserve_recent_tokens,
+      },
+      buffer: info.compaction.reserved,
+    },
+    skills: info.skills && [...(info.skills.paths ?? []), ...(info.skills.urls ?? [])],
+    commands: commands(info.command),
+    instructions: info.instructions,
+    references: info.references ?? info.reference,
+    experimental: experimental(info),
+    plugins: info.plugin?.map((plugin) =>
+      typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] },
     ),
-  )
+    providers: providers(info.provider),
+  }
 }
 
 function experimental(info: typeof ConfigV1.Info.Type) {
@@ -167,22 +154,18 @@ export function migrateAgent(info: ConfigAgentV1.Info) {
     ...(info.temperature === undefined ? {} : { temperature: info.temperature }),
     ...(info.top_p === undefined ? {} : { top_p: info.top_p }),
   }
-  return encodeAgent(
-    decodeAgent(
-      JSON.stringify({
-        model: modelSelection(info.model, info.variant),
-        request: Object.keys(body).length ? { body } : undefined,
-        system: info.prompt,
-        description: info.description,
-        mode: info.mode,
-        hidden: info.hidden,
-        color: info.color === undefined ? undefined : info.color.startsWith("#") ? info.color : "#aaaaaa",
-        steps: info.steps,
-        disabled: info.disable,
-        permissions: permissions(info.permission),
-      }),
-    ),
-  )
+  return {
+    model: modelSelection(info.model, info.variant),
+    request: Object.keys(body).length ? { body } : undefined,
+    system: info.prompt,
+    description: info.description,
+    mode: info.mode,
+    hidden: info.hidden,
+    color: info.color === undefined ? undefined : info.color.startsWith("#") ? info.color : "#aaaaaa",
+    steps: info.steps,
+    disabled: info.disable,
+    permissions: permissions(info.permission),
+  }
 }
 
 function commands(info?: Readonly<Record<string, ConfigCommandV1.Info>>) {

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

@@ -516,12 +516,12 @@ describe("Config", () => {
       })
       expect(migrated.providers?.["azure-cognitive-services"]).toBeUndefined()
       expect(migrated.providers?.["google-vertex"]).toMatchObject({
+        package: undefined,
         settings: { project: "test-project", location: "us-central1" },
         models: {
           "claude-sonnet": { package: Provider.aisdk("@ai-sdk/google-vertex/anthropic") },
         },
       })
-      expect(migrated.providers?.["google-vertex"]).not.toHaveProperty("package")
       expect(migrated.providers?.["google-vertex-anthropic"]).toBeUndefined()
     }),
   )

packages/core/test/integration.test.ts

@@ -151,6 +151,7 @@ describe("Integration", () => {
       yield* integrations.connection.key({
         integrationID,
         key: "secret",
+        inputs: { accountId: "account" },
         label: "Work",
       })
 
@@ -158,7 +159,7 @@ describe("Integration", () => {
         expect.objectContaining({
           integrationID,
           label: "Work",
-          value: Credential.Key.make({ type: "key", key: "secret" }),
+          value: Credential.Key.make({ type: "key", key: "secret", metadata: { accountId: "account" } }),
         }),
       ])
       expect((yield* Fiber.join(updated)).length).toBe(1)

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

@@ -151,9 +151,6 @@ describe("ModelResolver", () => {
           http: { body: { custom_extension: { enabled: true } } },
         },
       })
-      const prepared = yield* compileRequest(LLM.request({ model: resolved, prompt: "Hello" }))
-      expect(prepared.body.max_output_tokens).toBeUndefined()
-      expect(JSON.stringify(prepared.body)).not.toContain("max_output_tokens")
     }),
   )
 

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

@@ -6,6 +6,7 @@ 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"
 
@@ -102,6 +103,39 @@ mock.module("ai-gateway-provider/providers/unified", () => ({
 }))
 
 describe("CloudflareAIGatewayPlugin", () => {
+  it.effect("prompts for account and gateway IDs when the environment does not provide them", () =>
+    withEnv(
+      cloudflareEnv({
+        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",
+            prompts: [
+              {
+                type: "text",
+                key: "accountId",
+                message: "Enter your Cloudflare Account ID",
+                placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+              },
+              {
+                type: "text",
+                key: "gatewayId",
+                message: "Enter your Cloudflare AI Gateway ID",
+                placeholder: "e.g. my-gateway",
+              },
+            ],
+          })
+        }),
+    ),
+  )
+
   it.effect("requires account, gateway, and token before creating the unified SDK", () =>
     withEnv(
       {

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

@@ -7,6 +7,7 @@ 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"
@@ -79,6 +80,28 @@ function cloudflareHeaders(sdk: unknown, modelID = "@cf/model") {
 }
 
 describe("CloudflareWorkersAIPlugin", () => {
+  it.effect("prompts for the account ID when the environment does not provide it", () =>
+    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",
+          prompts: [
+            {
+              type: "text",
+              key: "accountId",
+              message: "Enter your Cloudflare Account ID",
+              placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+            },
+          ],
+        })
+      }),
+    ),
+  )
+
   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* () {

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

@@ -126,7 +126,7 @@ describe("OpenAIPlugin", () => {
       const eligible = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
       expect(eligible.package).toBe("@opencode-ai/ai/providers/openai")
       expect(eligible.cost).toEqual([])
-      expect(eligible.limit).toEqual({ context: 400_000, input: 272_000, output: 128_000 })
+      expect(eligible.limit).toEqual({ context: 272_000, input: 272_000, output: 128_000 })
       expect(eligible.enabled).toBe(true)
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5-pro"))).enabled).toBe(
         false,
@@ -135,14 +135,14 @@ describe("OpenAIPlugin", () => {
         false,
       )
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.4"))).limit).toEqual({
-        context: 400_000,
+        context: 272_000,
         input: 272_000,
         output: 64_000,
       })
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.6"))).enabled).toBe(false)
       const gpt56 = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.6-sol")))
       expect(gpt56.enabled).toBe(true)
-      expect(gpt56.limit).toEqual({ context: 400_000, input: 272_000, output: 128_000 })
+      expect(gpt56.limit).toEqual({ context: 272_000, input: 272_000, output: 128_000 })
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(false)
     }),
   )

packages/protocol/src/groups/integration.ts

@@ -59,6 +59,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
       query: LocationQuery,
       payload: Schema.Struct({
         key: Schema.String,
+        inputs: Schema.optional(Inputs),
         label: Schema.optional(Schema.String),
       }),
       success: HttpApiSchema.NoContent,

packages/schema/src/config.ts

@@ -3,7 +3,7 @@ export * as Config from "./config.js"
 import { Schema } from "effect"
 import { ephemeral, inventory } from "./event.js"
 import { Permission } from "./permission.js"
-import { AbsolutePath, optional } from "./schema.js"
+import { AbsolutePath } from "./schema.js"
 import { ConfigAgent } from "./config/agent.js"
 import { ConfigMedia } from "./config/media.js"
 import { ConfigCompaction } from "./config/compaction.js"
@@ -22,94 +22,94 @@ import { ConfigWatcher } from "./config/watcher.js"
 import { ConfigWarming } from "./config/warming.js"
 
 export class Info extends Schema.Class<Info>("Config.Info")({
-  $schema: optional(Schema.String).annotate({
+  $schema: Schema.optional(Schema.String).annotate({
     description: "JSON schema reference for configuration validation",
   }),
-  shell: Schema.String.pipe(optional).annotate({
+  shell: Schema.String.pipe(Schema.optional).annotate({
     description: "Default shell to use for terminal and shell tool execution",
   }),
-  model: ConfigModel.Selection.pipe(optional).annotate({
+  model: ConfigModel.Selection.pipe(Schema.optional).annotate({
     description: "Default model to use when no session or agent model is selected",
   }),
-  default_agent: Schema.String.pipe(optional).annotate({
+  default_agent: Schema.String.pipe(Schema.optional).annotate({
     description: "Default primary agent to use when no session agent is selected",
   }),
   autoupdate: Schema.Union([Schema.Boolean, Schema.Literal("notify")])
-    .pipe(optional)
+    .pipe(Schema.optional)
     .annotate({
       description: "Automatically update or notify when a new version is available",
     }),
-  share: Schema.Literals(["manual", "auto", "disabled"]).pipe(optional).annotate({
+  share: Schema.Literals(["manual", "auto", "disabled"]).pipe(Schema.optional).annotate({
     description: "Control whether sessions may be shared manually, automatically, or not at all",
   }),
   enterprise: Schema.Struct({
-    url: Schema.String.pipe(optional),
+    url: Schema.String.pipe(Schema.optional),
   })
-    .pipe(optional)
+    .pipe(Schema.optional)
     .annotate({
       description: "Enterprise sharing service configuration",
     }),
-  username: Schema.String.pipe(optional).annotate({
+  username: Schema.String.pipe(Schema.optional).annotate({
     description: "Username displayed in conversations and used for telemetry identity",
   }),
-  permissions: Permission.Ruleset.pipe(optional).annotate({
+  permissions: Permission.Ruleset.pipe(Schema.optional).annotate({
     description: "Ordered tool permission rules applied to agent tool use",
   }),
-  agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(optional).annotate({
+  agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(Schema.optional).annotate({
     description: "Named built-in agent overrides and custom agent definitions",
   }),
-  snapshots: Schema.Boolean.pipe(optional).annotate({
+  snapshots: Schema.Boolean.pipe(Schema.optional).annotate({
     description: "Enable snapshots used for undo and revert behavior",
   }),
-  watcher: ConfigWatcher.Info.pipe(optional).annotate({
+  watcher: ConfigWatcher.Info.pipe(Schema.optional).annotate({
     description: "Filesystem watcher configuration",
   }),
-  formatter: ConfigFormatter.Info.pipe(optional).annotate({
+  formatter: ConfigFormatter.Info.pipe(Schema.optional).annotate({
     description: "Enable built-in formatters or configure formatter overrides",
   }),
-  lsp: ConfigLSP.Info.pipe(optional).annotate({
+  lsp: ConfigLSP.Info.pipe(Schema.optional).annotate({
     description: "Enable built-in language servers or configure server overrides",
   }),
-  media: ConfigMedia.Info.pipe(optional).annotate({
+  media: ConfigMedia.Info.pipe(Schema.optional).annotate({
     description: "Media processing configuration",
   }),
-  tool_output: ConfigToolOutput.Info.pipe(optional).annotate({
+  tool_output: ConfigToolOutput.Info.pipe(Schema.optional).annotate({
     description: "Tool output truncation thresholds",
   }),
-  mcp: ConfigMCP.Info.pipe(optional).annotate({
+  mcp: ConfigMCP.Info.pipe(Schema.optional).annotate({
     description: "MCP server configuration",
   }),
-  compaction: ConfigCompaction.Info.pipe(optional).annotate({
+  compaction: ConfigCompaction.Info.pipe(Schema.optional).annotate({
     description: "Conversation compaction behavior",
   }),
-  skills: Schema.String.pipe(Schema.Array, optional).annotate({
+  skills: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
     description: "Additional paths or URLs to discover skills from",
   }),
-  commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(optional).annotate({
+  commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(Schema.optional).annotate({
     description: "Named slash command definitions",
   }),
-  instructions: Schema.String.pipe(Schema.Array, optional).annotate({
+  instructions: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
     description: "Additional paths or URLs supplying ambient instructions",
   }),
-  references: ConfigReference.Info.pipe(optional).annotate({
+  references: ConfigReference.Info.pipe(Schema.optional).annotate({
     description: "Named local directories or Git repositories available as external context",
   }),
-  websearch: ConfigWebSearch.Info.pipe(optional).annotate({
+  websearch: ConfigWebSearch.Info.pipe(Schema.optional).annotate({
     description: "Web search provider selection",
   }),
-  plugins: ConfigPlugin.Plugins.pipe(optional).annotate({
+  plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
     description: "Ordered plugin enablement directives and external package declarations",
   }),
-  warming: ConfigWarming.Warming.pipe(optional).annotate({
+  warming: ConfigWarming.Warming.pipe(Schema.optional).annotate({
     description: "Keep recently active sessions warm with transient model requests (default: false)",
   }),
-  providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(optional),
-  experimental: ConfigExperimental.Info.pipe(optional),
+  providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(Schema.optional),
+  experimental: ConfigExperimental.Info.pipe(Schema.optional),
 }) {}
 
 export class Document extends Schema.Class<Document>("Config.Document")({
   type: Schema.Literal("document"),
-  path: Schema.String.pipe(optional),
+  path: Schema.String.pipe(Schema.optional),
   info: Info,
 }) {}
 

packages/schema/src/config/agent.ts

@@ -2,21 +2,21 @@ export * as ConfigAgent from "./agent.js"
 
 import { Schema } from "effect"
 import { Permission } from "../permission.js"
-import { optional, PositiveInt } from "../schema.js"
+import { PositiveInt } from "../schema.js"
 import { ConfigModel } from "./model.js"
 import { ConfigProvider } from "./provider.js"
 
 export const Color = Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/))
 
 export class Info extends Schema.Class<Info>("Config.Agent")({
-  model: ConfigModel.Selection.pipe(optional),
-  request: ConfigProvider.Request.pipe(optional),
-  system: Schema.String.pipe(optional),
-  description: Schema.String.pipe(optional),
-  mode: Schema.Literals(["subagent", "primary", "all"]).pipe(optional),
-  hidden: Schema.Boolean.pipe(optional),
-  color: Color.pipe(optional),
-  steps: PositiveInt.pipe(optional),
-  disabled: Schema.Boolean.pipe(optional),
-  permissions: Permission.Ruleset.pipe(optional),
+  model: ConfigModel.Selection.pipe(Schema.optional),
+  request: ConfigProvider.Request.pipe(Schema.optional),
+  system: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  mode: Schema.Literals(["subagent", "primary", "all"]).pipe(Schema.optional),
+  hidden: Schema.Boolean.pipe(Schema.optional),
+  color: Color.pipe(Schema.optional),
+  steps: PositiveInt.pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  permissions: Permission.Ruleset.pipe(Schema.optional),
 }) {}

packages/schema/src/config/command.ts

@@ -1,13 +1,12 @@
 export * as ConfigCommand from "./command.js"
 
 import { Schema } from "effect"
-import { optional } from "../schema.js"
 import { ConfigModel } from "./model.js"
 
 export class Info extends Schema.Class<Info>("Config.Command")({
   template: Schema.String,
-  description: Schema.String.pipe(optional),
-  agent: Schema.String.pipe(optional),
-  model: ConfigModel.Selection.pipe(optional),
-  subtask: Schema.Boolean.pipe(optional),
+  description: Schema.String.pipe(Schema.optional),
+  agent: Schema.String.pipe(Schema.optional),
+  model: ConfigModel.Selection.pipe(Schema.optional),
+  subtask: Schema.Boolean.pipe(Schema.optional),
 }) {}

packages/schema/src/config/compaction.ts

@@ -1,14 +1,14 @@
 export * as ConfigCompaction from "./compaction.js"
 
 import { Schema } from "effect"
-import { NonNegativeInt, optional } from "../schema.js"
+import { NonNegativeInt } from "../schema.js"
 
 export class Keep extends Schema.Class<Keep>("Config.Compaction.Keep")({
-  tokens: NonNegativeInt.pipe(optional),
+  tokens: NonNegativeInt.pipe(Schema.optional),
 }) {}
 
 export class Info extends Schema.Class<Info>("Config.Compaction")({
-  auto: Schema.Boolean.pipe(optional),
-  keep: Keep.pipe(optional),
-  buffer: NonNegativeInt.pipe(optional),
+  auto: Schema.Boolean.pipe(Schema.optional),
+  keep: Keep.pipe(Schema.optional),
+  buffer: NonNegativeInt.pipe(Schema.optional),
 }) {}

packages/schema/src/config/experimental.ts

@@ -1,14 +1,14 @@
 export * as ConfigExperimental from "./experimental.js"
 
 import { Schema } from "effect"
-import { NonNegativeInt, optional } from "../schema.js"
+import { NonNegativeInt } from "../schema.js"
 import { ConfigPolicy } from "./policy.js"
 
 export class Info extends Schema.Class<Info>("ConfigExperimental.Info")({
-  subagent_depth: NonNegativeInt.pipe(optional).annotate({
+  subagent_depth: NonNegativeInt.pipe(Schema.optional).annotate({
     description: "Maximum subagent nesting depth. Defaults to 1.",
   }),
-  policies: ConfigPolicy.Info.pipe(Schema.Array, optional).annotate({
+  policies: ConfigPolicy.Info.pipe(Schema.Array, Schema.optional).annotate({
     description: "Ordered policies controlling access to configured resources",
   }),
 }) {}

packages/schema/src/config/formatter.ts

@@ -1,13 +1,12 @@
 export * as ConfigFormatter from "./formatter.js"
 
 import { Schema } from "effect"
-import { optional } from "../schema.js"
 
 export class Entry extends Schema.Class<Entry>("Config.Formatter.Entry")({
-  disabled: Schema.Boolean.pipe(optional),
-  command: Schema.String.pipe(Schema.Array, optional),
-  environment: Schema.Record(Schema.String, Schema.String).pipe(optional),
-  extensions: Schema.String.pipe(Schema.Array, optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  command: Schema.String.pipe(Schema.Array, Schema.optional),
+  environment: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  extensions: Schema.String.pipe(Schema.Array, Schema.optional),
 }) {}
 
 export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)])

packages/schema/src/config/lsp.ts

@@ -1,7 +1,6 @@
 export * as ConfigLSP from "./lsp.js"
 
 import { Schema } from "effect"
-import { optional } from "../schema.js"
 
 export const Disabled = Schema.Struct({
   disabled: Schema.Literal(true),
@@ -9,10 +8,10 @@ export const Disabled = Schema.Struct({
 
 export class Server extends Schema.Class<Server>("Config.LSP.Server")({
   command: Schema.String.pipe(Schema.Array),
-  extensions: Schema.String.pipe(Schema.Array, optional),
-  disabled: Schema.Boolean.pipe(optional),
-  env: Schema.Record(Schema.String, Schema.String).pipe(optional),
-  initialization: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+  extensions: Schema.String.pipe(Schema.Array, Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  env: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  initialization: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
 }) {}
 
 export const Entry = Schema.Union([Disabled, Server])

packages/schema/src/config/mcp.ts

@@ -2,7 +2,6 @@ export * as ConfigMCP from "./mcp.js"
 
 import { Schema } from "effect"
 import { Mcp } from "../mcp.js"
-import { optional } from "../schema.js"
 
 export const Timeout = Mcp.TimeoutConfig
 export type Timeout = Mcp.TimeoutConfig
@@ -15,6 +14,6 @@ export type Remote = Mcp.RemoteConfig
 export const Server = Mcp.ServerConfig
 
 export class Info extends Schema.Class<Info>("Config.MCP")({
-  timeout: Timeout.pipe(optional),
-  servers: Schema.Record(Schema.String, Server).pipe(optional),
+  timeout: Timeout.pipe(Schema.optional),
+  servers: Schema.Record(Schema.String, Server).pipe(Schema.optional),
 }) {}

packages/schema/src/config/media.ts

@@ -1,15 +1,15 @@
 export * as ConfigMedia from "./media.js"
 
 import { Schema } from "effect"
-import { optional, PositiveInt } from "../schema.js"
+import { PositiveInt } from "../schema.js"
 
 export class Image extends Schema.Class<Image>("Config.Media.Image")({
-  auto_resize: Schema.Boolean.pipe(optional),
-  max_width: PositiveInt.pipe(optional),
-  max_height: PositiveInt.pipe(optional),
-  max_base64_bytes: PositiveInt.pipe(optional),
+  auto_resize: Schema.Boolean.pipe(Schema.optional),
+  max_width: PositiveInt.pipe(Schema.optional),
+  max_height: PositiveInt.pipe(Schema.optional),
+  max_base64_bytes: PositiveInt.pipe(Schema.optional),
 }) {}
 
 export class Info extends Schema.Class<Info>("Config.Media")({
-  image: Image.pipe(optional),
+  image: Image.pipe(Schema.optional),
 }) {}

packages/schema/src/config/model.ts

@@ -3,7 +3,6 @@ export * as ConfigModel from "./model.js"
 import { Schema, SchemaGetter } from "effect"
 import { Model } from "../model.js"
 import { Provider } from "../provider.js"
-import { optional } from "../schema.js"
 
 const ProviderID = Provider.ID.check(Schema.isPattern(/^[^/#]+$/))
 const ModelID = Model.ID.check(Schema.isPattern(/^[^#]+$/))
@@ -12,7 +11,7 @@ const VariantID = Model.VariantID.check(Schema.isPattern(/^[^#]+$/))
 const Explicit = Schema.Struct({
   providerID: ProviderID,
   model: ModelID,
-  variant: VariantID.pipe(optional),
+  variant: VariantID.pipe(Schema.optional),
 })
 
 const Short = Schema.String.check(Schema.isPattern(/^[^/#]+\/[^#]+(?:#[^#]+)?$/))

packages/schema/src/config/plugin.ts

@@ -1,11 +1,10 @@
 export * as ConfigPlugin from "./plugin.js"
 
 import { Schema } from "effect"
-import { optional } from "../schema.js"
 
 export class Entry extends Schema.Class<Entry>("Config.Plugin.Entry")({
   package: Schema.String,
-  options: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+  options: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
 }) {}
 
 export const Plugin = Schema.Union([Schema.String, Entry])

packages/schema/src/config/provider.ts

@@ -3,14 +3,13 @@ export * as ConfigProvider from "./provider.js"
 import { Schema } from "effect"
 import { Money } from "../money.js"
 import { Capabilities, Compatibility, Family, ID, VariantID } from "../model.js"
-import { optional } from "../schema.js"
 
 const JsonRecord = Schema.Record(Schema.String, Schema.Json)
 
 export const Overlays = {
-  settings: JsonRecord.pipe(optional),
-  headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
-  body: JsonRecord.pipe(optional),
+  settings: JsonRecord.pipe(Schema.optional),
+  headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  body: JsonRecord.pipe(Schema.optional),
 }
 
 export class Request extends Schema.Class<Request>("Config.Provider.Request")({
@@ -19,47 +18,47 @@ export class Request extends Schema.Class<Request>("Config.Provider.Request")({
 }) {}
 
 class Cache extends Schema.Class<Cache>("Config.Model.Cost.Cache")({
-  read: Money.USDPerMillionTokens.pipe(optional),
-  write: Money.USDPerMillionTokens.pipe(optional),
+  read: Money.USDPerMillionTokens.pipe(Schema.optional),
+  write: Money.USDPerMillionTokens.pipe(Schema.optional),
 }) {}
 
 class Cost extends Schema.Class<Cost>("Config.Model.Cost")({
   tier: Schema.Struct({
     type: Schema.Literal("context"),
     size: Schema.Int,
-  }).pipe(optional),
+  }).pipe(Schema.optional),
   input: Money.USDPerMillionTokens,
   output: Money.USDPerMillionTokens,
-  cache: Cache.pipe(optional),
+  cache: Cache.pipe(Schema.optional),
 }) {}
 
 class Limit extends Schema.Class<Limit>("Config.Model.Limit")({
-  context: Schema.Int.pipe(optional),
-  input: Schema.Int.pipe(optional),
-  output: Schema.Int.pipe(optional),
+  context: Schema.Int.pipe(Schema.optional),
+  input: Schema.Int.pipe(Schema.optional),
+  output: Schema.Int.pipe(Schema.optional),
 }) {}
 
 class Model extends Schema.Class<Model>("Config.Model")({
-  modelID: ID.pipe(optional),
-  family: Family.pipe(optional),
-  name: Schema.String.pipe(optional),
-  compatibility: Compatibility.pipe(optional),
-  package: Schema.String.pipe(optional),
+  modelID: ID.pipe(Schema.optional),
+  family: Family.pipe(Schema.optional),
+  name: Schema.String.pipe(Schema.optional),
+  compatibility: Compatibility.pipe(Schema.optional),
+  package: Schema.String.pipe(Schema.optional),
   ...Overlays,
-  capabilities: Capabilities.pipe(optional),
+  capabilities: Capabilities.pipe(Schema.optional),
   variants: Schema.Struct({
     id: VariantID,
     ...Overlays,
-  }).pipe(Schema.Array, optional),
-  cost: Schema.Union([Cost, Cost.pipe(Schema.Array)]).pipe(optional),
-  disabled: Schema.Boolean.pipe(optional),
-  limit: Limit.pipe(optional),
+  }).pipe(Schema.Array, Schema.optional),
+  cost: Schema.Union([Cost, Cost.pipe(Schema.Array)]).pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  limit: Limit.pipe(Schema.optional),
 }) {}
 
 export class Info extends Schema.Class<Info>("Config.Provider")({
-  name: Schema.String.pipe(optional),
-  env: Schema.String.pipe(Schema.Array, optional),
-  package: Schema.String.pipe(optional),
+  name: Schema.String.pipe(Schema.optional),
+  env: Schema.String.pipe(Schema.Array, Schema.optional),
+  package: Schema.String.pipe(Schema.optional),
   ...Overlays,
-  models: Schema.Record(Schema.String, Model).pipe(optional),
+  models: Schema.Record(Schema.String, Model).pipe(Schema.optional),
 }) {}

packages/schema/src/config/reference.ts

@@ -1,19 +1,18 @@
 export * as ConfigReference from "./reference.js"
 
 import { Schema } from "effect"
-import { optional } from "../schema.js"
 
 export class Git extends Schema.Class<Git>("Config.Reference.Git")({
   repository: Schema.String,
-  branch: Schema.String.pipe(optional),
-  description: Schema.String.pipe(optional),
-  hidden: Schema.Boolean.pipe(optional),
+  branch: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  hidden: Schema.Boolean.pipe(Schema.optional),
 }) {}
 
 export class Local extends Schema.Class<Local>("Config.Reference.Local")({
   path: Schema.String,
-  description: Schema.String.pipe(optional),
-  hidden: Schema.Boolean.pipe(optional),
+  description: Schema.String.pipe(Schema.optional),
+  hidden: Schema.Boolean.pipe(Schema.optional),
 }) {}
 
 export const Entry = Schema.Union([Schema.String, Git, Local])

packages/schema/src/config/tool-output.ts

@@ -1,9 +1,9 @@
 export * as ConfigToolOutput from "./tool-output.js"
 
 import { Schema } from "effect"
-import { optional, PositiveInt } from "../schema.js"
+import { PositiveInt } from "../schema.js"
 
 export class Info extends Schema.Class<Info>("Config.ToolOutput")({
-  max_lines: PositiveInt.pipe(optional),
-  max_bytes: PositiveInt.pipe(optional),
+  max_lines: PositiveInt.pipe(Schema.optional),
+  max_bytes: PositiveInt.pipe(Schema.optional),
 }) {}

packages/schema/src/config/warming.ts

@@ -1,16 +1,15 @@
 export * as ConfigWarming from "./warming.js"
 
 import { Schema } from "effect"
-import { optional } from "../schema.js"
 
 export class Info extends Schema.Class<Info>("Config.Warming")({
-  prompt: Schema.String.pipe(optional).annotate({
+  prompt: Schema.String.pipe(Schema.optional).annotate({
     description: "Prompt sent for keep-alive requests",
   }),
-  interval: Schema.DurationFromString.pipe(optional).annotate({
+  interval: Schema.DurationFromString.pipe(Schema.optional).annotate({
     description: 'Idle time between keep-alive requests (default: "4 minutes")',
   }),
-  duration: Schema.DurationFromString.pipe(optional).annotate({
+  duration: Schema.DurationFromString.pipe(Schema.optional).annotate({
     description: 'Time after the last active request to keep a session warm (default: "30 minutes")',
   }),
 }) {}

packages/schema/src/config/watcher.ts

@@ -1,8 +1,7 @@
 export * as ConfigWatcher from "./watcher.js"
 
 import { Schema } from "effect"
-import { optional } from "../schema.js"
 
 export class Info extends Schema.Class<Info>("Config.Watcher")({
-  ignore: Schema.String.pipe(Schema.Array, optional),
+  ignore: Schema.String.pipe(Schema.Array, Schema.optional),
 }) {}

packages/schema/src/integration.ts

@@ -68,6 +68,7 @@ export interface KeyMethod extends Schema.Schema.Type<typeof KeyMethod> {}
 export const KeyMethod = Schema.Struct({
   type: Schema.Literal("key"),
   label: optional(Schema.String),
+  prompts: optional(Schema.Array(Prompt)),
 }).annotate({ identifier: "Integration.KeyMethod" })
 
 export interface EnvMethod extends Schema.Schema.Type<typeof EnvMethod> {}

packages/schema/src/mcp.ts

@@ -5,13 +5,13 @@ import { optional, PositiveInt } from "./schema.js"
 import { IntegrationID } from "./integration-id.js"
 
 export class TimeoutConfig extends Schema.Class<TimeoutConfig>("Mcp.TimeoutConfig")({
-  startup: PositiveInt.pipe(optional).annotate({
+  startup: PositiveInt.pipe(Schema.optional).annotate({
     description: "Maximum time in milliseconds to establish and initialize the MCP server.",
   }),
-  catalog: PositiveInt.pipe(optional).annotate({
+  catalog: PositiveInt.pipe(Schema.optional).annotate({
     description: "Maximum time in milliseconds to wait for MCP discovery requests such as tools/list and prompts/list.",
   }),
-  execution: PositiveInt.pipe(optional).annotate({
+  execution: PositiveInt.pipe(Schema.optional).annotate({
     description: "Maximum time in milliseconds to wait for MCP tool and prompt execution.",
   }),
 }) {}
@@ -19,35 +19,35 @@ export class TimeoutConfig extends Schema.Class<TimeoutConfig>("Mcp.TimeoutConfi
 export class LocalConfig extends Schema.Class<LocalConfig>("Mcp.LocalConfig")({
   type: Schema.Literal("local"),
   command: Schema.String.pipe(Schema.Array),
-  cwd: Schema.String.pipe(optional).annotate({
+  cwd: Schema.String.pipe(Schema.optional).annotate({
     description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory.",
   }),
-  environment: Schema.Record(Schema.String, Schema.String).pipe(optional),
-  disabled: Schema.Boolean.pipe(optional),
-  codemode: Schema.Boolean.pipe(optional).annotate({
+  environment: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  codemode: Schema.Boolean.pipe(Schema.optional).annotate({
     description: "Expose this server's tools through Code Mode. Defaults to true.",
   }),
-  timeout: TimeoutConfig.pipe(optional),
+  timeout: TimeoutConfig.pipe(Schema.optional),
 }) {}
 
 export class OAuthConfig extends Schema.Class<OAuthConfig>("Mcp.OAuthConfig")({
-  client_id: Schema.String.pipe(optional),
-  client_secret: Schema.String.pipe(optional),
-  scope: Schema.String.pipe(optional),
-  callback_port: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 })).pipe(optional),
-  redirect_uri: Schema.String.pipe(optional),
+  client_id: Schema.String.pipe(Schema.optional),
+  client_secret: Schema.String.pipe(Schema.optional),
+  scope: Schema.String.pipe(Schema.optional),
+  callback_port: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 })).pipe(Schema.optional),
+  redirect_uri: Schema.String.pipe(Schema.optional),
 }) {}
 
 export class RemoteConfig extends Schema.Class<RemoteConfig>("Mcp.RemoteConfig")({
   type: Schema.Literal("remote"),
   url: Schema.String,
-  headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
-  oauth: Schema.Union([OAuthConfig, Schema.Literal(false)]).pipe(optional),
-  disabled: Schema.Boolean.pipe(optional),
-  codemode: Schema.Boolean.pipe(optional).annotate({
+  headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  oauth: Schema.Union([OAuthConfig, Schema.Literal(false)]).pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  codemode: Schema.Boolean.pipe(Schema.optional).annotate({
     description: "Expose this server's tools through Code Mode. Defaults to true.",
   }),
-  timeout: TimeoutConfig.pipe(optional),
+  timeout: TimeoutConfig.pipe(Schema.optional),
 }) {}
 
 export const ServerConfig = Schema.Union([LocalConfig, RemoteConfig]).pipe(Schema.toTaggedUnion("type"))
@@ -68,9 +68,13 @@ const Failed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.S
 const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth") }).annotate({
   identifier: "Mcp.Status.NeedsAuth",
 })
+const NeedsClientRegistration = Schema.Struct({
+  status: Schema.Literal("needs_client_registration"),
+  error: Schema.String,
+}).annotate({ identifier: "Mcp.Status.NeedsClientRegistration" })
 
 export type Status = typeof Status.Type
-export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth]).pipe(
+export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth, NeedsClientRegistration]).pipe(
   Schema.toTaggedUnion("status"),
 )
 

packages/schema/test/config.test.ts

@@ -1,10 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Schema } from "effect"
 import { Config } from "../src/config.js"
-import { ConfigAgent } from "../src/config/agent.js"
-import { ConfigMCP } from "../src/config/mcp.js"
-import { ConfigProvider } from "../src/config/provider.js"
-import { Mcp } from "../src/mcp.js"
 import { AbsolutePath } from "../src/schema.js"
 
 describe("Config.Entry", () => {
@@ -33,14 +29,7 @@ describe("Config.Entry", () => {
     expect(decoded).toEqual(entries)
     expect(decoded[0]).toBeInstanceOf(Config.Document)
     expect(decoded[1]).not.toHaveProperty("path")
-    expect(decoded.map((entry) => entry.type)).toEqual([
-      "document",
-      "document",
-      "directory",
-      "file",
-      "agents",
-      "claude",
-    ])
+    expect(decoded.map((entry) => entry.type)).toEqual(["document", "document", "directory", "file", "agents", "claude"])
     expect(decoded[0]?.type === "document" ? decoded[0].info.permissions : undefined).toEqual([
       { action: "shell", resource: "*", effect: "ask" },
       { action: "shell", resource: "git status", effect: "allow" },
@@ -50,39 +39,4 @@ describe("Config.Entry", () => {
   test("has a stable public identifier", () => {
     expect(Config.Entry.ast.annotations?.identifier).toBe("Config.Entry")
   })
-
-  test("omits undefined optional properties while encoding", () => {
-    const entry = new Config.Document({
-      type: "document",
-      path: undefined,
-      info: new Config.Info({
-        default_agent: undefined,
-        agents: { reviewer: new ConfigAgent.Info({ description: undefined }) },
-        mcp: new ConfigMCP.Info({
-          timeout: undefined,
-          servers: {
-            docs: new Mcp.RemoteConfig({
-              type: "remote",
-              url: "https://example.com/mcp",
-              headers: undefined,
-              oauth: new Mcp.OAuthConfig({ client_id: undefined }),
-            }),
-          },
-        }),
-        providers: { custom: new ConfigProvider.Info({ headers: undefined }) },
-      }),
-    })
-    const encoded = Schema.encodeSync(Config.Entry)(entry)
-    if (encoded.type !== "document") throw new Error("Expected a config document")
-
-    expect(encoded).not.toHaveProperty("path")
-    expect(encoded.info).not.toHaveProperty("default_agent")
-    expect(encoded.info.agents?.reviewer).not.toHaveProperty("description")
-    expect(encoded.info.mcp).not.toHaveProperty("timeout")
-    const docs = encoded.info.mcp?.servers?.docs
-    if (docs?.type !== "remote" || docs.oauth === false) throw new Error("Expected a remote MCP server")
-    expect(docs).not.toHaveProperty("headers")
-    expect(docs.oauth).not.toHaveProperty("client_id")
-    expect(encoded.info.providers?.custom).not.toHaveProperty("headers")
-  })
 })

packages/server/src/handlers/integration.ts

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

packages/server/test/config.test.ts

@@ -16,9 +16,7 @@ it.live("returns ordered config entries for the requested directory", () =>
         const global = path.join(tmp.path, "global")
         const project = path.join(tmp.path, "project")
         const config = path.join(project, "opencode.json")
-        yield* Effect.promise(() =>
-          Promise.all([fs.mkdir(global, { recursive: true }), fs.mkdir(project, { recursive: true })]),
-        )
+        yield* Effect.promise(() => Promise.all([fs.mkdir(global, { recursive: true }), fs.mkdir(project, { recursive: true })]))
         yield* Effect.promise(() =>
           fs.writeFile(
             config,
@@ -27,7 +25,6 @@ it.live("returns ordered config entries for the requested directory", () =>
                 { action: "shell", resource: "*", effect: "ask" },
                 { action: "shell", resource: "git status", effect: "allow" },
               ],
-              mcp: { servers: { docs: { type: "remote", url: "https://example.com/mcp" } } },
             }),
           ),
         )
@@ -45,8 +42,9 @@ it.live("returns ordered config entries for the requested directory", () =>
         const response = yield* Effect.promise(() =>
           fetch(url, { headers: { authorization: `Basic ${btoa("opencode:secret")}` } }),
         )
-        const body: unknown = yield* Effect.promise(() => response.json())
-        const entries = Schema.decodeUnknownSync(Schema.Array(Config.Entry))(body)
+        const entries = Schema.decodeUnknownSync(Schema.Array(Config.Entry))(
+          yield* Effect.promise(() => response.json()),
+        )
 
         expect(response.status).toBe(200)
         expect(Array.isArray(entries)).toBe(true)
@@ -58,21 +56,7 @@ it.live("returns ordered config entries for the requested directory", () =>
           { action: "shell", resource: "git status", effect: "allow" },
         ])
         expect(entries.some((entry) => entry.type === "file" && entry.path === config)).toBe(true)
-        if (!Array.isArray(body)) throw new Error("Expected a config entry array")
-        const raw = body.find((entry) => isRecord(entry) && entry["type"] === "document" && entry["path"] === config)
-        if (!isRecord(raw) || !isRecord(raw["info"])) throw new Error("Expected a config document")
-        expect(raw["info"]).not.toHaveProperty("default_agent")
-        expect(raw["info"]).not.toHaveProperty("model")
-        const mcp = raw["info"]["mcp"]
-        if (!isRecord(mcp) || !isRecord(mcp["servers"]) || !isRecord(mcp["servers"]["docs"]))
-          throw new Error("Expected an MCP server config")
-        expect(mcp["servers"]["docs"]).not.toHaveProperty("headers")
-        expect(mcp["servers"]["docs"]).not.toHaveProperty("oauth")
       }),
     (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
   ),
 )
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}

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

@@ -6,7 +6,6 @@ import type {
   IntegrationOauthConnectOutput,
   IntegrationOAuthMethod,
 } from "@opencode-ai/client"
-import open from "open"
 import { createMemo, createSignal, onCleanup, onMount, Show } from "solid-js"
 import { useClipboard } from "../context/clipboard"
 import { useData } from "../context/data"
@@ -181,7 +180,7 @@ function openMethod(
   onConnected?: OnIntegrationConnected,
 ) {
   if (method.type === "key") {
-    dialog.replace(() => <KeyMethod integration={integration} method={method} onConnected={onConnected} />)
+    void beginKey(integration, method, dialog, onConnected)
     return
   }
   if (method.type === "command") {
@@ -191,6 +190,19 @@ 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 inputs = method.prompts?.length ? await promptInputs(dialog, method.prompts) : {}
+  if (inputs === null) return
+  dialog.replace(() => (
+    <KeyMethod integration={integration} method={method} inputs={inputs} onConnected={onConnected} />
+  ))
+}
+
 function CommandStarting(props: {
   integration: IntegrationInfo
   method: Extract<ConnectMethod, { type: "command" }>
@@ -336,6 +348,7 @@ function CommandView(props: { title: string; output: string; message: string })
 function KeyMethod(props: {
   integration: IntegrationInfo
   method: Extract<ConnectMethod, { type: "key" }>
+  inputs: Record<string, string>
   onConnected?: OnIntegrationConnected
 }) {
   const data = useData()
@@ -356,6 +369,7 @@ function KeyMethod(props: {
             integrationID: props.integration.id,
             location: location(data),
             key,
+            inputs: props.inputs,
           })
           .then(() => connected(props.integration, data, dialog, toast, props.onConnected))
           .catch((cause) => setError(message(cause)))
@@ -446,19 +460,6 @@ function OAuthAuto(props: {
   Keymap.createLayer(() => ({
     mode: "modal",
     commands: [
-      {
-        bind: "o",
-        title: "Open authorization URL",
-        group: "Dialog",
-        run: () => {
-          open(props.attempt.url).catch(() =>
-            toast.show({
-              message: "Could not open the browser. Copy the URL and continue manually.",
-              variant: "error",
-            }),
-          )
-        },
-      },
       {
         bind: "c",
         title: "Copy authorization details",
@@ -516,7 +517,6 @@ function OAuthAuto(props: {
       instructions={props.attempt.instructions}
       message="Waiting for authorization..."
       copy
-      open
     />
   )
 }
@@ -574,14 +574,7 @@ function OAuthCode(props: {
   )
 }
 
-function OAuthView(props: {
-  title: string
-  url?: string
-  instructions?: string
-  message: string
-  copy?: boolean
-  open?: boolean
-}) {
+function OAuthView(props: { title: string; url?: string; instructions?: string; message: string; copy?: boolean }) {
   const dialog = useDialog()
   const theme = useTheme("elevated")
   return (
@@ -605,18 +598,11 @@ function OAuthView(props: {
         )}
       </Show>
       <text fg={theme.text.subdued}>{props.message}</text>
-      <box flexDirection="row" gap={2}>
-        <Show when={props.open}>
-          <text fg={theme.text.default}>
-            o <span style={{ fg: theme.text.subdued }}>open</span>
-          </text>
-        </Show>
-        <Show when={props.copy}>
-          <text fg={theme.text.default}>
-            c <span style={{ fg: theme.text.subdued }}>copy</span>
-          </text>
-        </Show>
-      </box>
+      <Show when={props.copy}>
+        <text fg={theme.text.default}>
+          c <span style={{ fg: theme.text.subdued }}>copy</span>
+        </text>
+      </Show>
     </box>
   )
 }

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

@@ -15,7 +15,7 @@ import { useConfig } from "../config"
 import { getScrollAcceleration } from "../util/scroll"
 
 function statusError(status: McpServer["status"]) {
-  if (status.status === "failed") return status.error
+  if (status.status === "failed" || status.status === "needs_client_registration") return status.error
   return undefined
 }
 

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

@@ -14,6 +14,7 @@ export function DialogStatus() {
     if (status === "connected") return theme.text.feedback.success.default
     if (status === "failed") return theme.text.feedback.error.default
     if (status === "needs_auth") return theme.text.feedback.warning.default
+    if (status === "needs_client_registration") return theme.text.feedback.error.default
     return theme.text.subdued
   }
   return (
@@ -45,6 +46,9 @@ export function DialogStatus() {
                       <Match when={item.status.status === "failed" && item.status}>{(val) => val().error}</Match>
                       <Match when={item.status.status === "disabled"}>Disabled in configuration</Match>
                       <Match when={item.status.status === "needs_auth"}>Needs authentication</Match>
+                      <Match when={item.status.status === "needs_client_registration" && item.status}>
+                        {(val) => (val() as { error: string }).error}
+                      </Match>
                     </Switch>
                   </span>
                 </text>

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

@@ -157,7 +157,6 @@ export function Prompt(props: PromptProps) {
   const route = useRoute()
   const data = useData()
   const keymapCommands = Keymap.useCommands()
-  const queueShortcut = Keymap.useShortcut("prompt.queue")
   const currentLocation = useLocation()
   const config = useConfig().data
   const dialog = useDialog()
@@ -362,20 +361,6 @@ export function Prompt(props: PromptProps) {
           dialog.clear()
         },
       },
-      {
-        title: "Queue prompt",
-        name: "prompt.queue",
-        category: "Prompt",
-        palette: undefined,
-        run: async (_input: string | undefined, event?: KeyEvent) => {
-          event?.preventDefault()
-          event?.stopPropagation()
-          if (!input.focused) return
-          const handled = await submit("queue")
-          if (!handled) return
-          dialog.clear()
-        },
-      },
       {
         title: "Remove editor context",
         name: "prompt.editor_context.clear",
@@ -534,11 +519,6 @@ export function Prompt(props: PromptProps) {
     commands: promptCommands(),
   }))
 
-  Keymap.createLayer(() => ({
-    priority: 1,
-    bindings: ["prompt.queue"],
-  }))
-
   Keymap.createLayer(() => ({
     bindings: [
       "prompt.submit",
@@ -924,7 +904,7 @@ export function Prompt(props: PromptProps) {
   })
 
   let submitting = false
-  async function submit(delivery: "steer" | "queue" = "steer") {
+  async function submit() {
     // Prevent overlapping invocations (e.g. a double-pressed Enter, or the
     // input's native onSubmit racing another dispatch). Without this guard,
     // a second call slips past the empty-input check before the first call
@@ -934,13 +914,13 @@ export function Prompt(props: PromptProps) {
     if (submitting) return false
     submitting = true
     try {
-      return await submitInner(delivery)
+      return await submitInner()
     } finally {
       submitting = false
     }
   }
 
-  async function submitInner(delivery: "steer" | "queue") {
+  async function submitInner() {
     // IME: double-defer may fire before onContentChange flushes the last
     // composed character (e.g. Korean hangul) to the store, so read
     // plainText directly and sync before any downstream reads.
@@ -953,20 +933,12 @@ export function Prompt(props: PromptProps) {
     if (auto()?.visible) return false
     if (!store.prompt.text) return false
     const trimmed = store.prompt.text.trim()
-    if (delivery === "queue" && (store.mode === "shell" || trimmed === "exit" || trimmed === "quit" || trimmed === ":q")) {
-      toast.show({ message: "This prompt cannot be queued", variant: "warning" })
-      return false
-    }
     if (trimmed === "exit" || trimmed === "quit" || trimmed === ":q") {
       void exit()
       return true
     }
     const slash = argumentSlash(store.prompt.text, keymapCommands())
     if (slash) {
-      if (delivery === "queue") {
-        toast.show({ message: "This prompt cannot be queued", variant: "warning" })
-        return false
-      }
       clearPrompt()
       await slash.command.run(slash.input)
       return true
@@ -1064,7 +1036,6 @@ export function Prompt(props: PromptProps) {
           model: { providerID: selectedModel.providerID, id: selectedModel.modelID, variant },
           files: store.prompt.files,
           agents: store.prompt.agents,
-          delivery,
         })
         .catch((error) => {
           toast.show({ title: "Failed to run command", message: errorMessage(error), variant: "error" })
@@ -1075,10 +1046,6 @@ export function Prompt(props: PromptProps) {
         (skill) => skill.slash === true && skill.id === inputText.split("\n")[0].split(" ")[0].slice(1),
       )
     ) {
-      if (delivery === "queue") {
-        toast.show({ message: "Skills cannot be queued", variant: "warning" })
-        return false
-      }
       move.startSubmit()
       void client.api.session.skill({
         sessionID,
@@ -1136,7 +1103,6 @@ export function Prompt(props: PromptProps) {
           text: inputText,
           files: store.prompt.files,
           agents: store.prompt.agents,
-          delivery,
         })
         .then(
           () => undefined,
@@ -1609,13 +1575,6 @@ export function Prompt(props: PromptProps) {
                       {store.interrupt > 0 ? "again to interrupt" : "interrupt"}
                     </span>
                   </text>
-                  <Show when={queueShortcut()}>
-                    {(shortcut) => (
-                      <text fg={theme.text.default} wrapMode="none" flexShrink={0}>
-                        {shortcut()} <span style={{ fg: theme.text.subdued }}>queue</span>
-                      </text>
-                    )}
-                  </Show>
                 </box>
               </Match>
               <Match when={move.progress()}>

packages/tui/src/config/v1/keybind.ts

@@ -161,7 +161,6 @@ export const Definitions = {
   display_thinking: keybind("none", "Toggle thinking blocks visibility"),
 
   prompt_submit: keybind("none", "Submit prompt"),
-  prompt_queue: keybind("alt+return", "Queue prompt"),
   prompt_editor_context_clear: keybind("none", "Clear editor context"),
   prompt_skills: keybind("none", "Open skill selector"),
   prompt_stash: keybind("none", "Stash prompt"),
@@ -171,7 +170,7 @@ export const Definitions = {
   input_clear: keybind("ctrl+c", "Clear input field"),
   input_paste: keybind({ key: "ctrl+v", preventDefault: false }, "Paste from clipboard"),
   input_submit: keybind("return", "Submit input"),
-  input_newline: keybind("shift+return,ctrl+return,ctrl+j", "Insert newline in input"),
+  input_newline: keybind("shift+return,ctrl+return,alt+return,ctrl+j", "Insert newline in input"),
   input_move_left: keybind("left,ctrl+b", "Move cursor left in input"),
   input_move_right: keybind("right,ctrl+f", "Move cursor right in input"),
   input_move_up: keybind("up", "Move cursor up in input"),
@@ -360,7 +359,6 @@ export const CommandMap = {
   messages_redo: "session.redo",
   display_thinking: "session.toggle.thinking",
   prompt_submit: "prompt.submit",
-  prompt_queue: "prompt.queue",
   prompt_editor_context_clear: "prompt.editor_context.clear",
   prompt_skills: "prompt.skills",
   prompt_stash: "prompt.stash",

packages/tui/src/feature-plugins/sidebar/mcp.tsx

@@ -8,7 +8,13 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
   const list = createMemo(() => props.context.data.location.mcp.server.list(session()?.location) ?? [])
   const on = createMemo(() => list().filter((item) => item.status.status === "connected").length)
   const bad = createMemo(
-    () => list().filter((item) => item.status.status === "failed" || item.status.status === "needs_auth").length,
+    () =>
+      list().filter(
+        (item) =>
+          item.status.status === "failed" ||
+          item.status.status === "needs_auth" ||
+          item.status.status === "needs_client_registration",
+      ).length,
   )
 
   const dot = (status: string) => {
@@ -16,6 +22,7 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
     if (status === "failed") return theme.text.feedback.error.default
     if (status === "disabled") return theme.text.subdued
     if (status === "needs_auth") return theme.text.feedback.warning.default
+    if (status === "needs_client_registration") return theme.text.feedback.error.default
     return theme.text.subdued
   }
 
@@ -58,6 +65,7 @@ function View(props: { context: Plugin.Context; sessionID: string }) {
                       </Match>
                       <Match when={item.status.status === "disabled"}>Disabled</Match>
                       <Match when={item.status.status === "needs_auth"}>Needs auth</Match>
+                      <Match when={item.status.status === "needs_client_registration"}>Needs client ID</Match>
                     </Switch>
                   </span>
                 </text>

packages/tui/src/mini/footer.prompt.tsx

@@ -19,7 +19,6 @@ import {
   displayCharAt,
   displaySlice,
   isExitCommand,
-  isCompactCommand,
   mentionTriggerIndex,
   isNewCommand,
   movePromptHistory,
@@ -981,18 +980,8 @@ export function createPromptState(input: PromptInput): PromptState {
   }))
 
   Keymap.createLayer(() => ({
-    priority: 1,
     enabled: input.prompt() && !visible(),
     commands: [
-      {
-        id: "prompt.queue",
-        title: "Queue prompt",
-        group: "Prompt",
-        run() {
-          syncDraft()
-          submitPrompt(promptCopy(draft), "queue")
-        },
-      },
       {
         id: "prompt.editor",
         title: "Open editor",
@@ -1127,7 +1116,7 @@ export function createPromptState(input: PromptInput): PromptState {
     }
   }
 
-  const submitPrompt = (next: RunPrompt, delivery: "steer" | "queue" = "steer") => {
+  const submitPrompt = (next: RunPrompt) => {
     if (!area || area.isDestroyed) {
       draft = promptCopy(next)
     }
@@ -1147,13 +1136,6 @@ export function createPromptState(input: PromptInput): PromptState {
     }
 
     const command = next.mode === "shell" ? undefined : selectedCommand(next.text, next.command)
-    if (
-      delivery === "queue" &&
-      (next.mode === "shell" || command?.source === "skill" || isNewCommand(next.text) || isCompactCommand(next.text))
-    ) {
-      input.onStatus("this prompt cannot be queued")
-      return
-    }
     if (!command && next.mode !== "shell" && isExitCommand(next.text)) {
       input.onExit()
       return
@@ -1175,10 +1157,10 @@ export function createPromptState(input: PromptInput): PromptState {
     }
 
     const submit = command
-      ? { ...next, command, delivery }
+      ? { ...next, command }
       : parsed?.type === "command"
-        ? { ...next, command: parsed.command, delivery }
-        : { ...next, delivery }
+        ? { ...next, command: parsed.command }
+        : next
     const shellMode = next.mode === "shell"
 
     resetDraft()

packages/tui/src/mini/footer.view.tsx

@@ -185,7 +185,6 @@ export function RunFooterView(props: RunFooterViewProps) {
   const command = () => shortcut("command.palette.show")
   const subagentShortcut = () => shortcut("session.child.first")
   const queuedShortcut = () => shortcut("session.queued_prompts")
-  const queueShortcut = () => shortcut("prompt.queue")
   const backgroundShortcut = () => shortcut("session.background")
   const subagentInterruptShortcut = () => shortcut("subagent.interrupt")
   const interrupt = () => shortcut("session.interrupt")
@@ -458,9 +457,6 @@ export function RunFooterView(props: RunFooterViewProps) {
     if (activeTabs().length > 0 && subagentShortcut()) {
       items.push({ key: subagentShortcut(), label: "subagents" })
     }
-    if (busy() && queueShortcut()) {
-      items.push({ key: queueShortcut(), label: "queue" })
-    }
 
     return items
   })

packages/tui/src/mini/runtime.queue.ts

@@ -25,7 +25,7 @@ export type QueueInput = {
   onAdmissionError?: (prompt: RunPrompt, error: unknown) => void | Promise<void>
   onNewSession?: () => void | Promise<void>
   onCompact?: () => void | Promise<void>
-  admit: (prompt: RunPrompt, delivery: "steer" | "queue", signal: AbortSignal) => Promise<void>
+  admit: (prompt: RunPrompt, signal: AbortSignal) => Promise<void>
   settle: () => Promise<void>
   run: (prompt: RunPrompt, signal: AbortSignal, admitted: () => void) => Promise<void>
 }
@@ -183,7 +183,7 @@ export async function runPromptQueue(input: QueueInput): Promise<void> {
               input.trace?.write("ui.commit", commit)
               input.footer.append(commit)
             }
-            input.onSend?.(sent, sent.delivery ?? "steer")
+            input.onSend?.(sent, "steer")
 
             if (state.closed) {
               break
@@ -276,11 +276,10 @@ export async function runPromptQueue(input: QueueInput): Promise<void> {
       const sent = { ...prompt, messageID: SessionMessage.ID.create() }
       const admission = state.admission
       admissionVersion += 1
-      const delivery = prompt.delivery ?? "queue"
-      input.onSend?.(sent, delivery)
+      input.onSend?.(sent, "queue")
       admissions = admissions
         .then(() => admission)
-        .then(() => input.admit(sent, delivery, admissionController.signal))
+        .then(() => input.admit(sent, admissionController.signal))
         .catch((error) => (state.closed ? undefined : input.onAdmissionError?.(sent, error)))
       return
     }

packages/tui/src/mini/runtime.ts

@@ -892,7 +892,7 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
       trace: log,
       onSend: (prompt, delivery) => {
         state.shown = true
-        state.history.push({ ...prompt, delivery: undefined })
+        state.history.push(prompt)
         if (prompt.mode !== "shell" && delivery === "steer") {
           rememberLocal({
             kind: "user",
@@ -903,21 +903,18 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
           })
         }
       },
-      admit: async (prompt, delivery, signal) => {
+      admit: async (prompt, signal) => {
         await state.switching?.catch(() => {})
         const next = await ensureStream()
-        await next.handle.admitPromptTurn(
-          {
-            agent: state.agent,
-            model: state.model,
-            variant: state.activeVariant,
-            prompt,
-            files: input.files,
-            includeFiles: false,
-            signal,
-          },
-          delivery,
-        )
+        await next.handle.queuePromptTurn({
+          agent: state.agent,
+          model: state.model,
+          variant: state.activeVariant,
+          prompt,
+          files: input.files,
+          includeFiles: false,
+          signal,
+        })
       },
       onAdmissionError: renderPromptError,
       onCompact: async () => {

packages/tui/src/mini/stream-v2.transport.ts

@@ -71,7 +71,7 @@ export type SessionResizeReplayInput = {
 
 export type SessionTransport = {
   runPromptTurn(input: SessionTurnInput, admitted?: () => void): Promise<void>
-  admitPromptTurn(input: SessionTurnInput, delivery: "steer" | "queue"): Promise<void>
+  queuePromptTurn(input: SessionTurnInput): Promise<void>
   waitForIdle(): Promise<void>
   interruptActiveTurn(): Promise<void>
   selectSubagent(sessionID: string | undefined): void
@@ -1643,14 +1643,14 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
   }
 
   return {
-    async admitPromptTurn(next, delivery) {
+    async queuePromptTurn(next) {
       if (next.prompt.mode === "shell" || next.prompt.command?.source === "skill")
         throw new Error("This prompt cannot be queued")
       if (!state.connected) throw new Error("Event stream is reconnecting")
       const client = sdk
       if (next.agent)
         await client.session.switchAgent({ sessionID: input.sessionID, agent: next.agent }, { signal: next.signal })
-      mergePending(await admitPrompt(next, client, delivery))
+      mergePending(await admitPrompt(next, client, "queue"))
       settlementClient = client
     },
     async waitForIdle() {
@@ -1688,7 +1688,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
         return
       }
       if (command) {
-        await runTurnWait(next, messageID, client, () => admitPrompt(next, client, next.prompt.delivery ?? "steer"), admitted)
+        await runTurnWait(next, messageID, client, () => admitPrompt(next, client, "steer"), admitted)
         return
       }
 
@@ -1700,7 +1700,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       if (selected)
         await client.session.switchModel({ sessionID: input.sessionID, model: selected }, { signal: next.signal })
 
-      await runTurnWait(next, messageID, client, () => admitPrompt(next, client, next.prompt.delivery ?? "steer"), admitted)
+      await runTurnWait(next, messageID, client, () => admitPrompt(next, client, "steer"), admitted)
     },
     async interruptActiveTurn() {
       // A running shell holds no drain, so session.interrupt cannot reach it;

packages/tui/src/mini/types.ts

@@ -75,7 +75,6 @@ export type RunPrompt = {
   messageID?: string
   text: string
   parts: RunPromptPart[]
-  delivery?: "steer" | "queue"
   mode?: "shell"
   command?: {
     name: string

packages/tui/src/routes/session/index.tsx

@@ -175,11 +175,6 @@ export function Session() {
       .flatMap((sessionID) => data.session.form.list(sessionID) ?? [])
       .concat(global)
   })
-  const queuedPrompts = createMemo(() =>
-    data.session.pending.list(route.sessionID).flatMap((item) =>
-      item.type === "user" && item.delivery === "queue" ? [{ id: item.id, text: item.data.text }] : [],
-    ),
-  )
   const [composer, setComposer] = createStore({
     open: false,
     tab: undefined as string | undefined,
@@ -1011,9 +1006,6 @@ export function Session() {
               </Show>
             </scrollbox>
             <box flexShrink={0}>
-              <Show when={!composer.open && !disabled() && queuedPrompts().length > 0}>
-                <QueuedPromptDock prompts={queuedPrompts()} />
-              </Show>
               <PluginSlot name="session.composer.top" input={{ sessionID: route.sessionID }} mode="all" />
               <Composer
                 sessionID={route.sessionID}
@@ -1857,10 +1849,9 @@ function UserMessage(props: { message: SessionMessageUser }) {
   const mode = themes.mode
   const [hover, setHover] = createSignal(false)
   const color = createMemo(() => local.agent.color(data.session.get(ctx.sessionID)?.agent ?? "build"))
-  const delivery = createMemo(() => {
-    const pending = data.session.pending.list(ctx.sessionID).find((item) => item.id === props.message.id)
-    return pending?.type === "user" ? pending.delivery : undefined
-  })
+  const queued = createMemo(
+    () => data.session.status(ctx.sessionID) === "running" && data.session.input.has(ctx.sessionID, props.message.id),
+  )
   const dialog = useDialog()
   const renderer = useRenderer()
   const promptRef = usePromptRef()
@@ -1869,7 +1860,7 @@ function UserMessage(props: { message: SessionMessageUser }) {
     <Show when={props.message.text.trim() || files().length}>
       <box
         border={["left"]}
-        borderColor={delivery() ? theme.border.default : color()}
+        borderColor={queued() ? theme.border.default : color()}
         customBorderChars={SplitBorder.customBorderChars}
       >
         <box
@@ -1896,9 +1887,6 @@ function UserMessage(props: { message: SessionMessageUser }) {
           flexShrink={0}
         >
           <text fg={theme.text.default}>{props.message.text}</text>
-          <Show when={delivery()}>
-            {(value) => <text fg={theme.text.subdued}>{value() === "queue" ? "queued" : "steering"}</text>}
-          </Show>
           <Show when={files().length}>
             <box flexDirection="row" paddingTop={1} gap={1} flexWrap="wrap">
               <For each={files()}>
@@ -1931,38 +1919,6 @@ function UserMessage(props: { message: SessionMessageUser }) {
   )
 }
 
-function QueuedPromptDock(props: { prompts: { id: string; text: string }[] }) {
-  const theme = useTheme("elevated")
-  const shortcut = Keymap.useShortcut("command.palette.show")
-  const next = createMemo(() => props.prompts[0]?.text)
-
-  return (
-    <box
-      border={["left"]}
-      borderColor={theme.border.default}
-      customBorderChars={SplitBorder.customBorderChars}
-      paddingLeft={2}
-      paddingRight={1}
-      backgroundColor={theme.background.default}
-      flexDirection="row"
-      justifyContent="space-between"
-      gap={2}
-    >
-      <text fg={theme.text.subdued} wrapMode="none" truncate flexGrow={1} flexShrink={1} minWidth={0}>
-        <span style={{ fg: theme.text.default }}>{props.prompts.length} queued</span>
-        <Show when={next()}>{(text) => <> · Next · {text()}</>}</Show>
-      </text>
-      <Show when={shortcut()}>
-        {(key) => (
-          <text fg={theme.text.subdued} wrapMode="none" flexShrink={0}>
-            <span style={{ fg: theme.text.default }}>{key()}</span> view all
-          </text>
-        )}
-      </Show>
-    </box>
-  )
-}
-
 function AssistantRetry(props: { retry: SessionMessageAssistant["retry"] }) {
   const theme = useTheme()
   return (

packages/tui/src/routes/session/rows.ts

@@ -46,7 +46,6 @@ export function createSessionRows(sessionID: Accessor<string>) {
   function reduce() {
     const messages = data.session.message.list(sessionID())
     const inputs = new Set(data.session.input.list(sessionID()))
-    const pending = data.session.pending.list(sessionID())
     const boundary = revertBoundary()
     const rows = reduceSessionRows(
       boundary ? messages.filter((message) => message.id < boundary) : messages,
@@ -54,17 +53,12 @@ export function createSessionRows(sessionID: Accessor<string>) {
       turnTokens(),
     )
     partitionPending(rows, pendingPermissions())
-    removeQueuedPrompts(
-      rows,
-      pending
-        .filter((item) => item.type === "user" && item.delivery === "queue")
-        .map((item) => item.id),
-    )
     const position = rows.findIndex((row) => row.type === "message" && inputs.has(row.messageID))
     rows.splice(
       position === -1 ? rows.length : position,
       0,
-      ...pending
+      ...data.session.pending
+        .list(sessionID())
         .filter((item) => item.type === "compaction")
         .map((item): SessionRow => ({ type: "compaction-queued", inputID: item.id })),
     )
@@ -118,7 +112,10 @@ export function createSessionRows(sessionID: Accessor<string>) {
   createEffect(
     on(
       () =>
-        data.session.pending.list(sessionID()).map((item) => `${item.id}:${"delivery" in item ? item.delivery : item.type}`),
+        data.session.pending
+          .list(sessionID())
+          .filter((item) => item.type === "compaction")
+          .map((item) => item.id),
       () => setRows(reconcile(reduce())),
       { defer: true },
     ),
@@ -199,9 +196,7 @@ export function createSessionRows(sessionID: Accessor<string>) {
 
   const queuedStart = (rows: SessionRow[]) => {
     const index = rows.findIndex(
-      (row) =>
-        row.type === "compaction-queued" ||
-        (row.type === "message" && isPending(row.messageID)),
+      (row) => row.type === "compaction-queued" || (row.type === "message" && isPending(row.messageID)),
     )
     return index === -1 ? rows.length : index
   }
@@ -286,12 +281,6 @@ export function createSessionRows(sessionID: Accessor<string>) {
   return rows
 }
 
-export function removeQueuedPrompts(rows: SessionRow[], messageIDs: string[]) {
-  const queued = new Set(messageIDs)
-  const visible = rows.filter((row) => row.type !== "message" || !queued.has(row.messageID))
-  rows.splice(0, rows.length, ...visible)
-}
-
 export function reduceSessionRows(
   messages: SessionMessageInfo[],
   inputs = new Set<string>(),

packages/tui/src/ui/link.tsx

@@ -28,7 +28,7 @@ export function Link(props: LinkProps) {
         open(props.href).catch(() => {})
       }}
     >
-      <a href={props.href}>{displayText}</a>
+      {displayText}
     </text>
   )
 }

packages/tui/test/cli/tui/session-rows.test.ts

@@ -1,30 +1,6 @@
 import { expect, test } from "bun:test"
 import type { SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client"
-import {
-  cacheReuseDrop,
-  messageBoundaryIDs,
-  removeQueuedPrompts,
-  reduceSessionRows,
-} from "../../../src/routes/session/rows"
-import type { SessionRow } from "../../../src/routes/session/rows"
-
-test("removes queued prompts from transcript rows", () => {
-  const rows: SessionRow[] = [
-    { type: "message" as const, messageID: "active" },
-    { type: "message" as const, messageID: "queue-1" },
-    { type: "message" as const, messageID: "steer" },
-    { type: "message" as const, messageID: "queue-2" },
-    { type: "message" as const, messageID: "queue-3" },
-    { type: "message" as const, messageID: "queue-4" },
-  ]
-
-  removeQueuedPrompts(rows, ["queue-1", "queue-2", "queue-3", "queue-4"])
-
-  expect(rows).toEqual([
-    { type: "message", messageID: "active" },
-    { type: "message", messageID: "steer" },
-  ])
-})
+import { cacheReuseDrop, messageBoundaryIDs, reduceSessionRows } from "../../../src/routes/session/rows"
 
 test("filters OpenAI cache quantization from cache reuse drops", () => {
   const openai = { id: "gpt", providerID: "openai" }

packages/tui/test/mini/fixture/footer-api.ts

@@ -56,9 +56,9 @@ export function createFooterApiFixture(input: { events?: FooterEvent[]; commits?
     commits,
     calls,
     promptReady,
-    submit(text: string, mode?: RunPrompt["mode"], delivery?: RunPrompt["delivery"]) {
+    submit(text: string, mode?: RunPrompt["mode"]) {
       if (prompts.size === 0) return false
-      const prompt: RunPrompt = { text, parts: [], ...(mode ? { mode } : {}), ...(delivery ? { delivery } : {}) }
+      const prompt: RunPrompt = mode ? { text, parts: [], mode } : { text, parts: [] }
       for (const fn of [...prompts]) fn(prompt)
       return true
     },

packages/tui/test/mini/footer.view.test.tsx

@@ -1068,11 +1068,11 @@ test("direct footer submits slash autocomplete selections without dispatching sh
     await app.renderOnce()
 
     expect(submits).toEqual([
-      { text: "/review ", parts: [], command: { name: "review", arguments: "" }, delivery: "steer" },
-      { text: "/review ", parts: [], command: { name: "review", arguments: "" }, delivery: "steer" },
-      { text: "/review branch", parts: [], command: { name: "review", arguments: "branch" }, delivery: "steer" },
-      { text: "/new ", parts: [], delivery: "steer" },
-      { text: "/new ", parts: [], delivery: "steer" },
+      { text: "/review ", parts: [], command: { name: "review", arguments: "" } },
+      { text: "/review ", parts: [], command: { name: "review", arguments: "" } },
+      { text: "/review branch", parts: [], command: { name: "review", arguments: "branch" } },
+      { text: "/new ", parts: [] },
+      { text: "/new ", parts: [] },
     ])
     expect(app.renderer.currentFocusedEditor?.plainText).toBe("/settings ")
   } finally {
@@ -1100,9 +1100,7 @@ test("direct footer slash autocomplete keeps a real skills command", async () =>
     app.mockInput.pressEnter()
     await app.renderOnce()
 
-    expect(submits).toEqual([
-      { text: "/skills ", parts: [], command: { name: "skills", arguments: "" }, delivery: "steer" },
-    ])
+    expect(submits).toEqual([{ text: "/skills ", parts: [], command: { name: "skills", arguments: "" } }])
     expect(app.captureCharFrame()).not.toContain("Apply formatter fixes")
   } finally {
     app.cleanup()
@@ -1160,12 +1158,7 @@ test("direct footer tags skill slash submissions with their catalog source", asy
     await app.renderOnce()
 
     expect(submits).toEqual([
-      {
-        text: "/formatter src",
-        parts: [],
-        command: { name: "formatter", arguments: "src", source: "skill" },
-        delivery: "steer",
-      },
+      { text: "/formatter src", parts: [], command: { name: "formatter", arguments: "src", source: "skill" } },
     ])
   } finally {
     app.cleanup()

packages/tui/test/mini/runtime.boot.test.ts

@@ -82,8 +82,7 @@ describe("run runtime boot", () => {
     expect(result.keybinds.get("prompt.history.next")?.[0]?.key).toBe("down")
     expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+c")
     expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("return")
-    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,ctrl+j")
-    expect(result.keybinds.get("prompt.queue")?.[0]?.key).toBe("alt+return")
+    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,alt+return,ctrl+j")
   })
 
   test("preserves disabled leader from resolved tui config", async () => {

packages/tui/test/mini/runtime.queue.test.ts

@@ -265,33 +265,6 @@ describe("run runtime queue", () => {
     await task
   })
 
-  test("preserves explicit steer and queue delivery for in-flight prompts", async () => {
-    const ui = createFooterApiFixture()
-    const admitted: string[] = []
-    const gate = Promise.withResolvers<void>()
-
-    const task = runPromptQueue({
-      footer: ui.api,
-      run: async (_input, _signal, onAdmitted) => {
-        onAdmitted()
-        await gate.promise
-      },
-      admit: async (input, delivery) => {
-        admitted.push(`${input.text}:${delivery}`)
-      },
-      settle: async () => ui.api.close(),
-    })
-
-    ui.submit("one")
-    ui.submit("two", undefined, "steer")
-    ui.submit("three", undefined, "queue")
-    while (admitted.length < 2) await Bun.sleep(0)
-    expect(admitted).toEqual(["two:steer", "three:queue"])
-
-    gate.resolve()
-    await task
-  })
-
   test("continues durable admission after one fails", async () => {
     const ui = createFooterApiFixture()
     const admitted: string[] = []
@@ -335,7 +308,7 @@ describe("run runtime queue", () => {
         admitted()
         await new Promise<void>((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }))
       },
-      admit: async (_prompt, _delivery, signal) => {
+      admit: async (_prompt, signal) => {
         admissionStarted.resolve()
         await new Promise<void>((resolve) => {
           if (signal.aborted) {

packages/tui/test/mini/runtime.test.ts

@@ -126,7 +126,7 @@ describe("run interactive runtime", () => {
                 turnStarted.resolve()
                 api.close()
               },
-              admitPromptTurn: async () => {},
+              queuePromptTurn: async () => {},
               waitForIdle: async () => {},
               interruptActiveTurn: async () => {},
               selectSubagent: () => {},
@@ -209,7 +209,7 @@ describe("run interactive runtime", () => {
             streamStarted.resolve()
             return {
               runPromptTurn: async () => {},
-              admitPromptTurn: async () => {},
+              queuePromptTurn: async () => {},
               waitForIdle: async () => {},
               interruptActiveTurn: async () => {},
               selectSubagent: () => {},
@@ -556,7 +556,7 @@ describe("run interactive runtime", () => {
             setTimeout(() => input.footer.close(), 0)
             return {
               runPromptTurn: async () => {},
-              admitPromptTurn: async () => {},
+              queuePromptTurn: async () => {},
               waitForIdle: async () => {},
               interruptActiveTurn: async () => {},
               selectSubagent: () => {},

packages/tui/test/mini/stream-v2.transport.test.ts

@@ -701,14 +701,14 @@ describe("V2 mini transport", () => {
     const prompt = spyOn(client.session, "prompt").mockImplementation(
       (request) => ok(promptAdmission(request)) as never,
     )
-    await transport.admitPromptTurn({
+    await transport.queuePromptTurn({
       agent: "review",
       model: undefined,
       variant: undefined,
       prompt: { messageID: "msg_next", text: "another", parts: [] },
       files: [],
       includeFiles: false,
-    }, "queue")
+    })
     expect(client.session.switchAgent).toHaveBeenCalledWith({ sessionID: "ses_1", agent: "review" }, expect.anything())
     expect(prompt).toHaveBeenCalledWith(expect.objectContaining({ delivery: "queue" }), expect.anything())
     events.push({
@@ -813,14 +813,14 @@ describe("V2 mini transport", () => {
       durable: durable("ses_1", 2),
       data: { sessionID: "ses_1", inputID: "msg_prompt" },
     })
-    await transport.admitPromptTurn({
+    await transport.queuePromptTurn({
       agent: undefined,
       model: undefined,
       variant: undefined,
       prompt: { messageID: "msg_queued", text: "follow up", parts: [] },
       files: [],
       includeFiles: false,
-    }, "queue")
+    })
     events.push({
       id: "evt_queued_promoted",
       created: 3,

packages/www/content/docs/(Configure)/compaction.mdx

@@ -83,7 +83,7 @@ Add `compaction` to any [OpenCode configuration file](/config):
     "auto": true,
     "prune": false,
     "keep": {
-      "tokens": 15000
+      "tokens": 8000
     },
     "buffer": 20000
   }
@@ -94,7 +94,7 @@ Add `compaction` to any [OpenCode configuration file](/config):
 | --- | ---: | --- |
 | `auto` | `true` | Runs the preflight context-size check. It does not disable manual compaction or one-shot provider-overflow recovery. |
 | `prune` | None | Accepted by the V2 schema, but currently has no runtime effect. V2 does not prune old tool outputs in place. |
-| `keep.tokens` | `15000` | Approximate number of tokens from the newest serialized conversation context to retain beside the summary. |
+| `keep.tokens` | `8000` | Approximate number of tokens from the newest serialized conversation context to retain beside the summary. |
 | `buffer` | `20000` | Safety reserve below an explicit input limit. Without one, it is the minimum context reserve and the model output allowance wins when larger. |
 
 `keep.tokens` and `buffer` accept non-negative integers. Larger `keep.tokens`

packages/www/content/docs/config.mdx

@@ -329,7 +329,7 @@ Control automatic context compaction and how much recent context it preserves.
   "compaction": {
     "auto": true,
     "keep": {
-      "tokens": 15000
+      "tokens": 8000
     },
     "buffer": 20000
   }