refactor(ai): inline Azure URL check

# Conflicts:
#	packages/core/src/plugin/provider.ts

packages/ai/src/protocols/gemini.ts

@@ -444,6 +444,7 @@ const mapUsage = (usage: GeminiUsage | undefined) => {
 }
 
 const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean): FinishReason => {
+  if (finishReason === undefined) return hasToolCalls ? "tool-calls" : "unknown"
   if (finishReason === "STOP") return hasToolCalls ? "tool-calls" : "stop"
   if (finishReason === "MAX_TOKENS") return "length"
   if (

packages/ai/src/providers/azure.ts

@@ -5,6 +5,7 @@ import type { ProviderPackage } from "../provider-package"
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
+import { ProviderShared } from "../protocols/shared"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options"
 
 export const id = ProviderID.make("azure")
@@ -19,7 +20,7 @@ export type LanguageModelOptions = AzureURL &
   ProviderAuthOption<"optional"> & {
     readonly apiVersion?: string
     readonly queryParams?: Record<string, string>
-    readonly useCompletionUrls?: boolean
+    readonly useDeploymentBasedUrls?: boolean
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 export type Config = LanguageModelOptions
@@ -29,27 +30,22 @@ export type Settings = ProviderPackage.Settings &
     readonly apiKey?: string
     readonly apiVersion?: string
     readonly queryParams?: Readonly<Record<string, string>>
+    readonly useDeploymentBasedUrls?: boolean
     readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
-const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai/v1`
+const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai`
 
 const responsesRoute = OpenAIResponses.route.with({
   id: "azure-openai-responses",
   provider: id,
   auth: routeAuth,
-  endpoint: {
-    query: { "api-version": "v1" },
-  },
 })
 
 const chatRoute = OpenAIChat.route.with({
   id: "azure-openai-chat",
   provider: id,
   auth: routeAuth,
-  endpoint: {
-    query: { "api-version": "v1" },
-  },
 })
 
 export const routes = [responsesRoute, chatRoute]
@@ -59,7 +55,7 @@ const defaults = (input: Config) => {
     apiKey: _,
     apiVersion: _apiVersion,
     resourceName: _resourceName,
-    useCompletionUrls: _useCompletionUrls,
+    useDeploymentBasedUrls: _useDeploymentBasedUrls,
     baseURL: _baseURL,
     queryParams: _queryParams,
     ...rest
@@ -80,37 +76,39 @@ const auth = (input: Config) => {
   )
 }
 
-const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config) =>
+const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config, modelID: string | ModelID) =>
   route.with({
     auth: auth(input),
-    endpoint: {
-      // AtLeastOne guarantees at least one is set; baseURL wins if both are.
-      baseURL: input.baseURL ?? resourceBaseURL(input.resourceName!),
-      query: {
-        ...(input.apiVersion ? { "api-version": input.apiVersion } : {}),
-        ...input.queryParams,
-      },
-    },
+    endpoint: endpoint(input, modelID),
   })
 
+function endpoint(input: Config, modelID: string | ModelID) {
+  const baseURL = ProviderShared.trimBaseUrl(input.baseURL ?? resourceBaseURL(input.resourceName!))
+  const query = { "api-version": input.apiVersion ?? "v1", ...input.queryParams }
+
+  if (input.useDeploymentBasedUrls) return { baseURL: `${baseURL}/deployments/${modelID}`, query }
+  if (input.baseURL !== undefined && !new URL(input.baseURL).hostname.endsWith(".openai.azure.com")) {
+    return { baseURL, query: input.queryParams }
+  }
+  return { baseURL: `${baseURL}/v1`, query }
+}
+
 export const configure = (input: Config) => {
-  const configuredResponsesRoute = configuredRoute(responsesRoute, input)
-  const configuredChatRoute = configuredRoute(chatRoute, input)
   const modelDefaults = defaults(input)
 
   const responses = (modelID: string | ModelID) =>
-    configuredResponsesRoute
+    configuredRoute(responsesRoute, input, modelID)
       .with(withOpenAIOptions(modelID, modelDefaults))
       .model<OpenAIProviderOptionsInput>({ id: modelID })
 
   const chat = (modelID: string | ModelID) =>
-    configuredChatRoute
+    configuredRoute(chatRoute, input, modelID)
       .with(withOpenAIOptions(modelID, modelDefaults))
       .model<OpenAIProviderOptionsInput>({ id: modelID })
 
   return {
     id,
-    model: (modelID: string | ModelID) => (input.useCompletionUrls === true ? chat(modelID) : responses(modelID)),
+    model: responses,
     responses,
     chat,
     configure,
@@ -131,6 +129,7 @@ const config = (settings: Settings): Config => {
     limits: settings.limits,
     providerOptions: settings.providerOptions,
     queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
+    useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
   }
   if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
   if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }

packages/ai/src/providers/google-vertex-messages.ts

@@ -15,8 +15,7 @@ export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput
 
 const VERSION = "vertex-2023-10-16" as const
 
-// models.dev uses this provider id even though the API contract is Anthropic Messages.
-export const id = ProviderID.make("google-vertex-anthropic")
+export const id = ProviderID.make("google-vertex")
 
 export type Config = RouteDefaultsInput &
   GoogleVertexShared.OAuthOptions & {

packages/ai/src/route/client.ts

@@ -20,6 +20,7 @@ import {
   LanguageModel,
   LanguageModelLimits,
   LLMEvent,
+  InvalidProviderOutputReason,
   ProviderID,
   mergeGenerationOptions,
   mergeHttpOptions,
@@ -231,6 +232,17 @@ const streamError = (route: string, message: string, cause: Cause.Cause<unknown>
   return ProviderShared.eventError(route, message, Cause.pretty(cause))
 }
 
+const incompleteStreamError = (route: string) =>
+  new AIError({
+    module: "LLMClient",
+    method: "stream",
+    reason: new InvalidProviderOutputReason({
+      classification: "incomplete-stream",
+      message: "The provider response ended unexpectedly.",
+      route,
+    }),
+  })
+
 const requireTerminalEvent = (route: string) => (events: Stream.Stream<LLMEvent, AIError>) =>
   Stream.suspend(() => {
     let terminal = false
@@ -247,7 +259,7 @@ const requireTerminalEvent = (route: string) => (events: Stream.Stream<LLMEvent,
         Effect.suspend(() =>
           terminal
             ? Effect.void
-            : Effect.fail(ProviderShared.eventError(route, "Provider stream ended without a terminal finish event")),
+            : Effect.fail(incompleteStreamError(route)),
         ),
       ),
     )
@@ -416,10 +428,7 @@ const generateWith = (stream: Interface["stream"]) =>
     const state = yield* stream(request, options).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce))
     const response = LLMResponse.complete(state)
     if (response) return response
-    return yield* ProviderShared.eventError(
-      `${request.model.provider}/${request.model.route.id}`,
-      "Provider stream ended without a terminal finish event",
-    )
+    return yield* incompleteStreamError(`${request.model.provider}/${request.model.route.id}`)
   })
 
 export function stream(request: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service> {

packages/ai/src/schema/errors.ts

@@ -105,6 +105,7 @@ export class InvalidProviderOutputReason extends Schema.Class<InvalidProviderOut
 )({
   _tag: Schema.tag("InvalidProviderOutput"),
   message: Schema.String,
+  classification: Schema.optional(Schema.Literals(["incomplete-stream"])),
   route: Schema.optional(Schema.String),
   raw: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),

packages/ai/src/tool.ts

@@ -24,7 +24,7 @@ export type ToolExecute<Parameters extends ToolSchema<any>, Success extends Tool
 ) => Effect.Effect<Schema.Schema.Type<Success>, ToolFailure>
 
 export interface ToolModelOutputInput<Parameters, Output> {
-  readonly callID: ToolCallPart["id"]
+  readonly id: ToolCallPart["id"]
   readonly parameters: Parameters
   readonly output: Output
 }
@@ -59,7 +59,7 @@ export interface Definition<Parameters extends ToolSchema<any>, Success extends
   /** @internal */
   readonly _project: (
     parameters: Schema.Schema.Type<Parameters>,
-    callID: ToolCallPart["id"],
+    id: ToolCallPart["id"],
     output: unknown,
   ) => ToolOutputType
   /** @internal */
@@ -173,8 +173,8 @@ export function make(config: TypedToolConfig | DynamicToolConfig): AnyTool {
       toStructuredOutput: config.toStructuredOutput,
       _decode: Effect.succeed,
       _encode: Effect.succeed,
-      _project: (parameters, callID, output) =>
-        project(config.toModelOutput, config.toStructuredOutput, parameters, callID, output),
+      _project: (parameters, id, output) =>
+        project(config.toModelOutput, config.toStructuredOutput, parameters, id, output),
       _legacyResult: config.toModelOutput === undefined && config.toStructuredOutput === undefined,
       _definition: new ToolDefinition({
         name: "",
@@ -193,8 +193,8 @@ export function make(config: TypedToolConfig | DynamicToolConfig): AnyTool {
     toStructuredOutput: config.toStructuredOutput,
     _decode: Schema.decodeUnknownEffect(config.parameters),
     _encode: Schema.encodeEffect(config.success),
-    _project: (parameters, callID, output) =>
-      project(config.toModelOutput, config.toStructuredOutput, parameters, callID, output),
+    _project: (parameters, id, output) =>
+      project(config.toModelOutput, config.toStructuredOutput, parameters, id, output),
     _legacyResult: false,
     _definition: new ToolDefinition({
       name: "",
@@ -239,12 +239,12 @@ const project = (
   toModelOutput: ((input: ToolModelOutputInput<any, any>) => ReadonlyArray<Tool.Content>) | undefined,
   toStructuredOutput: ((output: unknown) => unknown) | undefined,
   parameters: unknown,
-  callID: ToolCallPart["id"],
+  id: ToolCallPart["id"],
   output: unknown,
 ): ToolOutputType =>
   ToolOutput.make(
     toStructuredOutput?.(output) ?? output,
-    toModelOutput?.({ callID, parameters, output }) ??
+    toModelOutput?.({ id, parameters, output }) ??
       (typeof output === "string" ? [{ type: "text", text: output }] : []),
   )
 

packages/ai/test/adapter.test.ts

@@ -133,8 +133,8 @@ describe("llm route", () => {
     Effect.gen(function* () {
       const error = yield* (yield* LLMClient.Service).stream(request).pipe(Stream.runDrain, Effect.flip)
 
-      expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput" })
-      expect(error.message).toContain("Provider stream ended without a terminal finish event")
+      expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput", classification: "incomplete-stream" })
+      expect(error.message).toContain("The provider response ended unexpectedly.")
     }),
   )
 

packages/ai/test/provider-package.test.ts

@@ -209,6 +209,27 @@ describe("provider package entrypoints", () => {
     expect(chat.route.id).toBe("azure-openai-chat")
   })
 
+  test("constructs Azure deployment URLs and preserves custom gateway URLs", async () => {
+    const Azure = await import("@opencode-ai/ai/providers/azure")
+    const deployment = Azure.model("custom-deployment", {
+      apiKey: "fixture",
+      resourceName: "opencode-test",
+      apiVersion: "2025-01-01-preview",
+      useDeploymentBasedUrls: true,
+    })
+    const gateway = Azure.model("gateway-model", {
+      apiKey: "fixture",
+      baseURL: "https://gateway.example/azure/",
+    })
+
+    expect(deployment.route.endpoint).toMatchObject({
+      baseURL: "https://opencode-test.openai.azure.com/openai/deployments/custom-deployment",
+      query: { "api-version": "2025-01-01-preview" },
+    })
+    expect(gateway.route.endpoint.baseURL).toBe("https://gateway.example/azure")
+    expect(gateway.route.endpoint.query).toBeUndefined()
+  })
+
   test("maps Google package settings onto the Gemini model", async () => {
     const Google = await import("@opencode-ai/ai/providers/google")
     const selected = Google.model("gemini-2.5-flash", {

packages/ai/test/provider/anthropic-messages.test.ts

@@ -538,7 +538,8 @@ describe("Anthropic Messages route", () => {
 
       expect(error.reason).toMatchObject({
         _tag: "InvalidProviderOutput",
-        message: "Provider stream ended without a terminal finish event",
+        classification: "incomplete-stream",
+        message: "The provider response ended unexpectedly.",
       })
     }),
   )

packages/ai/test/provider/gemini.test.ts

@@ -601,6 +601,34 @@ describe("Gemini route", () => {
     }),
   )
 
+  it.effect("maps tool calls without a finish reason", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(
+        LLMRequest.update(request, {
+          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
+        }),
+      ).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents({
+              candidates: [
+                {
+                  content: {
+                    role: "model",
+                    parts: [{ functionCall: { name: "lookup", args: { query: "weather" } } }],
+                  },
+                },
+              ],
+              usageMetadata: { promptTokenCount: 5, candidatesTokenCount: 1 },
+            }),
+          ),
+        ),
+      )
+
+      expect(response.finishReason).toEqual({ normalized: "tool-calls", raw: undefined })
+    }),
+  )
+
   it.effect("assigns unique ids to multiple streamed tool calls", () =>
     Effect.gen(function* () {
       const body = sseEvents({

packages/ai/test/provider/google-vertex.test.ts

@@ -56,13 +56,14 @@ describe("Google Vertex providers", () => {
 
   it.effect("projects Anthropic Messages onto the Vertex raw-predict API", () =>
     Effect.gen(function* () {
+      const model = GoogleVertexMessages.configure({
+        accessToken: "vertex-token",
+        location: "eu",
+        project: "vertex-project",
+      }).model("claude-sonnet-4-6")
       const response = yield* LLMClient.generate(
         LLM.request({
-          model: GoogleVertexMessages.configure({
-            accessToken: "vertex-token",
-            location: "eu",
-            project: "vertex-project",
-          }).model("claude-sonnet-4-6"),
+          model,
           prompt: "Say hello.",
         }),
       ).pipe(
@@ -97,6 +98,7 @@ describe("Google Vertex providers", () => {
         ),
       )
 
+      expect(model.provider).toBe("google-vertex")
       expect(response.text).toBe("Hello.")
     }),
   )

packages/ai/test/provider/openai-chat.test.ts

@@ -1136,9 +1136,12 @@ describe("OpenAI Chat route", () => {
         { type: "tool-input-delta", id: "call_1", name: "lookup", text: ':"weather"}' },
       ])
       expect(events.filter(LLMEvent.is.toolCall)).toEqual([])
-      expect(streamError.reason).toMatchObject({ _tag: "InvalidProviderOutput" })
-      expect(streamError.message).toContain("Provider stream ended without a terminal finish event")
-      expect(error.message).toContain("Provider stream ended without a terminal finish event")
+      expect(streamError.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
+        classification: "incomplete-stream",
+      })
+      expect(streamError.message).toContain("The provider response ended unexpectedly.")
+      expect(error.message).toContain("The provider response ended unexpectedly.")
     }),
   )
 

packages/ai/test/tool-runtime.test.ts

@@ -169,7 +169,7 @@ describe("LLMClient tools", () => {
         LLMEvent.toolCall({ id: "call_projected", name: "projected", input: { prefix: "count" } }),
       )
 
-      expect(calls).toEqual([{ callID: "call_projected", parameters: { prefix: "count" }, output: { count: "2" } }])
+      expect(calls).toEqual([{ id: "call_projected", parameters: { prefix: "count" }, output: { count: "2" } }])
       expect(dispatched.result).toEqual({ type: "text", value: "count:2" })
       expect(dispatched.output).toEqual({ structured: { count: "2" }, content: [{ type: "text", text: "count:2" }] })
       expect(dispatched.events).toEqual([

packages/ai/test/tool.types.ts

@@ -27,8 +27,8 @@ Tool.make({
   parameters: Schema.Struct({ city: Schema.String }),
   success: Schema.Struct({ forecast: Schema.NumberFromString }),
   execute: () => Effect.succeed({ forecast: 1 }),
-  toModelOutput: ({ callID, parameters, output }) => [
-    { type: "text", text: `${callID}:${parameters.city}:${output.forecast}` },
+  toModelOutput: ({ id, parameters, output }) => [
+    { type: "text", text: `${id}:${parameters.city}:${output.forecast}` },
   ],
 })
 

packages/app/src/context/global-sync/utils.test.ts

@@ -53,7 +53,7 @@ describe("normalizePermissionRequest", () => {
         resources: ["README.md"],
         save: ["*.md"],
         metadata: { path: "README.md" },
-        source: { type: "tool", messageID: "message-1", callID: "call-1" },
+        source: { type: "tool", messageID: "message-1", id: "call-1" },
       }),
     ).toEqual({
       id: "permission-1",

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

@@ -48,7 +48,7 @@ export function normalizePermissionRequest(input: PermissionRequest | LegacyPerm
     always: input.save ?? [],
     metadata: input.metadata ?? {},
     tool:
-      input.source?.type === "tool" ? { messageID: input.source.messageID, callID: input.source.callID } : undefined,
+      input.source?.type === "tool" ? { messageID: input.source.messageID, callID: input.source.id } : undefined,
   }
 }
 

packages/app/src/context/server-sdk.test.ts

@@ -21,12 +21,24 @@ describe("adaptServerEvent", () => {
       id: "evt_1",
       created: 1,
       type: "permission.asked",
-      data: { id: "perm_1", sessionID: "ses_1", action: "read", resources: ["src/**"] },
+      data: {
+        id: "perm_1",
+        sessionID: "ses_1",
+        action: "read",
+        resources: ["src/**"],
+        source: { type: "tool", messageID: "msg_1", id: "call_1" },
+      },
     } as OpenCodeEvent
 
     expect(adaptServerEvent(current)).toMatchObject({
       type: "permission.asked",
-      properties: { id: "perm_1", sessionID: "ses_1", permission: "read", patterns: ["src/**"] },
+      properties: {
+        id: "perm_1",
+        sessionID: "ses_1",
+        permission: "read",
+        patterns: ["src/**"],
+        tool: { messageID: "msg_1", callID: "call_1" },
+      },
       current,
     })
   })
@@ -70,6 +82,26 @@ describe("coalesceServerEvents", () => {
     expect(result[0]?.payload.current).toMatchObject({ id: "evt_2", data: { delta: "hello world" } })
   })
 
+  test("coalesces current tool input deltas by tool ID", () => {
+    const current = (eventID: string, id: string, delta: string) =>
+      adaptServerEvent({
+        id: eventID,
+        created: 1,
+        type: "session.tool.input.delta",
+        location: { directory: "/repo" },
+        data: { sessionID: "ses", assistantMessageID: "msg", id, delta },
+      } as OpenCodeEvent)
+    const result = coalesceServerEvents([
+      { directory: "/repo", payload: current("evt_1", "call_1", "{") },
+      { directory: "/repo", payload: current("evt_2", "call_1", "}") },
+      { directory: "/repo", payload: current("evt_3", "call_2", "[]") },
+    ])
+
+    expect(result).toHaveLength(2)
+    expect(result[0]?.payload.current).toMatchObject({ id: "evt_2", data: { id: "call_1", delta: "{}" } })
+    expect(result[1]?.payload.current).toMatchObject({ id: "evt_3", data: { id: "call_2", delta: "[]" } })
+  })
+
   test("preserves event boundaries and distinct fields", () => {
     const status = {
       directory: "/repo",

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

@@ -39,7 +39,7 @@ export function adaptServerEvent(event: OpenCodeEvent): ServerEvent {
         metadata: event.data.metadata ?? {},
         tool:
           event.data.source?.type === "tool"
-            ? { messageID: event.data.source.messageID, callID: event.data.source.callID }
+            ? { messageID: event.data.source.messageID, callID: event.data.source.id }
             : undefined,
       },
       current: event,
@@ -142,7 +142,7 @@ function currentDelta(event: OpenCodeEvent | undefined): CurrentDelta | undefine
 
 function currentDeltaKey(event: CurrentDelta) {
   if (event.type === "session.tool.input.delta")
-    return `${event.type}:${event.data.sessionID}:${event.data.assistantMessageID}:${event.data.callID}`
+    return `${event.type}:${event.data.sessionID}:${event.data.assistantMessageID}:${event.data.id}`
   if (event.type === "session.compaction.delta") return `${event.type}:${event.data.sessionID}`
   return `${event.type}:${event.data.sessionID}:${event.data.assistantMessageID}:${event.data.ordinal}`
 }

packages/app/src/context/server-session-v2-reducer.test.ts

@@ -92,19 +92,19 @@ describe("v2 session reducer", () => {
       ...base,
       id: "evt_tool_start",
       type: "session.tool.input.started",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", callID: "call_1", name: "bash" },
+      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", id: "call_1", name: "bash" },
     })
     apply({
       ...base,
       id: "evt_tool_delta",
       type: "session.tool.input.delta",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", callID: "call_1", delta: "{}" },
+      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", id: "call_1", delta: "{}" },
     })
     apply({
       ...base,
       id: "evt_tool_called",
       type: "session.tool.called",
-      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", callID: "call_1", input: {}, executed: true },
+      data: { sessionID: "ses_1", assistantMessageID: "msg_assistant", id: "call_1", input: {}, executed: true },
     })
     apply({
       ...base,
@@ -113,7 +113,7 @@ describe("v2 session reducer", () => {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_assistant",
-        callID: "call_1",
+        id: "call_1",
         metadata: {},
         content: [{ type: "text", text: "done" }],
         executed: true,

packages/app/src/context/server-session-v2-reducer.ts

@@ -241,13 +241,13 @@ export function createV2SessionReducer() {
       case "session.tool.input.started":
         return updateAssistant(source, event.data.assistantMessageID, sessionID, (item) => ({
           ...item,
-          content: item.content.some((content) => content.type === "tool" && content.id === event.data.callID)
+          content: item.content.some((content) => content.type === "tool" && content.id === event.data.id)
             ? item.content
             : [
                 ...item.content,
                 {
                   type: "tool",
-                  id: event.data.callID,
+                  id: event.data.id,
                   name: event.data.name,
                   state: { status: "streaming", input: "" },
                   time: { created: event.created },
@@ -255,17 +255,17 @@ export function createV2SessionReducer() {
               ],
         }))
       case "session.tool.input.delta":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) =>
+        return updateTool(source, event.data.assistantMessageID, event.data.id, sessionID, (tool) =>
           tool.state.status === "streaming"
             ? { ...tool, state: { ...tool.state, input: tool.state.input + event.data.delta } }
             : tool,
         )
       case "session.tool.input.ended":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) =>
+        return updateTool(source, event.data.assistantMessageID, event.data.id, sessionID, (tool) =>
           tool.state.status === "streaming" ? { ...tool, state: { ...tool.state, input: event.data.text } } : tool,
         )
       case "session.tool.called":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) => ({
+        return updateTool(source, event.data.assistantMessageID, event.data.id, sessionID, (tool) => ({
           ...tool,
           executed: event.data.executed,
           providerState: event.data.state,
@@ -274,7 +274,7 @@ export function createV2SessionReducer() {
           time: { ...tool.time, ran: event.created },
         }))
       case "session.tool.progress":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) =>
+        return updateTool(source, event.data.assistantMessageID, event.data.id, sessionID, (tool) =>
           tool.state.status === "running"
             ? {
                 ...tool,
@@ -284,7 +284,7 @@ export function createV2SessionReducer() {
             : tool,
         )
       case "session.tool.success":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) => {
+        return updateTool(source, event.data.assistantMessageID, event.data.id, sessionID, (tool) => {
           if (tool.state.status !== "running") return tool
           return {
             ...tool,
@@ -302,7 +302,7 @@ export function createV2SessionReducer() {
           }
         })
       case "session.tool.failed":
-        return updateTool(source, event.data.assistantMessageID, event.data.callID, sessionID, (tool) => {
+        return updateTool(source, event.data.assistantMessageID, event.data.id, sessionID, (tool) => {
           if (tool.state.status !== "streaming" && tool.state.status !== "running") return tool
           return {
             ...tool,

packages/cli/src/acp/event.ts

@@ -72,7 +72,7 @@ export async function streamTurn(input: {
       if (next.done) throw new Error("event stream disconnected during prompt execution")
       const event = next.value
       if (event.type === "permission.asked" && event.data.sessionID === input.sessionID) {
-        const tool = event.data.source?.callID ? tools.get(event.data.source.callID) : undefined
+        const tool = event.data.source?.id ? tools.get(event.data.source.id) : undefined
         await replyPermission({
           client: input.client,
           connection: input.connection,
@@ -120,11 +120,11 @@ export async function streamTurn(input: {
       }
       if (event.type === "session.tool.input.started") {
         assistantMessageID = event.data.assistantMessageID
-        tools.set(event.data.callID, { name: event.data.name, input: {}, metadata: {}, content: [] })
+        tools.set(event.data.id, { name: event.data.name, input: {}, metadata: {}, content: [] })
         await update({
           sessionUpdate: "tool_call",
           ...pendingToolCall({
-            toolCallId: event.data.callID,
+            toolCallId: event.data.id,
             toolName: event.data.name,
             state: { input: {} },
             cwd: input.cwd,
@@ -134,13 +134,13 @@ export async function streamTurn(input: {
       }
       if (event.type === "session.tool.called") {
         assistantMessageID = event.data.assistantMessageID
-        const current = tools.get(event.data.callID) ?? emptyToolState()
+        const current = tools.get(event.data.id) ?? emptyToolState()
         current.input = event.data.input
-        tools.set(event.data.callID, current)
+        tools.set(event.data.id, current)
         await update({
           sessionUpdate: "tool_call_update",
           ...runningToolUpdate({
-            toolCallId: event.data.callID,
+            toolCallId: event.data.id,
             toolName: current.name,
             state: { input: current.input },
             cwd: input.cwd,
@@ -149,13 +149,13 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.progress") {
-        const current = tools.get(event.data.callID)
+        const current = tools.get(event.data.id)
         if (!current) continue
         current.metadata = event.data.metadata
         await update({
           sessionUpdate: "tool_call_update",
           ...runningToolUpdate({
-            toolCallId: event.data.callID,
+            toolCallId: event.data.id,
             toolName: current.name,
             state: { input: current.input },
             cwd: input.cwd,
@@ -164,8 +164,8 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.success") {
-        const current = tools.get(event.data.callID) ?? emptyToolState()
-        tools.delete(event.data.callID)
+        const current = tools.get(event.data.id) ?? emptyToolState()
+        tools.delete(event.data.id)
         await syncEditedFiles({
           connection: input.connection,
           writeTextFile: input.writeTextFile,
@@ -178,7 +178,7 @@ export async function streamTurn(input: {
         await update({
           sessionUpdate: "tool_call_update",
           ...completedToolUpdate({
-            toolCallId: event.data.callID,
+            toolCallId: event.data.id,
             toolName: current.name,
             input: current.input,
             metadata: event.data.metadata,
@@ -188,12 +188,12 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.failed") {
-        const current = tools.get(event.data.callID) ?? emptyToolState()
-        tools.delete(event.data.callID)
+        const current = tools.get(event.data.id) ?? emptyToolState()
+        tools.delete(event.data.id)
         await update({
           sessionUpdate: "tool_call_update",
           ...errorToolUpdate({
-            toolCallId: event.data.callID,
+            toolCallId: event.data.id,
             toolName: current.name,
             input: current.input,
             metadata: event.data.metadata ?? current.metadata,

packages/cli/src/acp/permission.ts

@@ -31,7 +31,7 @@ export async function replyPermission(input: {
       sessionId: input.sessionID,
       toolCall: {
         ...pendingToolCall({
-          toolCallId: input.event.data.source?.callID ?? input.event.data.id,
+          toolCallId: input.event.data.source?.id ?? input.event.data.id,
           toolName,
           state: { input: toolInput, title: permissionTitle(toolName, toolInput, previews) },
           cwd: input.cwd,

packages/cli/src/run/noninteractive.ts

@@ -300,7 +300,7 @@ export async function runNonInteractivePrompt(input: Input) {
 
       if (event.type === "session.tool.input.started") {
         flushStep()
-        tools.set(toolKey(event.data.assistantMessageID, event.data.callID), {
+        tools.set(toolKey(event.data.assistantMessageID, event.data.id), {
           id: partID(event.id),
           timestamp: time,
           assistantMessageID: event.data.assistantMessageID,
@@ -312,18 +312,18 @@ export async function runNonInteractivePrompt(input: Input) {
         continue
       }
       if (event.type === "session.tool.input.ended") {
-        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.callID))
+        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.id))
         if (current) current.raw = event.data.text
         continue
       }
       if (event.type === "session.tool.input.delta") {
-        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.callID))
+        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.id))
         if (current) current.raw = (current.raw ?? "") + event.data.delta
         continue
       }
       if (event.type === "session.tool.called") {
         flushStep()
-        const key = toolKey(event.data.assistantMessageID, event.data.callID)
+        const key = toolKey(event.data.assistantMessageID, event.data.id)
         const current = tools.get(key)
         tools.set(key, {
           id: current?.id ?? partID(event.id),
@@ -340,18 +340,18 @@ export async function runNonInteractivePrompt(input: Input) {
         continue
       }
       if (event.type === "session.tool.progress") {
-        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.callID))
+        const current = tools.get(toolKey(event.data.assistantMessageID, event.data.id))
         if (current) {
           current.metadata = event.data.metadata
         }
         continue
       }
       if (event.type === "session.tool.success") {
-        const key = toolKey(event.data.assistantMessageID, event.data.callID)
+        const key = toolKey(event.data.assistantMessageID, event.data.id)
         const current = tools.get(key) ?? fallbackTool(event)
         const tool: SessionMessageAssistantTool = {
           type: "tool",
-          id: event.data.callID,
+          id: event.data.id,
           name: current.tool,
           executed: event.data.executed,
           providerState: current.providerState,
@@ -365,11 +365,11 @@ export async function runNonInteractivePrompt(input: Input) {
           time: { created: current.timestamp, ran: current.timestamp, completed: time },
         }
         const part: MiniToolPart = {
-          id: current.id,
+          partID: current.id,
           sessionID: input.sessionID,
           messageID: event.data.assistantMessageID,
           type: "tool",
-          callID: event.data.callID,
+          id: event.data.id,
           tool: current.tool,
           state: {
             status: "completed",
@@ -392,14 +392,14 @@ export async function runNonInteractivePrompt(input: Input) {
         continue
       }
       if (event.type === "session.tool.failed") {
-        const key = toolKey(event.data.assistantMessageID, event.data.callID)
+        const key = toolKey(event.data.assistantMessageID, event.data.id)
         const current = tools.get(key) ?? fallbackTool(event)
         const error = event.data.error.message
         const metadata = event.data.metadata ?? current.metadata
         const content = event.data.content ?? nonEmptyToolContent(current.content)
         const tool: SessionMessageAssistantTool = {
           type: "tool",
-          id: event.data.callID,
+          id: event.data.id,
           name: current.tool,
           executed: event.data.executed,
           providerState: current.providerState,
@@ -414,11 +414,11 @@ export async function runNonInteractivePrompt(input: Input) {
           time: { created: current.timestamp, ran: current.timestamp, completed: time },
         }
         const part: MiniToolPart = {
-          id: current.id,
+          partID: current.id,
           sessionID: input.sessionID,
           messageID: event.data.assistantMessageID,
           type: "tool",
-          callID: event.data.callID,
+          id: event.data.id,
           tool: current.tool,
           state: {
             status: "error",
@@ -470,7 +470,7 @@ export async function runNonInteractivePrompt(input: Input) {
       if (event.type === "session.step.failed") {
         if (
           input.compatibility === "v1" &&
-          event.data.error.message === "Provider stream ended without a terminal finish event"
+          event.data.error.message === "The provider response ended unexpectedly."
         ) {
           pendingStep = undefined
           v1InvalidOutput = true
@@ -578,11 +578,11 @@ export async function runNonInteractivePrompt(input: Input) {
         const key = toolKey(message.id, item.id)
         if (renderedTools.has(key) || item.state.status === "streaming" || item.state.status === "running") continue
         const part: MiniToolPart = {
-          id: projectedPartID(message.id, `tool-${item.id}`),
+          partID: projectedPartID(message.id, `tool-${item.id}`),
           sessionID: input.sessionID,
           messageID: message.id,
           type: "tool",
-          callID: item.id,
+          id: item.id,
           tool: item.name,
           state:
             item.state.status === "completed"
@@ -771,8 +771,8 @@ function partID(eventID: string) {
   return `prt_${eventID.replace(/^evt_/, "")}`
 }
 
-function toolKey(messageID: string, callID: string) {
-  return `${messageID}\u0000${callID}`
+function toolKey(messageID: string, id: string) {
+  return `${messageID}\u0000${id}`
 }
 
 function contentKey(messageID: string, ordinal: number) {
@@ -786,7 +786,7 @@ function projectedPartID(messageID: string, part: string) {
 function fallbackTool(event: {
   id: string
   created: number
-  data: { assistantMessageID: string; callID: string }
+  data: { assistantMessageID: string; id: string }
 }): ToolState {
   return {
     id: partID(event.id),

packages/cli/test/acp/event-behavior.test.ts

@@ -200,7 +200,7 @@ describe("acp event behavior", () => {
           durableEvent("session.tool.input.started", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_ok",
+            id: "call_ok",
             name: "shell",
           }),
         )
@@ -208,7 +208,7 @@ describe("acp event behavior", () => {
           durableEvent("session.tool.called", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_ok",
+            id: "call_ok",
             input: { command: "printf done", workdir: "sub" },
             executed: false,
           }),
@@ -217,7 +217,7 @@ describe("acp event behavior", () => {
           ephemeralEvent("session.tool.progress", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_ok",
+            id: "call_ok",
             metadata: { phase: 1 },
           }),
         )
@@ -225,7 +225,7 @@ describe("acp event behavior", () => {
           durableEvent("session.tool.success", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_ok",
+            id: "call_ok",
             metadata: { exit: 0 },
             content: [{ type: "text", text: "done" }],
             executed: true,
@@ -235,7 +235,7 @@ describe("acp event behavior", () => {
           durableEvent("session.tool.input.started", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_fail",
+            id: "call_fail",
             name: "read",
           }),
         )
@@ -243,7 +243,7 @@ describe("acp event behavior", () => {
           durableEvent("session.tool.called", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_fail",
+            id: "call_fail",
             input: { path: "/workspace/missing.ts" },
             executed: false,
           }),
@@ -252,7 +252,7 @@ describe("acp event behavior", () => {
           ephemeralEvent("session.tool.progress", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_fail",
+            id: "call_fail",
             metadata: { bytes: 0 },
           }),
         )
@@ -260,7 +260,7 @@ describe("acp event behavior", () => {
           durableEvent("session.tool.failed", {
             sessionID: "ses_tools",
             assistantMessageID: "msg_tools",
-            callID: "call_fail",
+            id: "call_fail",
             error: { type: "tool.error", message: "not found" },
             metadata: { bytes: 0 },
             content: [{ type: "text", text: "opening" }],

packages/cli/test/acp/permission-behavior.test.ts

@@ -43,14 +43,14 @@ describe("acp permission behavior", () => {
           permissionAsked("ses_allow", "perm_once", {
             action: "shell",
             metadata: { command: "printf hello" },
-            source: { type: "tool", messageID: "msg_allow", callID: "call_once" },
+            source: { type: "tool", messageID: "msg_allow", id: "call_once" },
           }),
         )
         send(
           permissionAsked("ses_allow", "perm_always", {
             action: "read",
             metadata: { path: "/workspace/file.ts" },
-            source: { type: "tool", messageID: "msg_allow", callID: "call_always" },
+            source: { type: "tool", messageID: "msg_allow", id: "call_always" },
           }),
         )
         send(durableEvent("session.execution.succeeded", { sessionID: "ses_allow" }))
@@ -166,7 +166,7 @@ describe("acp permission behavior", () => {
           durableEvent("session.tool.input.started", {
             sessionID: "ses_edit",
             assistantMessageID: "msg_edit",
-            callID: "call_edit",
+            id: "call_edit",
             name: "edit",
           }),
         )
@@ -174,7 +174,7 @@ describe("acp permission behavior", () => {
           durableEvent("session.tool.called", {
             sessionID: "ses_edit",
             assistantMessageID: "msg_edit",
-            callID: "call_edit",
+            id: "call_edit",
             input: { path: "file.ts", oldString: "before", newString: "after" },
             executed: false,
           }),
@@ -182,7 +182,7 @@ describe("acp permission behavior", () => {
         send(
           permissionAsked("ses_edit", "perm_edit", {
             action: "edit",
-            source: { type: "tool", messageID: "msg_edit", callID: "call_edit" },
+            source: { type: "tool", messageID: "msg_edit", id: "call_edit" },
           }),
         )
       },
@@ -192,7 +192,7 @@ describe("acp permission behavior", () => {
           durableEvent("session.tool.success", {
             sessionID: "ses_edit",
             assistantMessageID: "msg_edit",
-            callID: "call_edit",
+            id: "call_edit",
             metadata: { files: [{ file: "file.ts" }], replacements: 1 },
             content: [{ type: "text", text: "edited" }],
             executed: true,
@@ -256,7 +256,7 @@ describe("acp permission behavior", () => {
           durableEvent("session.tool.input.started", {
             sessionID: "ses_patch",
             assistantMessageID: "msg_patch",
-            callID: "call_patch",
+            id: "call_patch",
             name: "patch",
           }),
         )
@@ -264,7 +264,7 @@ describe("acp permission behavior", () => {
           durableEvent("session.tool.called", {
             sessionID: "ses_patch",
             assistantMessageID: "msg_patch",
-            callID: "call_patch",
+            id: "call_patch",
             input: { patchText },
             executed: false,
           }),
@@ -272,7 +272,7 @@ describe("acp permission behavior", () => {
         send(
           permissionAsked("ses_patch", "perm_patch", {
             action: "edit",
-            source: { type: "tool", messageID: "msg_patch", callID: "call_patch" },
+            source: { type: "tool", messageID: "msg_patch", id: "call_patch" },
           }),
         )
       },
@@ -285,7 +285,7 @@ describe("acp permission behavior", () => {
           durableEvent("session.tool.success", {
             sessionID: "ses_patch",
             assistantMessageID: "msg_patch",
-            callID: "call_patch",
+            id: "call_patch",
             metadata: { files: [{ file: "first.ts" }, { file: "second.ts" }] },
             content: [{ type: "text", text: "patched" }],
             executed: true,
@@ -499,7 +499,7 @@ function permissionAsked(
   input: {
     readonly action?: string
     readonly metadata?: Record<string, unknown>
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
   } = {},
 ) {
   return ephemeralEvent("permission.asked", {

packages/cli/test/run/noninteractive.test.ts

@@ -109,7 +109,7 @@ function failedTool(inputID: string): V2Event[] {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_failed_tool",
-        callID: "call_failed_tool",
+        id: "call_failed_tool",
         name: "shell",
       },
     },
@@ -121,7 +121,7 @@ function failedTool(inputID: string): V2Event[] {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_failed_tool",
-        callID: "call_failed_tool",
+        id: "call_failed_tool",
         input: { command: "printf partial && false" },
         executed: true,
       },
@@ -133,7 +133,7 @@ function failedTool(inputID: string): V2Event[] {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_failed_tool",
-        callID: "call_failed_tool",
+        id: "call_failed_tool",
         metadata: { checkpoint: 1 },
       },
     },
@@ -145,7 +145,7 @@ function failedTool(inputID: string): V2Event[] {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_failed_tool",
-        callID: "call_failed_tool",
+        id: "call_failed_tool",
         error: { type: "unknown", message: "tool failed" },
         metadata: { checkpoint: 1 },
         content: [{ type: "text", text: "partial output" }],
@@ -168,7 +168,7 @@ function successfulGrep(inputID: string): V2Event[] {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_grep",
-        callID: "call_grep",
+        id: "call_grep",
         name: "grep",
       },
     },
@@ -180,7 +180,7 @@ function successfulGrep(inputID: string): V2Event[] {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_grep",
-        callID: "call_grep",
+        id: "call_grep",
         input: { pattern: "needle" },
         executed: true,
       },
@@ -193,7 +193,7 @@ function successfulGrep(inputID: string): V2Event[] {
       data: {
         sessionID: "ses_1",
         assistantMessageID: "msg_grep",
-        callID: "call_grep",
+        id: "call_grep",
         metadata: { matches: 2 },
         content: [{ type: "text", text }],
         executed: false,
@@ -503,8 +503,8 @@ describe("runNonInteractivePrompt", () => {
       turn: (messageID) => [
         prompted(messageID),
         stepStarted(),
-        stepFailed("Provider stream ended without a terminal finish event"),
-        executionFailed("Provider stream ended without a terminal finish event"),
+        stepFailed("The provider response ended unexpectedly."),
+        executionFailed("The provider response ended unexpectedly."),
       ],
     })
 
@@ -561,7 +561,7 @@ describe("runNonInteractivePrompt", () => {
       type: "tool_use",
       part: {
         type: "tool",
-        callID: "call_failed_tool",
+        id: "call_failed_tool",
         tool: "shell",
         state: {
           status: "error",

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

@@ -605,7 +605,7 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
-            readonly callID: string
+            readonly id: string
             readonly name: string
           }
         }
@@ -619,7 +619,7 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
-            readonly callID: string
+            readonly id: string
             readonly text: string
           }
         }
@@ -633,7 +633,7 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
-            readonly callID: string
+            readonly id: string
             readonly input: { readonly [x: string]: unknown }
             readonly executed: boolean
             readonly state?: SessionMessage.ProviderState | undefined
@@ -649,7 +649,7 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
-            readonly callID: string
+            readonly id: string
             readonly content: readonly [
               (
                 | { readonly type: "text"; readonly text: string }
@@ -685,7 +685,7 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
-            readonly callID: string
+            readonly id: string
             readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
             readonly content?:
               | readonly [

packages/client/src/effect/service.ts

@@ -56,7 +56,6 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
-  let ownerHeld = false
   const announce = (reason: "missing" | "version-mismatch", previousVersion?: string) =>
     Effect.sync(() => {
       if (announced) return
@@ -84,7 +83,6 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
     const info = registration.info
     const service = registration.service
     if (service !== undefined) {
-      ownerHeld = false
       spawnDelay = 5_000
       const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
       if (compatible && service.state === "ready") return Option.some(service)
@@ -97,14 +95,13 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
       return Option.none<LocalService>()
     } else if (lastSpawn === 0 && info !== undefined) lastSpawn = Date.now()
 
-    const failure = [...contenders].map(contenderFailure).find((error): error is Error => error !== undefined)
-    if (failure !== undefined) return yield* Effect.fail(failure)
     const finished = [...contenders].filter(contenderFinished)
+    const failure = finished.map(contenderFailure).find((error): error is Error => error !== undefined)
     if (finished.some((item) => item.child.exitCode === 0)) {
-      ownerHeld = true
       spawnDelay = Math.min(spawnDelay * 2, 30_000)
     }
     finished.forEach((item) => contenders.delete(item))
+    if (failure !== undefined && contenders.size === 0) return yield* Effect.fail(failure)
     // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
     if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
       yield* announce("missing")

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

@@ -297,7 +297,7 @@ export type FormExternalField = { key: string; type: "external"; url: string; ti
 
 export type FormValue = string | number | boolean | Array<string>
 
-export type PermissionSource = { type: "tool"; messageID: string; callID: string }
+export type PermissionSource = { type: "tool"; messageID: string; id: string }
 
 export type PermissionSavedInfo = { id: string; projectID: string; action: string; resource: string }
 
@@ -486,7 +486,7 @@ export type Pty = {
 
 export type QuestionOption = { label: string; description: string }
 
-export type QuestionTool = { messageID: string; callID: string }
+export type QuestionTool = { messageID: string; id: string }
 
 export type QuestionAnswer = Array<string>
 
@@ -744,7 +744,7 @@ export type SessionToolInputStarted = {
   type: "session.tool.input.started"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; assistantMessageID: string; callID: string; name: string }
+  data: { sessionID: string; assistantMessageID: string; id: string; name: string }
 }
 
 export type SessionToolInputEnded = {
@@ -754,7 +754,7 @@ export type SessionToolInputEnded = {
   type: "session.tool.input.ended"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; assistantMessageID: string; callID: string; text: string }
+  data: { sessionID: string; assistantMessageID: string; id: string; text: string }
 }
 
 export type SessionCompactionAdmitted = {
@@ -915,7 +915,7 @@ export type SessionToolInputDelta = {
   metadata?: { [x: string]: any }
   type: "session.tool.input.delta"
   location?: LocationRef
-  data: { sessionID: string; assistantMessageID: string; callID: string; delta: string }
+  data: { sessionID: string; assistantMessageID: string; id: string; delta: string }
 }
 
 export type SessionToolProgress = {
@@ -924,7 +924,7 @@ export type SessionToolProgress = {
   metadata?: { [x: string]: any }
   type: "session.tool.progress"
   location?: LocationRef
-  data: { sessionID: string; assistantMessageID: string; callID: string; metadata: { [x: string]: JsonValue } }
+  data: { sessionID: string; assistantMessageID: string; id: string; metadata: { [x: string]: JsonValue } }
 }
 
 export type SessionCompactionDelta = {
@@ -1380,7 +1380,7 @@ export type SessionToolCalled = {
   data: {
     sessionID: string
     assistantMessageID: string
-    callID: string
+    id: string
     input: { [x: string]: any }
     executed: boolean
     state?: SessionMessageProviderState7
@@ -1831,7 +1831,7 @@ export type SessionToolSuccess = {
   data: {
     sessionID: string
     assistantMessageID: string
-    callID: string
+    id: string
     content: [ToolContent1, ...Array<ToolContent1>]
     metadata?: { [x: string]: JsonValue }
     executed: boolean
@@ -1849,7 +1849,7 @@ export type SessionToolFailed = {
   data: {
     sessionID: string
     assistantMessageID: string
-    callID: string
+    id: string
     error: SessionStructuredError
     content?: [ToolContent1, ...Array<ToolContent1>]
     metadata?: { [x: string]: JsonValue }
@@ -4472,7 +4472,7 @@ export type PermissionCreateInput = {
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["id"]
   readonly action: {
@@ -4481,7 +4481,7 @@ export type PermissionCreateInput = {
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["action"]
   readonly resources: {
@@ -4490,7 +4490,7 @@ export type PermissionCreateInput = {
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["resources"]
   readonly save?: {
@@ -4499,7 +4499,7 @@ export type PermissionCreateInput = {
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["save"]
   readonly metadata?: {
@@ -4508,7 +4508,7 @@ export type PermissionCreateInput = {
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["metadata"]
   readonly source?: {
@@ -4517,7 +4517,7 @@ export type PermissionCreateInput = {
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["source"]
   readonly agent?: {
@@ -4526,7 +4526,7 @@ export type PermissionCreateInput = {
     readonly resources: ReadonlyArray<string>
     readonly save?: ReadonlyArray<string>
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly callID: string }
+    readonly source?: { readonly type: "tool"; readonly messageID: string; readonly id: string }
     readonly agent?: string | null
   }["agent"]
 }

packages/client/src/promise/service.ts

@@ -37,7 +37,6 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   let announced = false
   let lastSpawn = 0
   let spawnDelay = 5_000
-  let ownerHeld = false
 
   const announce = (reason: "missing" | "version-mismatch", previousVersion?: string) => {
     if (announced) return
@@ -65,7 +64,6 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
     const registration = await registered(options.file, true)
 
     if (registration.service !== undefined) {
-      ownerHeld = false
       spawnDelay = 5_000
       const service = registration.service
       const compatible = !service.legacy && (options.version === undefined || service.version === options.version)
@@ -78,14 +76,13 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
       }
     } else {
       if (lastSpawn === 0 && registration.info !== undefined) lastSpawn = Date.now()
-      const failure = [...contenders].map(contenderFailure).find((error) => error !== undefined)
-      if (failure !== undefined) throw failure
       const finished = [...contenders].filter(contenderFinished)
+      const failure = finished.map(contenderFailure).find((error) => error !== undefined)
       if (finished.some((item) => item.child.exitCode === 0)) {
-        ownerHeld = true
         spawnDelay = Math.min(spawnDelay * 2, 30_000)
       }
       finished.forEach((item) => contenders.delete(item))
+      if (failure !== undefined && contenders.size === 0) throw failure
       // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
       if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
         announce("missing")

packages/client/test/fixture/service.ts

@@ -9,14 +9,20 @@ if (mode === "record-start") {
 }
 if (mode === "signal") process.kill(process.pid, process.platform === "win32" ? "SIGTERM" : "SIGKILL")
 
-if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated") {
+if (
+  mode === "delayed" ||
+  mode === "delayed-failed" ||
+  mode === "coordinated" ||
+  mode === "coordinated-failed-loser"
+) {
   await appendFile(registration + ".starts", process.pid + "\n")
   const owner = await writeFile(registration + ".owner", String(process.pid), { flag: "wx" })
     .then(() => true)
     .catch(() => false)
-  if (!owner) process.exit()
-  if (mode === "coordinated") {
+  if (!owner) process.exit(mode === "coordinated-failed-loser" ? 1 : 0)
+  if (mode === "coordinated" || mode === "coordinated-failed-loser") {
     while ((await Bun.file(registration + ".starts").text()).trim().split("\n").length < 2) await Bun.sleep(10)
+    if (mode === "coordinated-failed-loser") await Bun.sleep(1_500)
   } else await Bun.sleep(Number(delay))
   if (mode === "delayed-failed") process.exit(1)
 }

packages/client/test/promise-service.test.ts

@@ -44,6 +44,24 @@ test("ensures a missing service with native promises", async () => {
   }
 }, 15_000)
 
+test("waits for a live contender when another native contender fails", async () => {
+  const directory = await temp()
+  const registration = join(directory, "service.json")
+
+  const endpoint = await Service.ensure({
+    file: registration,
+    version: "test",
+    command: [process.execPath, fixture, registration, "coordinated-failed-loser"],
+  })
+  const info = await Bun.file(registration).json()
+  try {
+    expect(endpoint.url).toBe(info.url)
+  } finally {
+    process.kill(info.pid, "SIGTERM")
+    await waitForExit(info.pid)
+  }
+}, 15_000)
+
 test("reports a failed registered service", async () => {
   const registration = await setup("failed-owner")
 

packages/client/test/service.test.ts

@@ -141,6 +141,24 @@ test("waits for a slow winner while bounding lock probes", async () => {
   }
 }, 15_000)
 
+test("waits for a live contender when another contender fails", async () => {
+  const directory = await temp()
+  const registration = join(directory, "service.json")
+  const endpoint = await run(
+    Service.ensure({
+      file: registration,
+      version: "test",
+      command: [process.execPath, fixture, registration, "coordinated-failed-loser"],
+    }),
+  )
+  const info = await Bun.file(registration).json()
+  try {
+    expect(endpoint.url).toBe(info.url)
+  } finally {
+    process.kill(info.pid, "SIGTERM")
+  }
+}, 15_000)
+
 test("reports a contender that fails to start", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")

packages/core/src/aisdk-native.ts

@@ -27,6 +27,21 @@ export function map(input: MapInput): Mapping | undefined {
       }
     case "@ai-sdk/amazon-bedrock/mantle":
       return mapBedrockMantle(input, baseSettings)
+    case "@ai-sdk/azure":
+      return {
+        package: `@opencode-ai/ai/providers/azure/${input.settings.useCompletionUrls === true ? "chat" : "responses"}`,
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          ...(typeof input.settings.resourceName === "string" ? { resourceName: input.settings.resourceName } : {}),
+          ...(typeof input.settings.apiVersion === "string" ? { apiVersion: input.settings.apiVersion } : {}),
+          ...(isStringRecord(input.settings.queryParams) ? { queryParams: input.settings.queryParams } : {}),
+          ...(typeof input.settings.useDeploymentBasedUrls === "boolean"
+            ? { useDeploymentBasedUrls: input.settings.useDeploymentBasedUrls }
+            : {}),
+          ...mapOpenAIOptions(input.settings),
+        },
+      }
     case "@ai-sdk/google":
       return {
         package: "@opencode-ai/ai/providers/google",

packages/core/src/catalog.ts

@@ -213,7 +213,7 @@ const layer = Layer.effect(
           const provider = record.provider
 
           // TODO: Remove these provider-specific assumptions once model syncing reliably reports available deployments.
-          if (providerID === Provider.ID.azure || providerID === Provider.ID.make("azure-cognitive-services")) {
+          if (providerID === Provider.ID.azure) {
             return
           }
 

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

@@ -12,96 +12,84 @@ export const Plugin = define({
     const config = yield* Config.Service
     const loaded = { entries: yield* config.entries() }
     yield* ctx.integration.transform((integrations) => {
-      const files = loaded.entries.filter((entry): entry is Config.Document => entry.type === "document")
       const configuredIntegrations = new Set(
-        files.flatMap((file) =>
-          Object.entries(file.info.providers ?? {}).flatMap(([id, provider]) =>
-            provider.env === undefined ? [] : [id],
-          ),
-        ),
+        configuredProviders(loaded.entries).flatMap(([id, provider]) => (provider.env === undefined ? [] : [id])),
       )
-      for (const file of files) {
-        for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-          const integrationID = id
-          if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
-          integrations.update(integrationID, (integration) => {
-            integration.name = item.name ?? integration.name
+      for (const [id, provider] of configuredProviders(loaded.entries)) {
+        const integrationID = id
+        if (!configuredIntegrations.has(id) && !integrations.get(integrationID)) continue
+        integrations.update(integrationID, (integration) => {
+          integration.name = provider.name ?? integration.name
+        })
+        if (provider.env !== undefined) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "env", names: [...provider.env] },
           })
-          if (item.env !== undefined) {
-            integrations.method.update({
-              integrationID,
-              method: { type: "env", names: [...item.env] },
-            })
-          }
         }
       }
     })
 
     yield* ctx.catalog.transform((catalog) => {
-      const files = loaded.entries.filter((entry): entry is Config.Document => entry.type === "document")
       const configuredDefault = Config.latest(loaded.entries, "model")
       if (configuredDefault !== undefined)
         catalog.model.default.set(configuredDefault.providerID, configuredDefault.model)
-      for (const file of files) {
-        for (const [id, item] of Object.entries(file.info.providers ?? {})) {
-          const providerID = id
-          catalog.provider.update(providerID, (provider) => {
-            if (item.name !== undefined) provider.name = item.name
-            if (item.package !== undefined) provider.package = item.package
-            if (item.settings !== undefined)
-              provider.settings = Provider.mergeOverlay(provider.settings, item.settings)
-            if (item.headers !== undefined) provider.headers = Provider.mergeHeaders(provider.headers, item.headers)
-            if (item.body !== undefined) provider.body = Provider.mergeOverlay(provider.body, item.body)
+      for (const [id, item] of configuredProviders(loaded.entries)) {
+        const providerID = id
+        catalog.provider.update(providerID, (provider) => {
+          if (item.name !== undefined) provider.name = item.name
+          if (item.package !== undefined) provider.package = item.package
+          if (item.settings !== undefined) provider.settings = Provider.mergeOverlay(provider.settings, item.settings)
+          if (item.headers !== undefined) provider.headers = Provider.mergeHeaders(provider.headers, item.headers)
+          if (item.body !== undefined) provider.body = Provider.mergeOverlay(provider.body, item.body)
+        })
+        for (const [id, config] of Object.entries(item.models ?? {})) {
+          catalog.model.update(providerID, id, (model) => {
+            if (config.family !== undefined) model.family = config.family
+            if (config.name !== undefined) model.name = config.name
+            if (config.modelID !== undefined) model.modelID = config.modelID
+            if (config.compatibility !== undefined)
+              model.compatibility = { ...model.compatibility, ...config.compatibility }
+            if (config.package !== undefined) model.package = config.package
+            if (config.settings !== undefined) model.settings = Provider.mergeOverlay(model.settings, config.settings)
+            if (config.headers !== undefined) model.headers = Provider.mergeHeaders(model.headers, config.headers)
+            if (config.body !== undefined) model.body = Provider.mergeOverlay(model.body, config.body)
+            if (config.capabilities !== undefined) {
+              model.capabilities = {
+                tools: config.capabilities.tools,
+                input: [...config.capabilities.input],
+                output: [...config.capabilities.output],
+              }
+            }
+            if (config.variants !== undefined) {
+              model.variants ??= []
+              for (const variant of config.variants) {
+                let existing = model.variants.find((item) => item.id === variant.id)
+                if (!existing) {
+                  existing = { id: variant.id }
+                  model.variants.push(existing)
+                }
+                if (variant.settings !== undefined)
+                  existing.settings = Provider.mergeOverlay(existing.settings, variant.settings)
+                if (variant.headers !== undefined)
+                  existing.headers = Provider.mergeHeaders(existing.headers, variant.headers)
+                if (variant.body !== undefined) existing.body = Provider.mergeOverlay(existing.body, variant.body)
+              }
+            }
+            if (config.cost !== undefined) {
+              model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
+                tier: cost.tier && { ...cost.tier },
+                input: cost.input,
+                output: cost.output,
+                cache: {
+                  read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
+                  write: cost.cache?.write ?? Money.USDPerMillionTokens.zero,
+                },
+              }))
+            }
+            if (config.disabled !== undefined) model.enabled = !config.disabled
+            if (config.limit !== undefined) model.limit = { ...model.limit, ...config.limit }
           })
-          for (const [id, config] of Object.entries(item.models ?? {})) {
-            catalog.model.update(providerID, id, (model) => {
-              if (config.family !== undefined) model.family = config.family
-              if (config.name !== undefined) model.name = config.name
-              if (config.modelID !== undefined) model.modelID = config.modelID
-              if (config.compatibility !== undefined)
-                model.compatibility = { ...model.compatibility, ...config.compatibility }
-              if (config.package !== undefined) model.package = config.package
-              if (config.settings !== undefined)
-                model.settings = Provider.mergeOverlay(model.settings, config.settings)
-              if (config.headers !== undefined) model.headers = Provider.mergeHeaders(model.headers, config.headers)
-              if (config.body !== undefined) model.body = Provider.mergeOverlay(model.body, config.body)
-              if (config.capabilities !== undefined) {
-                model.capabilities = {
-                  tools: config.capabilities.tools,
-                  input: [...config.capabilities.input],
-                  output: [...config.capabilities.output],
-                }
-              }
-              if (config.variants !== undefined) {
-                model.variants ??= []
-                for (const variant of config.variants) {
-                  let existing = model.variants.find((item) => item.id === variant.id)
-                  if (!existing) {
-                    existing = { id: variant.id }
-                    model.variants.push(existing)
-                  }
-                  if (variant.settings !== undefined)
-                    existing.settings = Provider.mergeOverlay(existing.settings, variant.settings)
-                  if (variant.headers !== undefined)
-                    existing.headers = Provider.mergeHeaders(existing.headers, variant.headers)
-                  if (variant.body !== undefined) existing.body = Provider.mergeOverlay(existing.body, variant.body)
-                }
-              }
-              if (config.cost !== undefined) {
-                model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
-                  tier: cost.tier && { ...cost.tier },
-                  input: cost.input,
-                  output: cost.output,
-                  cache: {
-                    read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
-                    write: cost.cache?.write ?? Money.USDPerMillionTokens.zero,
-                  },
-                }))
-              }
-              if (config.disabled !== undefined) model.enabled = !config.disabled
-              if (config.limit !== undefined) model.limit = { ...model.limit, ...config.limit }
-            })
-          }
         }
       }
     })
@@ -118,3 +106,9 @@ export const Plugin = define({
     )
   }),
 })
+
+function configuredProviders(entries: readonly Config.Entry[]) {
+  return entries
+    .filter((entry): entry is Config.Document => entry.type === "document")
+    .flatMap((file) => Object.entries(file.info.providers ?? {}))
+}

packages/core/src/model-resolver.ts

@@ -146,6 +146,20 @@ export const fromCatalogModel = (
     if (draft.settings?.apiKey === "") delete draft.settings.apiKey
     if (credential?.type === "key" && credential.metadata !== undefined)
       draft.body = Provider.mergeOverlay(draft.body, credential.metadata)
+    if (draft.providerID !== Provider.ID.azure) return
+    const configured = draft.settings?.resourceName
+    const resourceName =
+      typeof configured === "string" && configured.trim() !== ""
+        ? configured
+        : (process.env.AZURE_RESOURCE_NAME ?? process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME)
+    if (resourceName) draft.settings = { ...draft.settings, resourceName }
+    if (typeof draft.settings?.baseURL !== "string") return
+    draft.settings.baseURL = draft.settings.baseURL
+      .replaceAll("${AZURE_RESOURCE_NAME}", resourceName ?? "${AZURE_RESOURCE_NAME}")
+      .replaceAll(
+        "${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}",
+        resourceName ?? "${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}",
+      )
   })
   const packageName = Provider.packageName(resolved.package)
   const key = apiKey(resolved, credential)

packages/core/src/plugin/models-dev.ts

@@ -3,13 +3,14 @@ import { Integration } from "@opencode-ai/schema/integration"
 import { Effect, Stream } from "effect"
 import { Bus } from "../bus"
 import { ModelsDev } from "../models-dev"
+import { Provider } from "../provider"
 
 export const ModelsDevPlugin = define({
   id: "opencode.models-dev",
   effect: Effect.fn(function* (ctx) {
     const modelsDev = yield* ModelsDev.Service
     const bus = yield* Bus.Service
-    const loaded = { data: structuredClone(yield* modelsDev.get()) }
+    const loaded = { data: snapshots(yield* modelsDev.get()) }
     yield* ctx.integration.transform((integrations) => {
       for (const provider of loaded.data) {
         if (provider.environment.length === 0) continue
@@ -21,7 +22,10 @@ export const ModelsDevPlugin = define({
         })
         integrations.method.update({
           integrationID,
-          method: { type: "env", names: [...provider.environment] },
+          method: {
+            type: "env",
+            names: environmentNames(provider),
+          },
         })
       }
     })
@@ -39,7 +43,7 @@ export const ModelsDevPlugin = define({
     yield* bus.subscribe(ModelsDev.Event.Refreshed).pipe(
       Stream.runForEach(() =>
         modelsDev.get().pipe(
-          Effect.tap((data) => Effect.sync(() => (loaded.data = structuredClone(data)))),
+          Effect.tap((data) => Effect.sync(() => (loaded.data = snapshots(data)))),
           Effect.andThen(ctx.integration.reload()),
           Effect.andThen(ctx.catalog.reload()),
         ),
@@ -48,3 +52,14 @@ export const ModelsDevPlugin = define({
     )
   }),
 })
+
+function environmentNames(provider: ModelsDev.Snapshot) {
+  if (provider.info.id !== Provider.ID.azure) return [...provider.environment]
+  return [...provider.environment.filter((name) => name.endsWith("_API_KEY")), "AZURE_COGNITIVE_SERVICES_API_KEY"]
+}
+
+function snapshots(data: readonly ModelsDev.Snapshot[]) {
+  return structuredClone(data).filter(
+    (provider) => provider.info.id !== "azure-cognitive-services" && provider.info.id !== "google-vertex-anthropic",
+  )
+}

packages/core/src/plugin/provider.ts

@@ -1,7 +1,7 @@
 import { AlibabaPlugin } from "./provider/alibaba"
 import { AmazonBedrockPlugin } from "./provider/amazon-bedrock"
 import { AnthropicPlugin } from "./provider/anthropic"
-import { AzureCognitiveServicesPlugin, AzurePlugin } from "./provider/azure"
+import { AzurePlugin } from "./provider/azure"
 import { CerebrasPlugin } from "./provider/cerebras"
 import { CloudflareAIGatewayPlugin } from "./provider/cloudflare-ai-gateway"
 import { CloudflareWorkersAIPlugin } from "./provider/cloudflare-workers-ai"
@@ -11,7 +11,7 @@ import { DynamicProviderPlugin } from "./provider/dynamic"
 import { GatewayPlugin } from "./provider/gateway"
 import { GithubCopilotPlugin } from "./provider/github-copilot"
 import { GitLabPlugin } from "./provider/gitlab"
-import { GoogleVertexAnthropicPlugin, GoogleVertexPlugin } from "./provider/google-vertex"
+import { GoogleVertexPlugin } from "./provider/google-vertex"
 import { GroqPlugin } from "./provider/groq"
 import { KiloPlugin } from "./provider/kilo"
 import { LLMGatewayPlugin } from "./provider/llmgateway"
@@ -35,7 +35,6 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
   AlibabaPlugin,
   AmazonBedrockPlugin,
   AnthropicPlugin,
-  AzureCognitiveServicesPlugin,
   AzurePlugin,
   CerebrasPlugin,
   CloudflareAIGatewayPlugin,
@@ -45,7 +44,6 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
   GatewayPlugin,
   GithubCopilotPlugin,
   GitLabPlugin,
-  GoogleVertexAnthropicPlugin,
   GoogleVertexPlugin,
   GroqPlugin,
   KiloPlugin,

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

@@ -19,7 +19,9 @@ export const AzurePlugin = define({
         if (Provider.packageName(item.provider.package) !== "@ai-sdk/azure") continue
         const configured = item.provider.settings?.resourceName
         const resourceName =
-          typeof configured === "string" && configured.trim() !== "" ? configured : process.env.AZURE_RESOURCE_NAME
+          typeof configured === "string" && configured.trim() !== ""
+            ? configured
+            : (process.env.AZURE_RESOURCE_NAME ?? process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME)
         if (!resourceName) continue
         evt.provider.update(item.provider.id, (provider) => {
           provider.settings = { ...provider.settings, resourceName }
@@ -36,9 +38,7 @@ export const AzurePlugin = define({
             !evt.options.baseURL &&
             (!Provider.isAISDK(evt.model.package) || typeof evt.model.settings?.baseURL !== "string")
           ) {
-            throw new Error(
-              "AZURE_RESOURCE_NAME is missing, set it using env var or reconnecting the azure provider and setting it",
-            )
+            throw new Error("Azure resource name is missing; set AZURE_RESOURCE_NAME or configure resourceName/baseURL")
           }
         }
         const mod = yield* Effect.promise(() => import("@ai-sdk/azure"))
@@ -58,35 +58,3 @@ export const AzurePlugin = define({
     )
   }),
 })
-
-export const AzureCognitiveServicesPlugin = define({
-  id: "opencode.provider.azure-cognitive-services",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      const resourceName = process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME
-      if (!resourceName) return
-      for (const item of evt.provider.list()) {
-        if (!Provider.isAISDK(item.provider.package)) continue
-        if (Provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible") continue
-        if (!item.provider.id.includes("azure-cognitive-services")) continue
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.settings = {
-            ...provider.settings,
-            baseURL: `https://${resourceName}.cognitiveservices.azure.com/openai`,
-          }
-        })
-      }
-    })
-    yield* ctx.aisdk.hook(
-      "language",
-      Effect.fn(function* (evt) {
-        if (evt.model.providerID !== Provider.ID.make("azure-cognitive-services")) return
-        evt.language = selectLanguage(
-          evt.sdk,
-          evt.model.modelID ?? evt.model.id,
-          Boolean(evt.options.useCompletionUrls),
-        )
-      }),
-    )
-  }),
-})

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

@@ -92,6 +92,22 @@ export const GoogleVertexPlugin = define({
           evt.options.fetch = authFetch(evt.options.fetch)
           return
         }
+        if (evt.package === "@ai-sdk/google-vertex/anthropic") {
+          const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"))
+          const project = resolveProject(evt.options)
+          const location = String(resolveLocation(evt.options))
+          const regionalBaseURL =
+            (location === "eu" || location === "us") && project && !evt.options.baseURL
+              ? `https://aiplatform.${location}.rep.googleapis.com/v1/projects/${project}/locations/${location}/publishers/anthropic/models`
+              : undefined
+          evt.sdk = mod.createVertexAnthropic({
+            ...evt.options,
+            project,
+            location,
+            ...(regionalBaseURL ? { baseURL: regionalBaseURL } : {}),
+          })
+          return
+        }
         if (evt.package !== "@ai-sdk/google-vertex") return
         const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex"))
         const project = resolveProject(evt.options)
@@ -114,62 +130,3 @@ export const GoogleVertexPlugin = define({
     )
   }),
 })
-
-export const GoogleVertexAnthropicPlugin = define({
-  id: "opencode.provider.google-vertex-anthropic",
-  effect: Effect.fn(function* (ctx) {
-    yield* ctx.catalog.transform((evt) => {
-      for (const item of evt.provider.list()) {
-        if (!Provider.isAISDK(item.provider.package)) continue
-        if (Provider.packageName(item.provider.package) !== "@ai-sdk/google-vertex/anthropic") continue
-        const project =
-          item.provider.settings?.project ??
-          process.env.GOOGLE_CLOUD_PROJECT ??
-          process.env.GCP_PROJECT ??
-          process.env.GCLOUD_PROJECT
-        const location =
-          item.provider.settings?.location ??
-          process.env.GOOGLE_CLOUD_LOCATION ??
-          process.env.VERTEX_LOCATION ??
-          "global"
-        evt.provider.update(item.provider.id, (provider) => {
-          provider.settings = { ...provider.settings, ...(project ? { project } : {}), location }
-        })
-      }
-    })
-    yield* ctx.aisdk.hook(
-      "sdk",
-      Effect.fn(function* (evt) {
-        if (evt.package !== "@ai-sdk/google-vertex/anthropic") return
-        const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"))
-        const project =
-          typeof evt.options.project === "string"
-            ? evt.options.project
-            : (process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GCP_PROJECT ?? process.env.GCLOUD_PROJECT)
-        const location =
-          typeof evt.options.location === "string"
-            ? evt.options.location
-            : (process.env.GOOGLE_CLOUD_LOCATION ?? process.env.VERTEX_LOCATION ?? "global")
-        evt.sdk = mod.createVertexAnthropic({
-          ...evt.options,
-          project,
-          location,
-          // Continental multi-regions (eu, us) require Regional Endpoint Platform
-          // domains; the default {region}-aiplatform.googleapis.com does not resolve.
-          ...((location === "eu" || location === "us") && project && !evt.options.baseURL
-            ? {
-                baseURL: `https://aiplatform.${location}.rep.googleapis.com/v1/projects/${project}/locations/${location}/publishers/anthropic/models`,
-              }
-            : {}),
-        })
-      }),
-    )
-    yield* ctx.aisdk.hook(
-      "language",
-      Effect.fn(function* (evt) {
-        if (evt.model.providerID !== Provider.ID.make("google-vertex-anthropic")) return
-        evt.language = evt.sdk.languageModel(String(evt.model.modelID ?? evt.model.id).trim())
-      }),
-    )
-  }),
-})

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

@@ -111,9 +111,9 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
   type DraftText = WritableDraft<SessionMessage.AssistantText>
   type DraftReasoning = WritableDraft<SessionMessage.AssistantReasoning>
 
-  const latestTool = (assistant: DraftAssistant | undefined, callID?: string) =>
+  const latestTool = (assistant: DraftAssistant | undefined, id?: string) =>
     assistant?.content.findLast(
-      (item): item is DraftTool => item.type === "tool" && (callID === undefined || item.id === callID),
+      (item): item is DraftTool => item.type === "tool" && (id === undefined || item.id === id),
     )
 
   const latestText = (assistant: DraftAssistant | undefined) =>
@@ -331,7 +331,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
             castDraft(
               SessionMessage.AssistantTool.make({
                 type: "tool",
-                id: event.data.callID,
+                id: event.data.id,
                 name: event.data.name,
                 time: { created: event.created },
                 state: SessionMessage.ToolStateStreaming.make({ status: "streaming", input: "" }),
@@ -343,13 +343,13 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.tool.input.delta": () => Effect.void,
       "session.tool.input.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestTool(draft, event.data.callID)
+          const match = latestTool(draft, event.data.id)
           if (match && match.state.status === "streaming") match.state.input = event.data.text
         })
       },
       "session.tool.called": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestTool(draft, event.data.callID)
+          const match = latestTool(draft, event.data.id)
           if (match) {
             match.executed = event.data.executed
             match.providerState = event.data.state
@@ -366,7 +366,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       },
       "session.tool.progress": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestTool(draft, event.data.callID)
+          const match = latestTool(draft, event.data.id)
           if (match && match.state.status === "running") {
             match.state.metadata = event.data.metadata
           }
@@ -376,7 +376,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       // never reaches into ephemeral progress history.
       "session.tool.success": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestTool(draft, event.data.callID)
+          const match = latestTool(draft, event.data.id)
           if (match && match.state.status === "running") {
             match.executed = event.data.executed || match.executed === true
             match.providerResultState = event.data.resultState
@@ -394,7 +394,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       },
       "session.tool.failed": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
-          const match = latestTool(draft, event.data.callID)
+          const match = latestTool(draft, event.data.id)
           if (match && (match.state.status === "streaming" || match.state.status === "running")) {
             match.executed = event.data.executed || match.executed === true
             match.providerResultState = event.data.resultState

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

@@ -488,7 +488,7 @@ const layer = Layer.effect(
           yield* bus.publish(SessionEvent.Tool.Failed, {
             sessionID,
             assistantMessageID: message.id,
-            callID: tool.id,
+            id: tool.id,
             error: { type: "aborted", message: `Tool execution interrupted: ${tool.name}` },
             executed: tool.executed === true,
           })

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

@@ -23,6 +23,10 @@ export class ModelUnavailableError extends Schema.TaggedErrorClass<ModelUnavaila
   { providerID: Provider.ID, modelID: ID },
 ) {
   override get message() {
+    if (this.providerID === "azure-cognitive-services")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use azure/${this.modelID} instead.`
+    if (this.providerID === "google-vertex-anthropic")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use google-vertex/${this.modelID} instead.`
     return `Model unavailable: ${this.providerID}/${this.modelID}`
   }
 }

packages/core/src/session/runner/publish-llm-event.ts

@@ -78,7 +78,7 @@ const hostedContent = (result: ToolResultValue): NonEmptyContent => {
  * between a check (`tool.settled`, `stepStarted`, ...) and its mark, so check-and-mark
  * stays atomic under cooperative scheduling. (2) Never require a cross-source event
  * order: each publishing fiber is sequential, so per-source order holds by construction,
- * and consumers fold by callID/ordinal rather than global position.
+ * and consumers fold by id/ordinal rather than global position.
  */
 export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, input: Input) => {
   const tools = new Map<
@@ -188,14 +188,14 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
       }),
     true,
   )
-  const toolInput = fragments("tool input", (callID, value) =>
+  const toolInput = fragments("tool input", (id, value) =>
     Effect.gen(function* () {
-      const tool = tools.get(callID)
-      if (!tool) return yield* Effect.die(new Error(`Tool input end before start: ${callID}`))
+      const tool = tools.get(id)
+      if (!tool) return yield* Effect.die(new Error(`Tool input end before start: ${id}`))
       yield* bus.publish(SessionEvent.Tool.Input.Ended, {
         sessionID: input.sessionID,
         assistantMessageID: tool.assistantMessageID,
-        callID,
+        id,
         text: value,
       })
     }),
@@ -225,7 +225,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     yield* bus.publish(SessionEvent.Tool.Input.Started, {
       sessionID: input.sessionID,
       assistantMessageID,
-      callID: event.id,
+      id: event.id,
       name: event.name,
     })
   })
@@ -258,7 +258,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     yield* bus.publish(SessionEvent.Tool.Failed, {
       sessionID: input.sessionID,
       assistantMessageID: tool.assistantMessageID,
-      callID: event.id,
+      id: event.id,
       error: {
         type: "tool.input-json",
         message: "Tool call arguments were malformed JSON and were not executed. Retry with valid JSON.",
@@ -272,14 +272,14 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     yield* flushFragments()
   })
 
-  const failTool = Effect.fnUntraced(function* (callID: string, error: SessionError.Error) {
-    const tool = tools.get(callID)
+  const failTool = Effect.fnUntraced(function* (id: string, error: SessionError.Error) {
+    const tool = tools.get(id)
     if (!tool || tool.settled) return false
     tool.settled = true
     yield* bus.publish(SessionEvent.Tool.Failed, {
       sessionID: input.sessionID,
       assistantMessageID: tool.assistantMessageID,
-      callID,
+      id,
       error,
       ...failureSnapshot(tool),
       executed: tool.providerExecuted,
@@ -289,10 +289,10 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
 
   const failTools = Effect.fnUntraced(function* (error: SessionError.Error, mode: "all" | "hosted" | "uncalled") {
     let failed = false
-    for (const [callID, tool] of tools) {
+    for (const [id, tool] of tools) {
       if (tool.settled || (mode === "hosted" && !tool.providerExecuted) || (mode === "uncalled" && tool.called))
         continue
-      failed = (yield* failTool(callID, error)) || failed
+      failed = (yield* failTool(id, error)) || failed
     }
     return failed
   })
@@ -328,9 +328,9 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     return yield* failTools(error, scope)
   })
 
-  const assistantMessageIDForTool = (callID: string) => {
-    const tool = tools.get(callID)
-    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${callID}`))
+  const assistantMessageIDForTool = (id: string) => {
+    const tool = tools.get(id)
+    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${id}`))
   }
 
   const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (event: LLMEvent) {
@@ -399,7 +399,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         yield* bus.publish(SessionEvent.Tool.Input.Delta, {
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
-          callID: event.id,
+          id: event.id,
           delta: event.text,
         })
         return
@@ -424,7 +424,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         yield* bus.publish(SessionEvent.Tool.Called, {
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
-          callID: event.id,
+          id: event.id,
           input: asRecord(event.input),
           executed: tool.providerExecuted,
           state: providerState(event.providerMetadata),
@@ -450,7 +450,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
           yield* bus.publish(SessionEvent.Tool.Failed, {
             sessionID: input.sessionID,
             assistantMessageID: tool.assistantMessageID,
-            callID: event.id,
+            id: event.id,
             error: { type: "tool.execution", message: stringify(event.result.value) },
             ...failureSnapshot(tool),
             executed,
@@ -461,7 +461,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         yield* bus.publish(SessionEvent.Tool.Success, {
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
-          callID: event.id,
+          id: event.id,
           content: hostedContent(event.result),
           executed,
           resultState,
@@ -478,7 +478,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         yield* bus.publish(SessionEvent.Tool.Failed, {
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
-          callID: event.id,
+          id: event.id,
           error:
             event.message === `Unknown tool: ${event.name}`
               ? { type: "tool.unknown", message: event.message }
@@ -508,30 +508,30 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     }
   })
 
-  const progress = Effect.fnUntraced(function* (callID: string, update: Tool.Metadata) {
-    const tool = tools.get(callID)
+  const progress = Effect.fnUntraced(function* (id: string, update: Tool.Metadata) {
+    const tool = tools.get(id)
     if (!tool?.called || tool.settled)
-      return yield* Effect.die(new Error(`Tool progress outside running call: ${callID}`))
+      return yield* Effect.die(new Error(`Tool progress outside running call: ${id}`))
     tool.progress = update
     yield* bus.publish(SessionEvent.Tool.Progress, {
       sessionID: input.sessionID,
       assistantMessageID: tool.assistantMessageID,
-      callID,
+      id,
       metadata: update,
     })
   })
 
   /** Publishes one canonical terminal event for a locally executed tool call. */
   const toolExecution = Effect.fnUntraced(function* (
-    callID: string,
+    id: string,
     name: string,
     result: Tool.Result,
   ) {
-    const tool = tools.get(callID)
-    if (!tool?.called) return yield* Effect.die(new Error(`Tool execution before call: ${callID}`))
+    const tool = tools.get(id)
+    if (!tool?.called) return yield* Effect.die(new Error(`Tool execution before call: ${id}`))
     if (tool.name !== name)
-      return yield* Effect.die(new Error(`Tool execution name changed for ${callID}: ${tool.name} -> ${name}`))
-    if (tool.settled) return yield* Effect.die(new Error(`Duplicate tool execution: ${callID}`))
+      return yield* Effect.die(new Error(`Tool execution name changed for ${id}: ${tool.name} -> ${name}`))
+    if (tool.settled) return yield* Effect.die(new Error(`Duplicate tool execution: ${id}`))
     tool.settled = true
     const content =
       typeof result.content === "string"
@@ -539,11 +539,11 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         : result.content === undefined
           ? []
           : [...result.content]
-    if (content.length === 0) return yield* Effect.die(new Error(`Tool execution has no content: ${callID}`))
+    if (content.length === 0) return yield* Effect.die(new Error(`Tool execution has no content: ${id}`))
     yield* bus.publish(SessionEvent.Tool.Success, {
       sessionID: input.sessionID,
       assistantMessageID: tool.assistantMessageID,
-      callID,
+      id,
       content: [content[0], ...content.slice(1)],
       ...(result.metadata === undefined ? {} : { metadata: result.metadata }),
       executed: tool.providerExecuted,

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

@@ -20,10 +20,11 @@ export function isRetryable(error: AIError) {
     case "ProviderInternal":
     case "Transport":
       return true
+    case "InvalidProviderOutput":
+      return error.reason.classification === "incomplete-stream"
     case "Authentication":
     case "QuotaExceeded":
     case "ContentPolicy":
-    case "InvalidProviderOutput":
     case "InvalidRequest":
     case "NoRoute":
     case "UnknownProvider":

packages/core/src/tool.ts

@@ -93,7 +93,7 @@ const layer = Layer.effect(
         sessionID: context.sessionID,
         agent: context.agent,
         messageID: context.messageID,
-        callID: context.callID,
+        id: context.id,
         input,
       }
       yield* hooks.trigger("tool", "execute.before", beforeEvent)
@@ -106,7 +106,7 @@ const layer = Layer.effect(
         sessionID: context.sessionID,
         agent: context.agent,
         messageID: context.messageID,
-        callID: context.callID,
+        id: context.id,
         input: beforeEvent.input,
       }
       if ("failure" in execution) {
@@ -228,7 +228,7 @@ const layer = Layer.effect(
                   sessionID: input.sessionID,
                   agent: input.agent,
                   messageID: input.messageID,
-                  callID: Tool.CallID.make(input.call.id),
+                  id: Tool.CallID.make(input.call.id),
                   progress: input.progress ?? (() => Effect.void),
                 }
                 if (input.call.name === "execute" && codemodeTool)

packages/core/src/tool/AGENTS.md

@@ -22,7 +22,7 @@ Location-scoped built-in layers acquire `Permission.Service` and every other req
 const source = {
   type: "tool" as const,
   messageID: context.messageID,
-  callID: context.callID,
+  id: context.id,
 }
 ```
 

packages/core/src/tool/mcp.ts

@@ -59,7 +59,7 @@ export const layer = Layer.effectDiscard(
                   source: {
                     type: "tool",
                     messageID: context.messageID,
-                    callID: context.callID,
+                    id: context.id,
                   },
                 })
                 const result = yield* mcp

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

@@ -129,7 +129,7 @@ export const Plugin = {
                   const permissionSource = {
                     type: "tool" as const,
                     messageID: context.messageID,
-                    callID: context.callID,
+                    id: context.id,
                   }
                   if (input.oldString === input.newString) {
                     return yield* new ToolFailure({

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

@@ -61,7 +61,7 @@ export const Plugin = {
             execute: (input, context) =>
               Effect.gen(function* () {
                 const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path
-                const source = { type: "tool" as const, messageID: context.messageID, callID: context.callID }
+                const source = { type: "tool" as const, messageID: context.messageID, id: context.id }
                 const target = yield* mutation.resolve({ path: searchPath ?? ".", kind: "directory" })
                 const external = target.externalDirectory
                 if (external)

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

@@ -76,7 +76,7 @@ export const Plugin = {
             output: Output,
             execute: (input, context) =>
               Effect.gen(function* () {
-                const source = { type: "tool" as const, messageID: context.messageID, callID: context.callID }
+                const source = { type: "tool" as const, messageID: context.messageID, id: context.id }
                 const target = yield* mutation.resolve({ path: input.path ?? "." })
                 if (target.externalDirectory)
                   yield* permission.assert({

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

@@ -95,7 +95,7 @@ export const Plugin = {
                   const source = {
                     type: "tool" as const,
                     messageID: context.messageID,
-                    callID: context.callID,
+                    id: context.id,
                   }
                   if (!input.patchText) return yield* new ToolFailure({ message: "patchText is required" })
                   const hunks = yield* Effect.fromResult(Patch.parse(input.patchText)).pipe(

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

@@ -70,7 +70,7 @@ export const Plugin = {
                   resources: ["*"],
                   sessionID: context.sessionID,
                   agent: context.agent,
-                  source: { type: "tool", messageID: context.messageID, callID: context.callID },
+                  source: { type: "tool", messageID: context.messageID, id: context.id },
                 })
                 .pipe(
                   Effect.mapError((error) => new ToolFailure({ message: "Permission denied: question", error })),
@@ -81,7 +81,7 @@ export const Plugin = {
                         title: "Questions",
                         metadata: {
                           kind: "question",
-                          tool: { messageID: context.messageID, callID: context.callID },
+                          tool: { messageID: context.messageID, id: context.id },
                         },
                         fields: [
                           toField(input.questions[0], 0),

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

@@ -56,7 +56,7 @@ export const Plugin = {
                 const source = {
                   type: "tool" as const,
                   messageID: context.messageID,
-                  callID: context.callID,
+                  id: context.id,
                 }
                 const target = yield* mutation.resolve({ path: input.path, kind: "directory" })
                 const external = target.externalDirectory

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

@@ -89,10 +89,10 @@ export const Plugin = {
 
     const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (
       sessionID: SessionSchema.ID,
-      callID: string,
+      id: string,
       command: string,
     ) {
-      yield* runtime.job.wait({ id: callID }).pipe(
+      yield* runtime.job.wait({ id: id }).pipe(
         Effect.flatMap((result) => {
           const state =
             result.info?.status === "completed"
@@ -111,7 +111,7 @@ export const Plugin = {
                 : "Command cancelled"
           return runtime.session.synthetic({
             sessionID,
-            text: `<shell id="${callID}" state="${state}" command="${command}">\n${text}\n</shell>`,
+            text: `<shell id="${id}" state="${state}" command="${command}">\n${text}\n</shell>`,
             description: command,
             metadata: { source: "shell", state },
           })
@@ -134,7 +134,7 @@ export const Plugin = {
                 const source = {
                   type: "tool" as const,
                   messageID: context.messageID,
-                  callID: context.callID,
+                  id: context.id,
                 }
                 const timeout = input.background === true ? (input.timeout ?? 0) : (input.timeout ?? DEFAULT_TIMEOUT_MS)
                 let finalTimeout = timeout
@@ -176,7 +176,12 @@ export const Plugin = {
                           agent: context.agent,
                           source,
                         })
-                      if ((yield* fsUtil.stat(target.canonical)).type !== "Directory")
+                      const workdir = yield* fsUtil.stat(target.canonical).pipe(
+                        Effect.catchReason("PlatformError", "NotFound", () =>
+                          Effect.fail(new Error(`Working directory does not exist: ${target.canonical}`)),
+                        ),
+                      )
+                      if (workdir.type !== "Directory")
                         return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.canonical}`))
                     }),
                 )
@@ -227,7 +232,7 @@ export const Plugin = {
                   Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)),
                 )
                 const job = yield* runtime.job.start({
-                  id: context.callID,
+                  id: context.id,
                   type: name,
                   title: info.command,
                   metadata: { sessionID: context.sessionID, shellID: info.id },
@@ -236,7 +241,7 @@ export const Plugin = {
 
                 if (input.background === true) {
                   yield* runtime.job.background(job.id)
-                  yield* notifyWhenDone(context.sessionID, context.callID, info.command)
+                  yield* notifyWhenDone(context.sessionID, context.id, info.command)
                   return {
                     output: BACKGROUND_STARTED,
                     shellID: info.id,
@@ -250,7 +255,7 @@ export const Plugin = {
                 )
                 if (result?.type === "backgrounded") {
                   yield* shell.timeout(info.id, 0)
-                  yield* notifyWhenDone(context.sessionID, context.callID, info.command)
+                  yield* notifyWhenDone(context.sessionID, context.id, info.command)
                   return {
                     output: BACKGROUND_STARTED,
                     shellID: info.id,

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

@@ -75,7 +75,7 @@ export const Plugin = {
                     save: [skill.id],
                     sessionID: context.sessionID,
                     agent: context.agent,
-                    source: { type: "tool", messageID: context.messageID, callID: context.callID },
+                    source: { type: "tool", messageID: context.messageID, id: context.id },
                   })
                   const directory = path.dirname(skill.location)
                   const files =

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

@@ -159,7 +159,7 @@ export const Plugin = {
                     source: {
                       type: "tool",
                       messageID: context.messageID,
-                      callID: context.callID,
+                      id: context.id,
                     },
                   })
                   .pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent denied: ${agent.id}`, error })))

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

@@ -139,7 +139,7 @@ export const Plugin = {
                   metadata: input,
                   sessionID: context.sessionID,
                   agent: context.agent,
-                  source: { type: "tool", messageID: context.messageID, callID: context.callID },
+                  source: { type: "tool", messageID: context.messageID, id: context.id },
                 })
 
                 const { body, contentType } = yield* Effect.gen(function* () {

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

@@ -47,7 +47,7 @@ export const Plugin = {
                 metadata: input,
                 sessionID: context.sessionID,
                 agent: context.agent,
-                source: { type: "tool", messageID: context.messageID, callID: context.callID },
+                source: { type: "tool", messageID: context.messageID, id: context.id },
               })
               const result = yield* ctx.websearch.query(input).pipe(
                 Effect.catch((error) => {

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

@@ -67,7 +67,7 @@ export const Plugin = {
                   const source = {
                     type: "tool" as const,
                     messageID: context.messageID,
-                    callID: context.callID,
+                    id: context.id,
                   }
                   const target = yield* mutation.resolve({ path: input.path, kind: "file" })
                   const external = target.externalDirectory

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

@@ -94,13 +94,13 @@ function experimental(info: typeof ConfigV1.Info.Type) {
           { action: "provider.use" as const, resource: "*", effect: "deny" as const },
           ...info.enabled_providers.map((resource) => ({
             action: "provider.use" as const,
-            resource,
+            resource: providerID(resource),
             effect: "allow" as const,
           })),
         ]),
     ...(info.disabled_providers ?? []).map((resource) => ({
       action: "provider.use" as const,
-      resource,
+      resource: providerID(resource),
       effect: "deny" as const,
     })),
   ]
@@ -188,7 +188,7 @@ function modelSelection(input?: string, variant?: string) {
   if (input === undefined || !/^[^/#]+\/[^#]+$/.test(input)) return undefined
   const separator = input.indexOf("/")
   return {
-    providerID: input.slice(0, separator),
+    providerID: providerID(input.slice(0, separator)),
     model: input.slice(separator + 1),
     ...(variant === undefined || variant.length === 0 || variant.includes("#") ? {} : { variant }),
   }
@@ -234,24 +234,57 @@ function migrateMcp(info: ConfigMCPV1.Info) {
 
 function providers(info?: Readonly<Record<string, ConfigProviderV1.Info>>) {
   if (!info) return undefined
-  return Object.fromEntries(Object.entries(info).map(([name, provider]) => [name, migrateProvider(provider)]))
+  return Object.fromEntries(
+    Object.entries(info).flatMap(([name, provider]) => {
+      const id = providerID(name)
+      // If both names are present, keep the settings under the current name and ignore the old one.
+      if (id !== name && info[id]) return []
+      return [[id, migrateProvider(name, provider)]]
+    }),
+  )
 }
 
-function migrateProvider(info: ConfigProviderV1.Info) {
+function migrateProvider(sourceID: string, info: ConfigProviderV1.Info) {
   const options = ConfigProviderOptionsV1.provider(info.options ?? {})
+  const vertexAnthropic = sourceID === "google-vertex-anthropic"
+  const legacyAzure = sourceID === "azure-cognitive-services"
+  const packageName = info.npm ? Provider.aisdk(info.npm) : undefined
+  const modelPackage = vertexAnthropic ? (packageName ?? Provider.aisdk("@ai-sdk/google-vertex/anthropic")) : undefined
+  const legacyAzureBaseURL =
+    legacyAzure && info.npm === "@ai-sdk/openai-compatible" && !info.api
+      ? "https://${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}.cognitiveservices.azure.com/openai"
+      : undefined
   return {
     name: info.name,
-    env: info.env,
-    package: info.npm ? Provider.aisdk(info.npm) : undefined,
-    settings: info.api ? { ...options.settings, baseURL: info.api } : options.settings,
+    env: legacyAzure ? info.env?.filter((name) => name !== "AZURE_COGNITIVE_SERVICES_RESOURCE_NAME") : info.env,
+    // The current Google Vertex provider includes Gemini and Claude. Keep the Anthropic SDK on Claude models
+    // instead of changing the package inherited by every model on the provider.
+    package: vertexAnthropic ? undefined : packageName,
+    settings: info.api
+      ? { ...options.settings, baseURL: info.api }
+      : legacyAzureBaseURL
+        ? { ...options.settings, baseURL: legacyAzureBaseURL }
+        : options.settings,
     headers: info.options && options.headers,
     body: info.options && options.body,
     models:
       info.models &&
-      Object.fromEntries(Object.entries(info.models).map(([name, model]) => [name, migrateModel(model)])),
+      Object.fromEntries(
+        Object.entries(info.models).map(([name, model]) => {
+          const migrated = migrateModel(model)
+          return [name, modelPackage && !migrated.package ? { ...migrated, package: modelPackage } : migrated]
+        }),
+      ),
   }
 }
 
+// Rename these only in files detected as V1 by a field that exists only in the old config format.
+function providerID(input: string) {
+  if (input === "azure-cognitive-services") return "azure"
+  if (input === "google-vertex-anthropic") return "google-vertex"
+  return input
+}
+
 function migrateModel(info: typeof ConfigProviderV1.Model.Type) {
   const settings = info.options && ConfigProviderOptionsV1.model(info.options)
   const costs = info.cost && [

packages/core/test/aisdk-native.test.ts

@@ -16,6 +16,31 @@ describe("AISDKNative", () => {
     })
   })
 
+  test("maps Azure deployments and settings to native routes", () => {
+    const settings = {
+      apiKey: "secret",
+      resourceName: "resource",
+      apiVersion: "2025-01-01-preview",
+      queryParams: { feature: "enabled" },
+      useDeploymentBasedUrls: true,
+      reasoningEffort: "high",
+    }
+    expect(map("@ai-sdk/azure", settings, "deployment")).toEqual({
+      package: "@opencode-ai/ai/providers/azure/responses",
+      settings: {
+        apiKey: "secret",
+        resourceName: "resource",
+        apiVersion: "2025-01-01-preview",
+        queryParams: { feature: "enabled" },
+        useDeploymentBasedUrls: true,
+        providerOptions: { openai: { reasoningEffort: "high" } },
+      },
+    })
+    expect(map("@ai-sdk/azure", { ...settings, useCompletionUrls: true }, "custom-deployment")?.package).toBe(
+      "@opencode-ai/ai/providers/azure/chat",
+    )
+  })
+
   test("maps Bedrock provider and request options", () => {
     expect(
       map(

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

@@ -475,6 +475,111 @@ describe("Config", () => {
     }),
   )
 
+  it.effect("renames old provider IDs while migrating v1 configuration", () =>
+    Effect.sync(() => {
+      const migrated = ConfigMigrateV1.migrate({
+        model: "azure-cognitive-services/deployment",
+        enabled_providers: ["google-vertex-anthropic"],
+        disabled_providers: ["azure-cognitive-services"],
+        agent: {
+          reviewer: { model: "google-vertex-anthropic/claude-sonnet" },
+        },
+        command: {
+          review: { template: "Review", model: "azure-cognitive-services/deployment" },
+        },
+        provider: {
+          "azure-cognitive-services": {
+            npm: "@ai-sdk/azure",
+            env: ["AZURE_COGNITIVE_SERVICES_RESOURCE_NAME", "AZURE_COGNITIVE_SERVICES_API_KEY"],
+            models: { deployment: {} },
+          },
+          "google-vertex-anthropic": {
+            npm: "@ai-sdk/google-vertex/anthropic",
+            options: { project: "test-project", location: "us-central1" },
+            models: { "claude-sonnet": {} },
+          },
+        },
+      })
+
+      expect(migrated.model).toEqual({ providerID: "azure", model: "deployment" })
+      expect(migrated.agents?.reviewer?.model).toEqual({ providerID: "google-vertex", model: "claude-sonnet" })
+      expect(migrated.commands?.review?.model).toEqual({ providerID: "azure", model: "deployment" })
+      expect(migrated.experimental?.policies).toEqual([
+        { action: "provider.use", resource: "*", effect: "deny" },
+        { action: "provider.use", resource: "google-vertex", effect: "allow" },
+        { action: "provider.use", resource: "azure", effect: "deny" },
+      ])
+      expect(migrated.providers?.azure).toMatchObject({
+        env: ["AZURE_COGNITIVE_SERVICES_API_KEY"],
+        package: Provider.aisdk("@ai-sdk/azure"),
+        models: { deployment: {} },
+      })
+      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-anthropic"]).toBeUndefined()
+    }),
+  )
+
+  it.effect("preserves the generated base URL for v1 Azure OpenAI-compatible providers", () =>
+    Effect.sync(() => {
+      const migrated = ConfigMigrateV1.migrate({
+        provider: {
+          "azure-cognitive-services": {
+            npm: "@ai-sdk/openai-compatible",
+            env: ["AZURE_COGNITIVE_SERVICES_RESOURCE_NAME", "AZURE_COGNITIVE_SERVICES_API_KEY"],
+          },
+        },
+      })
+
+      expect(migrated.providers?.azure).toMatchObject({
+        env: ["AZURE_COGNITIVE_SERVICES_API_KEY"],
+        package: Provider.aisdk("@ai-sdk/openai-compatible"),
+        settings: {
+          baseURL: "https://${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}.cognitiveservices.azure.com/openai",
+        },
+      })
+    }),
+  )
+
+  it.effect("ignores old provider IDs when the current provider ID is configured", () =>
+    Effect.sync(() => {
+      const migrated = ConfigMigrateV1.migrate({
+        provider: {
+          azure: { models: { current: {} } },
+          "azure-cognitive-services": { models: { legacy: {} } },
+          "google-vertex": { models: { gemini: {} } },
+          "google-vertex-anthropic": { models: { claude: {} } },
+        },
+      })
+
+      expect(migrated.providers?.azure?.models).toEqual({ current: expect.anything() })
+      expect(migrated.providers?.["google-vertex"]?.models).toEqual({ gemini: expect.anything() })
+    }),
+  )
+
+  it.effect("preserves the built-in package for v1 Vertex Anthropic custom models", () =>
+    Effect.sync(() => {
+      const migrated = ConfigMigrateV1.migrate({
+        provider: {
+          "google-vertex-anthropic": {
+            models: { claude: {} },
+          },
+        },
+      })
+
+      expect(migrated.providers?.["google-vertex"]?.package).toBeUndefined()
+      expect(migrated.providers?.["google-vertex"]?.models?.claude?.package).toBe(
+        Provider.aisdk("@ai-sdk/google-vertex/anthropic"),
+      )
+    }),
+  )
+
   it.effect("migrates v1 interleaved fields to compatibility", () =>
     Effect.sync(() => {
       const migrated = ConfigMigrateV1.migrate({

packages/core/test/database-migration.test.ts

@@ -714,7 +714,7 @@ describe("DatabaseMigration", () => {
           sql`INSERT INTO event VALUES ('evt_success', 'session.tool.success.1', ${JSON.stringify({
             sessionID: "ses_test",
             assistantMessageID: "msg_tools",
-            callID: "call_hosted",
+            id: "call_hosted",
             structured: {},
             content: [],
             result: { type: "json", value: [{ url: "https://example.com" }] },
@@ -725,7 +725,7 @@ describe("DatabaseMigration", () => {
           sql`INSERT INTO event VALUES ('evt_failed', 'session.tool.failed.1', ${JSON.stringify({
             sessionID: "ses_test",
             assistantMessageID: "msg_tools",
-            callID: "call_failed",
+            id: "call_failed",
             error: { type: "tool.execution", message: "timed out" },
             metadata: { truncated: false },
             executed: false,
@@ -795,7 +795,7 @@ describe("DatabaseMigration", () => {
         expect(JSON.parse(event!.data)).toEqual({
           sessionID: "ses_test",
           assistantMessageID: "msg_tools",
-          callID: "call_hosted",
+          id: "call_hosted",
           structured: {},
           content: [],
           result: { type: "json", value: [{ url: "https://example.com" }] },
@@ -806,7 +806,7 @@ describe("DatabaseMigration", () => {
         expect(JSON.parse(failedEvent!.data)).toEqual({
           sessionID: "ses_test",
           assistantMessageID: "msg_tools",
-          callID: "call_failed",
+          id: "call_failed",
           error: { type: "tool.execution", message: "timed out" },
           metadata: { truncated: false },
           executed: false,

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

@@ -666,6 +666,50 @@ describe("LocationServiceMap", () => {
     ),
   )
 
+  it.live("explains replacements for unavailable legacy provider models", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const location = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
+          for (const [providerID, replacement] of [
+            ["azure-cognitive-services", "azure"],
+            ["google-vertex-anthropic", "google-vertex"],
+          ] as const) {
+            const failure = yield* SessionRunnerModel.Service.use((models) =>
+              models.resolve(
+                Session.Info.make({
+                  id: Session.ID.make(`ses_removed_${providerID}`),
+                  projectID: Project.ID.global,
+                  title: "test",
+                  model: {
+                    id: Model.ID.make("chat"),
+                    providerID: Provider.ID.make(providerID),
+                  },
+                  cost: Money.USD.zero,
+                  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                  time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+                  location,
+                }),
+              ),
+            ).pipe(Effect.provide(LocationServiceMap.Service.get(location)), Effect.flip)
+
+            expect(failure).toMatchObject({
+              _tag: "SessionRunnerModel.ModelUnavailableError",
+              providerID,
+              modelID: "chat",
+            })
+            expect(failure.message).toBe(
+              `Model unavailable: ${providerID}/chat. This provider has been deprecated; use ${replacement}/chat instead.`,
+            )
+          }
+        }),
+      ),
+    ),
+  )
+
   it.live("preserves the selected catalog identity when the package model id differs", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),

packages/core/test/mcp.test.ts

@@ -928,7 +928,7 @@ it.effect("waits for permission before calling an MCP tool", () =>
       source: {
         type: "tool",
         messageID: toolIdentity.messageID,
-        callID: "call_mcp_permission",
+        id: "call_mcp_permission",
       },
     })
     expect(calls).toBe(0)

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

@@ -12,6 +12,7 @@ import { ModelResolver } from "@opencode-ai/core/model-resolver"
 import { it } from "./lib/effect"
 
 interface ModelOptions {
+  readonly providerID?: Provider.ID
   readonly modelID?: string
   readonly compatibility?: Compatibility
   readonly settings?: Info["settings"]
@@ -25,7 +26,7 @@ const model = (packageName: string | undefined, options: ModelOptions = {}) =>
   Info.make({
     id: ID.make("test-model"),
     modelID: ID.make(options.modelID ?? "api-test-model"),
-    providerID: Provider.ID.make("test-provider"),
+    providerID: options.providerID ?? Provider.ID.make("test-provider"),
     name: "Test model",
     compatibility: options.compatibility,
     package: packageName,
@@ -42,6 +43,65 @@ const model = (packageName: string | undefined, options: ModelOptions = {}) =>
   })
 
 describe("ModelResolver", () => {
+  it.effect("constructs native Azure requests with deployment IDs and resolved resource URLs", () =>
+    Effect.gen(function* () {
+      const responses = yield* ModelResolver.fromCatalogModel(
+        model(Provider.aisdk("@ai-sdk/azure"), {
+          providerID: Provider.ID.azure,
+          modelID: "responses-deployment",
+          settings: { resourceName: "modern-resource", apiVersion: "2025-01-01-preview" },
+        }),
+        Credential.Key.make({ type: "key", key: "secret" }),
+      )
+      const chat = yield* ModelResolver.fromCatalogModel(
+        model(Provider.aisdk("@ai-sdk/azure"), {
+          providerID: Provider.ID.azure,
+          modelID: "chat-deployment",
+          settings: { resourceName: "modern-resource", useCompletionUrls: true },
+        }),
+      )
+      const deployment = yield* ModelResolver.fromCatalogModel(
+        model(Provider.aisdk("@ai-sdk/azure"), {
+          providerID: Provider.ID.azure,
+          modelID: "legacy-url-deployment",
+          settings: {
+            resourceName: "modern-resource",
+            apiVersion: "2025-01-01-preview",
+            useDeploymentBasedUrls: true,
+          },
+        }),
+      )
+      const compatible = yield* ModelResolver.fromCatalogModel(
+        model(Provider.aisdk("@ai-sdk/openai-compatible"), {
+          providerID: Provider.ID.azure,
+          modelID: "legacy-deployment",
+          settings: {
+            resourceName: "legacy-resource",
+            baseURL: "https://${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}.cognitiveservices.azure.com/openai",
+          },
+        }),
+      )
+
+      expect(responses).toMatchObject({ id: "responses-deployment", provider: "azure" })
+      expect(responses.route).toMatchObject({
+        id: "azure-openai-responses",
+        endpoint: {
+          baseURL: "https://modern-resource.openai.azure.com/openai/v1",
+          query: { "api-version": "2025-01-01-preview" },
+        },
+      })
+      expect(chat).toMatchObject({ id: "chat-deployment", provider: "azure" })
+      expect(chat.route.id).toBe("azure-openai-chat")
+      expect(deployment).toMatchObject({ id: "legacy-url-deployment", provider: "azure" })
+      expect(deployment.route.endpoint).toMatchObject({
+        baseURL: "https://modern-resource.openai.azure.com/openai/deployments/legacy-url-deployment",
+        query: { "api-version": "2025-01-01-preview" },
+      })
+      expect(compatible).toMatchObject({ id: "legacy-deployment", provider: "azure" })
+      expect(compatible.route.endpoint.baseURL).toBe("https://legacy-resource.cognitiveservices.azure.com/openai")
+    }),
+  )
+
   it.effect("maps Bedrock Mantle models to native Responses and safeguards to Chat", () =>
     Effect.gen(function* () {
       const credential = Credential.Key.make({ type: "key", key: "secret" })

packages/core/test/plugin/models-dev.test.ts

@@ -11,6 +11,7 @@ import { Location } from "@opencode-ai/core/location"
 import { Model } from "@opencode-ai/core/model"
 import { ModelsDev } from "@opencode-ai/core/models-dev"
 import { ModelsDevPlugin } from "@opencode-ai/core/plugin/models-dev"
+import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
 import { Provider } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
@@ -220,6 +221,61 @@ describe("ModelsDevPlugin", () => {
     }).pipe(Effect.provide(models(path.join(import.meta.dir, "fixtures", "models-dev.json")))),
   )
 
+  it.effect("omits legacy provider aliases", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const catalog = yield* Catalog.Service
+      const snapshots = [
+        ["azure", "Azure", "AZURE_API_KEY", "@ai-sdk/azure"],
+        ["azure-cognitive-services", "Azure Cognitive Services", "AZURE_COGNITIVE_SERVICES_API_KEY", "@ai-sdk/azure"],
+        ["google-vertex", "Google Vertex", "GOOGLE_APPLICATION_CREDENTIALS", "@ai-sdk/google-vertex"],
+        [
+          "google-vertex-anthropic",
+          "Google Vertex Anthropic",
+          "GOOGLE_APPLICATION_CREDENTIALS",
+          "@ai-sdk/google-vertex/anthropic",
+        ],
+      ].map(([id, name, environment, packageName]) => ({
+        info: {
+          id: Provider.ID.make(id),
+          name,
+          package: Provider.aisdk(packageName),
+        },
+        environment: id === "azure" ? ["AZURE_RESOURCE_NAME", environment] : [environment],
+        models: [],
+      })) satisfies readonly ModelsDev.Snapshot[]
+
+      yield* ModelsDevPlugin.effect(
+        host({
+          catalog: catalogHost(catalog),
+          integration: integrationHost(integrations),
+        }),
+      ).pipe(
+        Effect.provideService(
+          ModelsDev.Service,
+          ModelsDev.Service.of({
+            get: () => Effect.succeed(snapshots),
+            refresh: () => Effect.void,
+          }),
+        ),
+      )
+
+      expect(yield* catalog.provider.get(Provider.ID.azure)).toBeDefined()
+      expect(yield* catalog.provider.get(Provider.ID.make("google-vertex"))).toBeDefined()
+      expect(yield* catalog.provider.get(Provider.ID.make("azure-cognitive-services"))).toBeUndefined()
+      expect(yield* catalog.provider.get(Provider.ID.make("google-vertex-anthropic"))).toBeUndefined()
+      expect(yield* integrations.get(Integration.ID.make("azure"))).toBeDefined()
+      expect(yield* integrations.get(Integration.ID.make("azure"))).toMatchObject({
+        methods: [{ type: "key" }, { type: "env", names: ["AZURE_API_KEY", "AZURE_COGNITIVE_SERVICES_API_KEY"] }],
+      })
+      expect(yield* integrations.get(Integration.ID.make("google-vertex"))).toBeDefined()
+      expect(yield* integrations.get(Integration.ID.make("azure-cognitive-services"))).toBeUndefined()
+      expect(yield* integrations.get(Integration.ID.make("google-vertex-anthropic"))).toBeUndefined()
+      expect(ProviderPlugins.map((plugin) => plugin.id)).not.toContain("opencode.provider.azure-cognitive-services")
+      expect(ProviderPlugins.map((plugin) => plugin.id)).not.toContain("opencode.provider.google-vertex-anthropic")
+    }),
+  )
+
   it.effect("converts reasoning options into settings variants", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
@@ -389,10 +445,7 @@ describe("ModelsDevPlugin", () => {
         },
       ])
 
-      const openrouter = yield* catalog.model.get(
-        Provider.ID.make("openrouter"),
-        Model.ID.make("openrouter-toggle"),
-      )
+      const openrouter = yield* catalog.model.get(Provider.ID.make("openrouter"), Model.ID.make("openrouter-toggle"))
       expect(openrouter?.variants).toEqual([
         { id: Model.VariantID.make("none"), settings: { reasoning: { enabled: false } } },
         { id: Model.VariantID.make("thinking"), settings: { reasoning: { enabled: true } } },
@@ -414,10 +467,7 @@ describe("ModelsDevPlugin", () => {
         },
       ])
 
-      const vertex = yield* catalog.model.get(
-        Provider.ID.make("google-vertex"),
-        Model.ID.make("gemini-2.5-flash-lite"),
-      )
+      const vertex = yield* catalog.model.get(Provider.ID.make("google-vertex"), Model.ID.make("gemini-2.5-flash-lite"))
       expect(vertex?.variants).toEqual([
         {
           id: Model.VariantID.make("none"),

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

@@ -1,205 +0,0 @@
-import { AISDK } from "@opencode-ai/core/aisdk"
-import { describe, expect } from "bun:test"
-import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Model } from "@opencode-ai/core/model"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { AzureCognitiveServicesPlugin } from "@opencode-ai/core/plugin/provider/azure"
-import { Provider } from "@opencode-ai/core/provider"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "./fixture"
-
-const it = testEffect(PluginTestLayer)
-
-const addPlugin = Effect.fn(function* () {
-  const plugin = yield* Plugin.Service
-  const aisdk = yield* AISDK.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* AzureCognitiveServicesPlugin.effect(host)
-})
-
-function required<T>(value: T | undefined): T {
-  if (value === undefined) throw new Error("Expected value")
-  return value
-}
-
-function withEnv<A, E, R>(vars: Record<string, string | undefined>, fx: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
-      Object.entries(vars).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    fx,
-    (previous) =>
-      Effect.sync(() => {
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        })
-      }),
-  )
-}
-
-function fakeSelectorSdk(calls: string[]) {
-  const make = (method: string) => (id: string) => {
-    calls.push(`${method}:${id}`)
-    return { modelId: id, provider: method, specificationVersion: "v3" } as unknown as LanguageModelV3
-  }
-  return {
-    responses: make("responses"),
-    messages: make("messages"),
-    chat: make("chat"),
-    languageModel: make("languageModel"),
-  }
-}
-
-describe("AzureCognitiveServicesPlugin", () => {
-  it.effect("maps the resource env var to the Azure SDK baseURL", () =>
-    withEnv({ AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: "cognitive" }, () =>
-      Effect.gen(function* () {
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((catalog) => {
-          catalog.provider.update(Provider.ID.make("azure-cognitive-services"), (item) => {
-            item.package = Provider.aisdk("@ai-sdk/openai-compatible")
-          })
-        })
-        yield* addPlugin()
-        const result = required(yield* catalog.provider.get(Provider.ID.make("azure-cognitive-services")))
-        expect(result).toMatchObject({
-          package: "aisdk:@ai-sdk/openai-compatible",
-          settings: { baseURL: "https://cognitive.cognitiveservices.azure.com/openai" },
-        })
-        expect(result.settings?.resourceName).toBeUndefined()
-      }),
-    ),
-  )
-
-  it.effect("leaves baseURL unset without resource env and ignores other providers", () =>
-    withEnv({ AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: undefined }, () =>
-      Effect.gen(function* () {
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((catalog) => {
-          const azure = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.make("azure-cognitive-services")),
-            package: "aisdk:@ai-sdk/openai-compatible",
-          })
-          const openai = Provider.Info.make({
-            ...Provider.Info.empty(Provider.ID.openai),
-            package: "aisdk:test-provider",
-          })
-          catalog.provider.update(azure.id, (item) => {
-            item.package = azure.package
-            item.package = azure.package
-          })
-          catalog.provider.update(openai.id, (item) => {
-            item.package = openai.package
-            item.package = openai.package
-          })
-        })
-        yield* addPlugin()
-        const azure = required(yield* catalog.provider.get(Provider.ID.make("azure-cognitive-services")))
-        const openai = required(yield* catalog.provider.get(Provider.ID.openai))
-        expect(azure.settings?.baseURL).toBeUndefined()
-        expect(azure).toMatchObject({ package: "aisdk:@ai-sdk/openai-compatible" })
-        expect(openai.settings?.baseURL).toBeUndefined()
-        expect(openai).toMatchObject({ package: "aisdk:test-provider" })
-      }),
-    ),
-  )
-
-  it.effect("selects chat only for completion URLs", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      const calls: string[] = []
-      yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("azure-cognitive-services"), Model.ID.make("deployment")),
-          modelID: Model.ID.make("deployment"),
-          package: "aisdk:test-provider",
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: { useCompletionUrls: true },
-      })
-      expect(calls).toEqual(["chat:deployment"])
-    }),
-  )
-
-  it.effect("uses the legacy Azure selector order and provider guard", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      const calls: string[] = []
-      yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("azure-cognitive-services"), Model.ID.make("deployment")),
-          modelID: Model.ID.make("deployment"),
-          package: "aisdk:test-provider",
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: {},
-      })
-      const ignored = yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.openai, Model.ID.make("deployment")),
-          modelID: Model.ID.make("deployment"),
-          package: "aisdk:test-provider",
-        }),
-        sdk: fakeSelectorSdk(calls),
-        options: {},
-      })
-      expect(calls).toEqual(["responses:deployment"])
-      expect(ignored.language).toBeUndefined()
-    }),
-  )
-
-  it.effect("falls back from responses to messages, chat, then languageModel", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      const calls: string[] = []
-      const sdk = fakeSelectorSdk(calls)
-      yield* addPlugin()
-      yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("azure-cognitive-services"), Model.ID.make("messages-deployment")),
-          modelID: Model.ID.make("messages-deployment"),
-          package: "aisdk:test-provider",
-        }),
-        sdk: { messages: sdk.messages, chat: sdk.chat, languageModel: sdk.languageModel },
-        options: {},
-      })
-      yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("azure-cognitive-services"), Model.ID.make("chat-deployment")),
-          modelID: Model.ID.make("chat-deployment"),
-          package: "aisdk:test-provider",
-        }),
-        sdk: { chat: sdk.chat, languageModel: sdk.languageModel },
-        options: {},
-      })
-      yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("azure-cognitive-services"), Model.ID.make("language-deployment")),
-          modelID: Model.ID.make("language-deployment"),
-          package: "aisdk:test-provider",
-        }),
-        sdk: { languageModel: sdk.languageModel },
-        options: {},
-      })
-      expect(calls).toEqual([
-        "messages:messages-deployment",
-        "chat:chat-deployment",
-        "languageModel:language-deployment",
-      ])
-    }),
-  )
-})

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

@@ -75,6 +75,21 @@ describe("AzurePlugin", () => {
     ),
   )
 
+  it.effect("resolves resourceName from the legacy env", () =>
+    withEnv({ AZURE_RESOURCE_NAME: undefined, AZURE_COGNITIVE_SERVICES_RESOURCE_NAME: "legacy-resource" }, () =>
+      Effect.gen(function* () {
+        const catalog = yield* Catalog.Service
+        yield* catalog.transform((catalog) => {
+          catalog.provider.update(Provider.ID.azure, (item) => {
+            item.package = Provider.aisdk("@ai-sdk/azure")
+          })
+        })
+        yield* addPlugin()
+        expect(required(yield* catalog.provider.get(Provider.ID.azure)).settings?.resourceName).toBe("legacy-resource")
+      }),
+    ),
+  )
+
   it.effect("keeps explicit resourceName over env and ignores other providers", () =>
     withEnv({ AZURE_RESOURCE_NAME: "from-env" }, () =>
       Effect.gen(function* () {

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

@@ -1,271 +0,0 @@
-import { AISDK } from "@opencode-ai/core/aisdk"
-import type { LanguageModelV3 } from "@ai-sdk/provider"
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Catalog } from "@opencode-ai/core/catalog"
-import { Model } from "@opencode-ai/core/model"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { GoogleVertexAnthropicPlugin, GoogleVertexPlugin } from "@opencode-ai/core/plugin/provider/google-vertex"
-import { Provider } from "@opencode-ai/core/provider"
-import { testEffect } from "../lib/effect"
-import { PluginTestLayer } from "./fixture"
-
-const it = testEffect(PluginTestLayer)
-
-const addPlugin = Effect.fn(function* (definition: typeof GoogleVertexAnthropicPlugin | typeof GoogleVertexPlugin) {
-  const plugin = yield* Plugin.Service
-  const aisdk = yield* AISDK.Service
-  const host = yield* PluginHost.make(plugin)
-  yield* definition.effect(host)
-})
-
-function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
-      Object.entries(vars).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    effect,
-    (previous) =>
-      Effect.sync(() => {
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        })
-      }),
-  )
-}
-
-function selector(calls: string[]) {
-  return (id: string) => {
-    calls.push(`languageModel:${id}`)
-    return { modelId: id, provider: "languageModel", specificationVersion: "v3" } as unknown as LanguageModelV3
-  }
-}
-
-describe("GoogleVertexAnthropicPlugin", () => {
-  it.effect("resolves legacy project and location env on provider update", () =>
-    withEnv(
-      {
-        GOOGLE_CLOUD_PROJECT: "cloud-project",
-        GCP_PROJECT: "gcp-project",
-        GCLOUD_PROJECT: "gcloud-project",
-        GOOGLE_CLOUD_LOCATION: "cloud-location",
-        VERTEX_LOCATION: "vertex-location",
-        GOOGLE_VERTEX_LOCATION: "google-vertex-location",
-      },
-      () =>
-        Effect.gen(function* () {
-          const catalog = yield* Catalog.Service
-          yield* catalog.transform((catalog) =>
-            catalog.provider.update(Provider.ID.make("google-vertex-anthropic"), (provider) => {
-              provider.package = Provider.aisdk("@ai-sdk/google-vertex/anthropic")
-            }),
-          )
-          yield* addPlugin(GoogleVertexAnthropicPlugin)
-          expect((yield* catalog.provider.get(Provider.ID.make("google-vertex-anthropic")))?.settings?.project).toBe(
-            "cloud-project",
-          )
-          expect((yield* catalog.provider.get(Provider.ID.make("google-vertex-anthropic")))?.settings?.location).toBe(
-            "cloud-location",
-          )
-        }),
-    ),
-  )
-
-  it.effect("keeps configured project and location over env fallback", () =>
-    withEnv({ GOOGLE_CLOUD_PROJECT: "env-project", GOOGLE_CLOUD_LOCATION: "env-location" }, () =>
-      Effect.gen(function* () {
-        const catalog = yield* Catalog.Service
-        yield* catalog.transform((catalog) =>
-          catalog.provider.update(Provider.ID.make("google-vertex-anthropic"), (provider) => {
-            provider.package = Provider.aisdk("@ai-sdk/google-vertex/anthropic")
-            provider.settings = { ...provider.settings, project: "configured-project", location: "configured-location" }
-          }),
-        )
-        yield* addPlugin(GoogleVertexAnthropicPlugin)
-        expect((yield* catalog.provider.get(Provider.ID.make("google-vertex-anthropic")))?.settings?.project).toBe(
-          "configured-project",
-        )
-        expect((yield* catalog.provider.get(Provider.ID.make("google-vertex-anthropic")))?.settings?.location).toBe(
-          "configured-location",
-        )
-      }),
-    ),
-  )
-
-  it.effect("creates SDKs from legacy env fallback and default location", () =>
-    withEnv(
-      {
-        GOOGLE_CLOUD_PROJECT: undefined,
-        GCP_PROJECT: "gcp-project",
-        GCLOUD_PROJECT: "gcloud-project",
-        GOOGLE_CLOUD_LOCATION: undefined,
-        VERTEX_LOCATION: undefined,
-        GOOGLE_VERTEX_LOCATION: "ignored-location",
-      },
-      () =>
-        Effect.gen(function* () {
-          const plugin = yield* Plugin.Service
-          const aisdk = yield* AISDK.Service
-          yield* addPlugin(GoogleVertexAnthropicPlugin)
-          const result = yield* aisdk.runSDK({
-            model: Model.Info.make({
-              ...Model.Info.default(
-                Provider.ID.make("google-vertex-anthropic"),
-                Model.ID.make("claude-sonnet-4-5"),
-              ),
-              modelID: Model.ID.make("claude-sonnet-4-5"),
-              package: "aisdk:test-provider",
-            }),
-            package: "@ai-sdk/google-vertex/anthropic",
-            options: { name: "google-vertex-anthropic" },
-          })
-          expect(result.sdk.languageModel("claude-sonnet-4-5").config.baseURL).toBe(
-            "https://aiplatform.googleapis.com/v1/projects/gcp-project/locations/global/publishers/anthropic/models",
-          )
-        }),
-    ),
-  )
-
-  it.effect("uses GOOGLE_CLOUD_LOCATION before VERTEX_LOCATION when creating SDKs", () =>
-    withEnv(
-      { GOOGLE_CLOUD_PROJECT: "project", GOOGLE_CLOUD_LOCATION: "cloud-location", VERTEX_LOCATION: "vertex-location" },
-      () =>
-        Effect.gen(function* () {
-          const plugin = yield* Plugin.Service
-          const aisdk = yield* AISDK.Service
-          yield* addPlugin(GoogleVertexAnthropicPlugin)
-          const result = yield* aisdk.runSDK({
-            model: Model.Info.make({
-              ...Model.Info.default(
-                Provider.ID.make("google-vertex-anthropic"),
-                Model.ID.make("claude-sonnet-4-5"),
-              ),
-              modelID: Model.ID.make("claude-sonnet-4-5"),
-              package: "aisdk:test-provider",
-            }),
-            package: "@ai-sdk/google-vertex/anthropic",
-            options: { name: "google-vertex-anthropic" },
-          })
-          expect(result.sdk.languageModel("claude-sonnet-4-5").config.baseURL).toBe(
-            "https://cloud-location-aiplatform.googleapis.com/v1/projects/project/locations/cloud-location/publishers/anthropic/models",
-          )
-        }),
-    ),
-  )
-
-  it.effect("creates SDKs for google-vertex Anthropic models with multi-region endpoints", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      yield* addPlugin(GoogleVertexAnthropicPlugin)
-      const result = yield* aisdk.runSDK({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("google-vertex"), Model.ID.make("claude-sonnet-4-5")),
-          modelID: Model.ID.make("claude-sonnet-4-5"),
-          package: "aisdk:test-provider",
-        }),
-        package: "@ai-sdk/google-vertex/anthropic",
-        options: { name: "google-vertex", project: "project", location: "eu" },
-      })
-      expect(result.sdk.languageModel("claude-sonnet-4-5").config.baseURL).toBe(
-        "https://aiplatform.eu.rep.googleapis.com/v1/projects/project/locations/eu/publishers/anthropic/models",
-      )
-    }),
-  )
-
-  it.effect("keeps configured baseURL for google-vertex Anthropic models", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      yield* addPlugin(GoogleVertexAnthropicPlugin)
-      const result = yield* aisdk.runSDK({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("google-vertex"), Model.ID.make("claude-sonnet-4-5")),
-          modelID: Model.ID.make("claude-sonnet-4-5"),
-          package: "aisdk:test-provider",
-        }),
-        package: "@ai-sdk/google-vertex/anthropic",
-        options: { name: "google-vertex", project: "project", location: "eu", baseURL: "https://proxy.example/v1" },
-      })
-      expect(result.sdk.languageModel("claude-sonnet-4-5").config.baseURL).toBe("https://proxy.example/v1")
-    }),
-  )
-
-  it.effect("selects google-vertex Anthropic language models through plugins", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      yield* addPlugin(GoogleVertexPlugin)
-      yield* addPlugin(GoogleVertexAnthropicPlugin)
-      const sdkResult = yield* aisdk.runSDK({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("google-vertex"), Model.ID.make(" claude-sonnet-4-5 ")),
-          modelID: Model.ID.make(" claude-sonnet-4-5 "),
-          package: "aisdk:test-provider",
-        }),
-        package: "@ai-sdk/google-vertex/anthropic",
-        options: { name: "google-vertex", project: "project", location: "us" },
-      })
-      const languageResult = yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("google-vertex"), Model.ID.make(" claude-sonnet-4-5 ")),
-          modelID: Model.ID.make(" claude-sonnet-4-5 "),
-          package: "aisdk:test-provider",
-        }),
-        sdk: sdkResult.sdk,
-        options: {},
-      })
-      const language = languageResult.language as unknown as { config: { baseURL: string }; modelId: string }
-      expect(language.config.baseURL).toBe(
-        "https://aiplatform.us.rep.googleapis.com/v1/projects/project/locations/us/publishers/anthropic/models",
-      )
-      expect(language.modelId).toBe("claude-sonnet-4-5")
-    }),
-  )
-
-  it.effect("trims model IDs before selecting language models", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      const calls: string[] = []
-      yield* addPlugin(GoogleVertexAnthropicPlugin)
-      yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("google-vertex-anthropic"), Model.ID.make(" claude-sonnet-4-5 ")),
-          modelID: Model.ID.make(" claude-sonnet-4-5 "),
-          package: "aisdk:test-provider",
-        }),
-        sdk: { languageModel: selector(calls) },
-        options: {},
-      })
-      expect(calls).toEqual(["languageModel:claude-sonnet-4-5"])
-    }),
-  )
-
-  it.effect("ignores non Vertex Anthropic providers for language selection", () =>
-    Effect.gen(function* () {
-      const plugin = yield* Plugin.Service
-      const aisdk = yield* AISDK.Service
-      const calls: string[] = []
-      yield* addPlugin(GoogleVertexAnthropicPlugin)
-      const result = yield* aisdk.runLanguage({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("google-vertex"), Model.ID.make("claude-sonnet-4-5")),
-          modelID: Model.ID.make("claude-sonnet-4-5"),
-          package: "aisdk:test-provider",
-        }),
-        sdk: { languageModel: selector(calls) },
-        options: {},
-      })
-      expect(calls).toEqual([])
-      expect(result.language).toBeUndefined()
-    }),
-  )
-})

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

@@ -309,6 +309,27 @@ describe("GoogleVertexPlugin", () => {
     ),
   )
 
+  it.effect("creates Anthropic SDKs for canonical Google Vertex models", () =>
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      const aisdk = yield* AISDK.Service
+      yield* addPlugin()
+      const result = yield* aisdk.runSDK({
+        model: Model.Info.make({
+          ...Model.Info.default(Provider.ID.googleVertex, Model.ID.make("claude-sonnet-4-6@default")),
+          modelID: Model.ID.make("claude-sonnet-4-6@default"),
+          package: "aisdk:@ai-sdk/google-vertex/anthropic",
+        }),
+        package: "@ai-sdk/google-vertex/anthropic",
+        options: { name: "google-vertex", project: "project", location: "eu" },
+      })
+
+      expect(result.sdk.languageModel("claude-sonnet-4-6@default").config.baseURL).toBe(
+        "https://aiplatform.eu.rep.googleapis.com/v1/projects/project/locations/eu/publishers/anthropic/models",
+      )
+    }),
+  )
+
   it.effect("keeps Google auth fetch for OpenAI-compatible Vertex endpoints", () =>
     Effect.gen(function* () {
       googleAuthOptions.length = 0

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

@@ -255,19 +255,19 @@ it.effect("generates from fresh settled Session context without durable mutation
     yield* bus.publish(SessionEvent.Tool.Input.Started, {
       sessionID,
       assistantMessageID: activeAssistant,
-      callID: "active-call",
+      id: "active-call",
       name: "echo",
     })
     yield* bus.publish(SessionEvent.Tool.Input.Ended, {
       sessionID,
       assistantMessageID: activeAssistant,
-      callID: "active-call",
+      id: "active-call",
       text: "{}",
     })
     yield* bus.publish(SessionEvent.Tool.Called, {
       sessionID,
       assistantMessageID: activeAssistant,
-      callID: "active-call",
+      id: "active-call",
       input: {},
       executed: false,
     })

packages/core/test/session-runner-tool-events.test.ts

@@ -237,7 +237,7 @@ test("success event data can carry provider-executed result state", () => {
   const decoded = Schema.decodeUnknownSync(SessionEvent.Tool.Success.data)({
     sessionID,
     assistantMessageID: SessionMessage.ID.create(),
-    callID: "call-old",
+    id: "call-old",
     content: [{ type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png" }],
     executed: true,
     resultState: {

packages/core/test/session-runner-tool-registry.test.ts

@@ -339,7 +339,7 @@ describe("Tool", () => {
         call: { type: "tool-call", id: "call-context", name: "context", input: {} },
       })
       expect(contexts).toEqual([
-        { sessionID, ...identity, callID: Tool.CallID.make("call-context"), progress: expect.any(Function) },
+        { sessionID, ...identity, id: Tool.CallID.make("call-context"), progress: expect.any(Function) },
       ])
     }),
   )

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

@@ -513,6 +513,16 @@ const providerUnavailable = () =>
     reason: new TransportReason({ message: "Provider unavailable" }),
   })
 
+const incompleteStream = () =>
+  new AIError({
+    module: "test",
+    method: "stream",
+    reason: new InvalidProviderOutputReason({
+      classification: "incomplete-stream",
+      message: "The provider response ended unexpectedly.",
+    }),
+  })
+
 const invalidRequest = () =>
   new AIError({
     module: "test",
@@ -935,7 +945,7 @@ describe("SessionRunnerLLM", () => {
       yield* TestLLM.push(TestLLM.tool("call-location", "location_context", { query: "hello" }), [])
       const bus = yield* Bus.Service
       const progressFiber = yield* bus.subscribe(SessionEvent.Tool.Progress).pipe(
-        Stream.filter((event) => event.data.sessionID === sessionID && event.data.callID === "call-location"),
+        Stream.filter((event) => event.data.sessionID === sessionID && event.data.id === "call-location"),
         Stream.take(1),
         Stream.runCollect,
         Effect.forkScoped({ startImmediately: true }),
@@ -949,7 +959,7 @@ describe("SessionRunnerLLM", () => {
           sessionID,
           agent: Agent.ID.make("build"),
           messageID: expect.stringMatching(/^msg_/),
-          callID: Tool.CallID.make("call-location"),
+          id: Tool.CallID.make("call-location"),
           progress: expect.any(Function),
         },
       ])
@@ -2382,7 +2392,7 @@ describe("SessionRunnerLLM", () => {
 
       expect(requests).toHaveLength(2)
       expect(messageRoles(requests[1])).toEqual(["user", "assistant", "tool"])
-      expect(authorizations).toMatchObject([{ sessionID, callID: "call-echo" }])
+      expect(authorizations).toMatchObject([{ sessionID, id: "call-echo" }])
       expect(executions).toEqual(["hello"])
       const context = yield* session.context(sessionID)
       expect(context).toMatchObject([
@@ -2994,19 +3004,19 @@ describe("SessionRunnerLLM", () => {
       yield* bus.publish(SessionEvent.Tool.Input.Started, {
         sessionID,
         assistantMessageID,
-        callID: "call-interrupted",
+        id: "call-interrupted",
         name: "echo",
       })
       yield* bus.publish(SessionEvent.Tool.Input.Ended, {
         sessionID,
         assistantMessageID,
-        callID: "call-interrupted",
+        id: "call-interrupted",
         text: '{"text":"stale"}',
       })
       yield* bus.publish(SessionEvent.Tool.Called, {
         sessionID,
         assistantMessageID,
-        callID: "call-interrupted",
+        id: "call-interrupted",
         input: { text: "stale" },
         executed: false,
       })
@@ -3051,19 +3061,19 @@ describe("SessionRunnerLLM", () => {
       yield* bus.publish(SessionEvent.Tool.Input.Started, {
         sessionID,
         assistantMessageID,
-        callID: "call-hosted-interrupted",
+        id: "call-hosted-interrupted",
         name: "web_search",
       })
       yield* bus.publish(SessionEvent.Tool.Input.Ended, {
         sessionID,
         assistantMessageID,
-        callID: "call-hosted-interrupted",
+        id: "call-hosted-interrupted",
         text: '{"query":"stale"}',
       })
       yield* bus.publish(SessionEvent.Tool.Called, {
         sessionID,
         assistantMessageID,
-        callID: "call-hosted-interrupted",
+        id: "call-hosted-interrupted",
         input: { query: "stale" },
         executed: true,
         state: { itemId: "call-hosted-interrupted" },
@@ -3102,7 +3112,7 @@ describe("SessionRunnerLLM", () => {
       yield* bus.publish(SessionEvent.Tool.Input.Started, {
         sessionID,
         assistantMessageID,
-        callID: "call-pending-interrupted",
+        id: "call-pending-interrupted",
         name: "echo",
       })
       requests.length = 0
@@ -3949,6 +3959,26 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
+  it.effect("retries an incomplete stream before output", () =>
+    Effect.gen(function* () {
+      const session = yield* setup
+      yield* admit(session, "Retry incomplete stream")
+      yield* TestLLM.push(Stream.fail(incompleteStream()))
+      yield* TestLLM.push(TestLLM.text("Recovered", "incomplete-stream-success"))
+
+      const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
+      yield* TestLLM.wait(1)
+      yield* TestClock.adjust("2 seconds")
+      yield* Fiber.join(run)
+
+      expect(requests).toHaveLength(2)
+      expect(yield* session.context(sessionID)).toMatchObject([
+        { type: "user" },
+        { type: "assistant", finish: "stop", content: [{ type: "text", text: "Recovered" }] },
+      ])
+    }),
+  )
+
   it.effect("uses a larger provider retry-after delay", () =>
     Effect.gen(function* () {
       const session = yield* setup
@@ -3969,7 +3999,7 @@ describe("SessionRunnerLLM", () => {
   it.effect("does not retry eligible failures after observable output", () =>
     Effect.gen(function* () {
       const session = yield* setup
-      const failure = rateLimited()
+      const failure = incompleteStream()
       yield* TestLLM.push(
         TestLLM.failAfter(
           failure,
@@ -3987,7 +4017,7 @@ describe("SessionRunnerLLM", () => {
         {
           type: "assistant",
           finish: "error",
-          error: { type: "provider.rate-limit" },
+          error: { type: "provider.invalid-output" },
           content: [{ type: "text", text: "Partial" }],
         },
       ])
@@ -4120,7 +4150,7 @@ describe("SessionRunnerLLM", () => {
         {
           type: "session.tool.failed.2",
           data: {
-            callID: "call-malformed",
+            id: "call-malformed",
             error: { type: "provider.invalid-output", message: "Invalid JSON input for tool call echo" },
           },
         },
@@ -4220,7 +4250,7 @@ describe("SessionRunnerLLM", () => {
         .all()
         .pipe(Effect.orDie)
       expect(durable.find((event) => event.type === "session.tool.input.ended.1")?.data).toMatchObject({
-        callID: "call-malformed",
+        id: "call-malformed",
         text: raw,
       })
     }),
@@ -4616,13 +4646,13 @@ describe("SessionRunnerLLM", () => {
 
       const assistant = requireAssistant(yield* session.context(sessionID))
       const bus = yield* recordedStepSettlementEvents(sessionID, assistant.id)
-      expect(bus.map((event) => ({ type: event.type, callID: event.data.callID }))).toEqual([
-        { type: "session.step.started.1", callID: undefined },
-        { type: "session.tool.called.1", callID: "call-local-raw-failure" },
-        { type: "session.tool.called.1", callID: "call-hosted-raw-failure-pair" },
-        { type: "session.tool.failed.2", callID: "call-local-raw-failure" },
-        { type: "session.tool.failed.2", callID: "call-hosted-raw-failure-pair" },
-        { type: "session.step.failed.1", callID: undefined },
+      expect(bus.map((event) => ({ type: event.type, id: event.data.id }))).toEqual([
+        { type: "session.step.started.1", id: undefined },
+        { type: "session.tool.called.1", id: "call-local-raw-failure" },
+        { type: "session.tool.called.1", id: "call-hosted-raw-failure-pair" },
+        { type: "session.tool.failed.2", id: "call-local-raw-failure" },
+        { type: "session.tool.failed.2", id: "call-hosted-raw-failure-pair" },
+        { type: "session.step.failed.1", id: undefined },
       ])
       expect(
         bus.filter((event) => event.type.startsWith("session.step.") && event.type !== "session.step.started.1"),

packages/core/test/session-tool-progress.test.ts

@@ -65,18 +65,18 @@ describe("Tool.Metadata", () => {
         if (!row) return yield* Effect.die("Missing projected assistant")
         return Schema.decodeUnknownSync(SessionMessage.Assistant)({ ...row.data, id: row.id, type: row.type })
       })
-      const start = (callID: string) =>
+      const start = (id: string) =>
         Effect.gen(function* () {
           yield* service.publish(SessionEvent.Tool.Input.Started, {
             sessionID,
             assistantMessageID,
-            callID,
+            id,
             name: "bash",
           })
           yield* service.publish(SessionEvent.Tool.Called, {
             sessionID,
             assistantMessageID,
-            callID,
+            id,
             input: { command: "pwd" },
             executed: false,
           })
@@ -90,7 +90,7 @@ describe("Tool.Metadata", () => {
       const progress = yield* service.publish(SessionEvent.Tool.Progress, {
         sessionID,
         assistantMessageID,
-        callID: "call-success",
+        id: "call-success",
         metadata: { phase: "checkpoint" },
       })
       expect((yield* readAssistant).content[0]).toMatchObject({
@@ -100,7 +100,7 @@ describe("Tool.Metadata", () => {
       const success = yield* service.publish(SessionEvent.Tool.Success, {
         sessionID,
         assistantMessageID,
-        callID: "call-success",
+        id: "call-success",
         metadata: { phase: "done" },
         content: content("complete"),
         executed: false,
@@ -113,13 +113,13 @@ describe("Tool.Metadata", () => {
       yield* service.publish(SessionEvent.Tool.Progress, {
         sessionID,
         assistantMessageID,
-        callID: "call-failed",
+        id: "call-failed",
         metadata: { phase: "checkpoint" },
       })
       const failed = yield* service.publish(SessionEvent.Tool.Failed, {
         sessionID,
         assistantMessageID,
-        callID: "call-failed",
+        id: "call-failed",
         error: { type: "unknown", message: "boom" },
         metadata: { phase: "checkpoint" },
         content: content("before failure"),

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

@@ -12,7 +12,7 @@ const context = {
   sessionID: Session.ID.make("ses_execute"),
   agent: Agent.ID.make("build"),
   messageID: SessionMessage.ID.make("msg_execute"),
-  callID: Tool.CallID.make("call_execute"),
+  id: Tool.CallID.make("call_execute"),
   progress: () => Effect.void,
 }
 

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

@@ -166,7 +166,7 @@ describe("QuestionTool", () => {
       expect(capturedInput()).toEqual({
         sessionID,
         title: "Questions",
-        metadata: { kind: "question", tool: { messageID: toolIdentity.messageID, callID: "call-question" } },
+        metadata: { kind: "question", tool: { messageID: toolIdentity.messageID, id: "call-question" } },
         fields: [
           {
             key: "q0",
@@ -212,7 +212,7 @@ describe("QuestionTool", () => {
       expect(capturedInput()).toEqual({
         sessionID,
         title: "Questions",
-        metadata: { kind: "question", tool: { messageID: toolIdentity.messageID, callID: "call-question" } },
+        metadata: { kind: "question", tool: { messageID: toolIdentity.messageID, id: "call-question" } },
         fields: [
           {
             key: "q0",

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

@@ -257,6 +257,31 @@ describe("ShellTool", () => {
     ),
   )
 
+  it.live("reports a missing workdir", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => {
+        reset()
+        return withSession(tmp.path, (registry) =>
+          executeTool(registry, call({ command: cwdCommand, workdir: "missing" })),
+        ).pipe(
+          Effect.andThen((settled) =>
+            Effect.sync(() =>
+              expect(settled).toEqual({
+                status: "error",
+                error: {
+                  type: "unknown",
+                  message: `Working directory does not exist: ${path.join(tmp.path, "missing")}`,
+                },
+              }),
+            ),
+          ),
+        )
+      },
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
+    ),
+  )
+
   it.live("permissions compound commands separately", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

packages/plugin/src/effect/tool.ts

@@ -17,7 +17,7 @@ export interface ToolHooks {
     readonly sessionID: Session.ID
     readonly agent: Agent.ID
     readonly messageID: SessionMessage.ID
-    readonly callID: Tool.CallID
+    readonly id: Tool.CallID
     input: unknown
   }
   readonly "execute.after": {
@@ -25,7 +25,7 @@ export interface ToolHooks {
     readonly sessionID: Session.ID
     readonly agent: Agent.ID
     readonly messageID: SessionMessage.ID
-    readonly callID: Tool.CallID
+    readonly id: Tool.CallID
     readonly input: unknown
   } & (
     | {

packages/plugin/src/promise/tool.ts

@@ -34,7 +34,7 @@ interface ToolHooks {
     readonly sessionID: Session.ID
     readonly agent: Agent.ID
     readonly messageID: SessionMessage.ID
-    readonly callID: Tool.CallID
+    readonly id: Tool.CallID
     input: unknown
   }
   readonly "execute.after": {
@@ -42,7 +42,7 @@ interface ToolHooks {
     readonly sessionID: Session.ID
     readonly agent: Agent.ID
     readonly messageID: SessionMessage.ID
-    readonly callID: Tool.CallID
+    readonly id: Tool.CallID
     readonly input: unknown
   } & (
     | {

packages/schema/src/permission.ts

@@ -17,7 +17,7 @@ export const Source = Schema.Union([
   Schema.Struct({
     type: Schema.Literal("tool"),
     messageID: Schema.String,
-    callID: Schema.String,
+    id: Schema.String,
   }),
 ]).annotate({ identifier: "Permission.Source" })
 export type Source = typeof Source.Type

packages/schema/src/question.ts

@@ -45,7 +45,7 @@ export interface Prompt extends Schema.Schema.Type<typeof Prompt> {}
 
 export const Tool = Schema.Struct({
   messageID: Schema.String,
-  callID: Schema.String,
+  id: Schema.String,
 }).annotate({ identifier: "Question.Tool" })
 export interface Tool extends Schema.Schema.Type<typeof Tool> {}
 

packages/schema/src/session-event.ts

@@ -365,7 +365,7 @@ export namespace Tool {
   const ToolBase = {
     ...Base,
     assistantMessageID: SessionMessage.ID,
-    callID: Schema.String,
+    id: Schema.String,
   }
 
   export namespace Input {

packages/schema/src/tool.ts

@@ -15,7 +15,7 @@ export interface Context {
   readonly sessionID: Session.ID
   readonly agent: Agent.ID
   readonly messageID: SessionMessage.ID
-  readonly callID: CallID
+  readonly id: CallID
   readonly progress: (update: Metadata) => Effect.Effect<void>
 }
 

packages/schema/test/event-manifest.test.ts

@@ -177,7 +177,7 @@ describe("public event manifest", () => {
     const tool = SessionEvent.Tool.Called.data.make({
       sessionID,
       assistantMessageID,
-      callID: "call_test",
+      id: "call_test",
       input: {},
       executed: true,
       state: { itemId: "item_test" },

packages/simulation/src/backend/simulated-provider.ts

@@ -477,7 +477,7 @@ const makeToolDriver = Effect.fn("SimulatedProvider.makeToolDriver")(function* (
                     sessionID: context.sessionID,
                     agent: context.agent,
                     messageID: context.messageID,
-                    callID: context.callID,
+                    id: context.id,
                   },
                 }
                 const pending: PendingToolInvocation = {

packages/simulation/src/protocol/index.ts

@@ -503,7 +503,7 @@ export namespace Backend {
       sessionID: Schema.String,
       agent: Schema.String,
       messageID: Schema.String,
-      callID: Schema.String,
+      id: Schema.String,
     }),
   })
   export interface ToolInvocation extends Schema.Schema.Type<typeof ToolInvocation> {}

packages/simulation/test/simulated-provider.test.ts

@@ -279,7 +279,7 @@ test("controls arbitrary tools through scoped SDK overlays", async () => {
             expect.objectContaining({ name: "lookup", description: "Look up a value" }),
           )
           const progress: Tool.Metadata[] = []
-          const executeCall = (callID: string, query: string) =>
+          const executeCall = (id: string, query: string) =>
             toolSet.execute({
               sessionID: Session.ID.make("ses_simulated_tools"),
               agent: Agent.ID.make("build"),
@@ -287,7 +287,7 @@ test("controls arbitrary tools through scoped SDK overlays", async () => {
               progress: (update) => Effect.sync(() => progress.push(update)),
               call: {
                 type: "tool-call",
-                id: callID,
+                id: id,
                 name: "lookup",
                 input: { query },
               },
@@ -302,7 +302,7 @@ test("controls arbitrary tools through scoped SDK overlays", async () => {
               sessionID: "ses_simulated_tools",
               agent: "build",
               messageID: "msg_simulated_tools",
-              callID: "call_success",
+              id: "call_success",
             },
           })
           const successID = requireString(requireRecord(successInvocation.params).id)
@@ -420,25 +420,25 @@ test("controls arbitrary tools through scoped SDK overlays", async () => {
             invocations.map((invocation) => {
               const params = requireRecord(invocation.params)
               const context = requireRecord(params.context)
-              return [requireString(context.callID), requireString(params.id)]
+              return [requireString(context.id), requireString(params.id)]
             }),
           )
-          for (const [id, callID, value] of [
+          for (const [requestID, toolID, value] of [
             [5, "call_second", "second result"],
             [6, "call_first", "first result"],
           ] as const) {
             socket.send(
               JSON.stringify({
                 jsonrpc: "2.0",
-                id,
+                id: requestID,
                 method: "tool.finish",
                 params: {
-                  id: byCall.get(callID),
+                  id: byCall.get(toolID),
                   output: { structured: value, content: [{ type: "text", text: value }] },
                 },
               }),
             )
-            expect(yield* Queue.take(messages)).toMatchObject({ id, result: { ok: true } })
+            expect(yield* Queue.take(messages)).toMatchObject({ id: requestID, result: { ok: true } })
           }
           expect(yield* Fiber.join(concurrent[0])).toMatchObject({
             output: "first result",

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

@@ -88,10 +88,10 @@ export const Definitions = {
   session_new: keybind("<leader>n", "Create a new session"),
   session_list: keybind("<leader>l", "List all sessions"),
   open_menu: keybind("ctrl+o", "Open recent sessions and projects"),
-  session_tab_next: keybind("ctrl+tab,<leader>right,alt+shift+]", "Switch to next open tab"),
-  session_tab_previous: keybind("ctrl+shift+tab,<leader>left,alt+shift+[", "Switch to previous open tab"),
-  session_tab_next_unread: keybind("<leader>down", "Switch to next unread tab"),
-  session_tab_previous_unread: keybind("<leader>up", "Switch to previous unread tab"),
+  session_tab_next: keybind("ctrl+tab,alt+down", "Switch to next open tab"),
+  session_tab_previous: keybind("ctrl+shift+tab,alt+up", "Switch to previous open tab"),
+  session_tab_next_unread: keybind("alt+shift+down", "Switch to next unread tab"),
+  session_tab_previous_unread: keybind("alt+shift+up", "Switch to previous unread tab"),
   session_tab_close: keybind("<leader>w", "Close current tab"),
   session_tab_reopen: keybind("ctrl+shift+t", "Reopen last closed tab"),
   session_timeline: keybind("<leader>g", "Show session timeline"),
@@ -150,10 +150,10 @@ export const Definitions = {
   messages_half_page_down: keybind("ctrl+alt+d", "Scroll messages down by half page"),
   messages_first: keybind("ctrl+g,home,alt+home", "Navigate to first message"),
   messages_last: keybind("ctrl+alt+g,end", "Navigate to last message"),
-  messages_next: keybind("alt+down", "Navigate to next message"),
-  messages_previous: keybind("alt+up", "Navigate to previous message"),
-  messages_next_user: keybind("alt+shift+down", "Navigate to next user message"),
-  messages_previous_user: keybind("alt+shift+up", "Navigate to previous user message"),
+  messages_next: keybind("none", "Navigate to next message"),
+  messages_previous: keybind("none", "Navigate to previous message"),
+  messages_next_user: keybind("none", "Navigate to next user message"),
+  messages_previous_user: keybind("none", "Navigate to previous user message"),
   messages_last_user: keybind("alt+end", "Navigate to last user message"),
   messages_copy: keybind("<leader>y", "Copy message"),
   messages_undo: keybind("<leader>u", "Undo message"),

packages/tui/src/context/data.tsx

@@ -208,10 +208,10 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         const item = messages.findLast((item) => item.type === "compaction" && item.status === "running")
         return item?.type === "compaction" ? item : undefined
       },
-      latestTool(assistant: SessionMessageAssistant | undefined, callID?: string) {
+      latestTool(assistant: SessionMessageAssistant | undefined, id?: string) {
         return assistant?.content.findLast(
           (item): item is SessionMessageAssistantTool =>
-            item.type === "tool" && (callID === undefined || item.id === callID),
+            item.type === "tool" && (id === undefined || item.id === id),
         )
       },
       latestText(assistant: SessionMessageAssistant | undefined) {
@@ -592,7 +592,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             message.assistant(draft, index, event.data.assistantMessageID)?.content.push({
               type: "tool",
-              id: event.data.callID,
+              id: event.data.id,
               name: event.data.name,
               time: { created: event.created },
               state: { status: "streaming", input: "" },
@@ -603,7 +603,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             const match = message.latestTool(
               message.assistant(draft, index, event.data.assistantMessageID),
-              event.data.callID,
+              event.data.id,
             )
             if (match?.state.status === "streaming") match.state.input += event.data.delta
           })
@@ -612,7 +612,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             const match = message.latestTool(
               message.assistant(draft, index, event.data.assistantMessageID),
-              event.data.callID,
+              event.data.id,
             )
             if (match?.state.status === "streaming") match.state.input = event.data.text
           })
@@ -621,7 +621,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             const match = message.latestTool(
               message.assistant(draft, index, event.data.assistantMessageID),
-              event.data.callID,
+              event.data.id,
             )
             if (!match) return
             match.time.ran = event.created
@@ -634,7 +634,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             const match = message.latestTool(
               message.assistant(draft, index, event.data.assistantMessageID),
-              event.data.callID,
+              event.data.id,
             )
             if (match?.state.status !== "running") return
             match.state.metadata = event.data.metadata
@@ -644,7 +644,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             const match = message.latestTool(
               message.assistant(draft, index, event.data.assistantMessageID),
-              event.data.callID,
+              event.data.id,
             )
             if (match?.state.status !== "running") return
             match.state = {
@@ -662,7 +662,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             const match = message.latestTool(
               message.assistant(draft, index, event.data.assistantMessageID),
-              event.data.callID,
+              event.data.id,
             )
             if (!match || (match.state.status !== "streaming" && match.state.status !== "running")) return
             match.state = {

packages/tui/src/context/session-tabs-model.ts

@@ -82,11 +82,19 @@ export function moveSessionTab(tabs: SessionTab[], sessionID: string, index: num
   return next
 }
 
-export function cycleSessionTab(tabs: readonly SessionTab[], active: string | undefined, direction: 1 | -1) {
+export function cycleSessionTab(
+  tabs: readonly SessionTab[],
+  active: string | undefined,
+  direction: 1 | -1,
+  matches: (tab: SessionTab) => boolean = () => true,
+) {
   if (tabs.length === 0) return
   const index = tabs.findIndex((tab) => tab.sessionID === active)
   const start = index === -1 ? (direction === 1 ? -1 : 0) : index
-  return tabs[(start + direction + tabs.length) % tabs.length]
+  return Array.from(
+    { length: tabs.length },
+    (_, offset) => tabs[(start + direction * (offset + 1) + tabs.length * 2) % tabs.length],
+  ).find(matches)
 }
 
 // In-memory navigation history is bounded so a long-lived TUI does not accumulate one entry per

packages/tui/src/context/session-tabs.tsx

@@ -298,10 +298,8 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       },
       cycleUnread(direction: 1 | -1) {
         if (!enabled()) return
-        const tab = cycleSessionTab(
-          state().tabs.filter((tab) => state().unread[tab.sessionID] || status(tab.sessionID).attention),
-          current(),
-          direction,
+        const tab = cycleSessionTab(state().tabs, current(), direction, (tab) =>
+          Boolean(state().unread[tab.sessionID] || status(tab.sessionID).attention),
         )
         if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
       },

packages/tui/src/mini/demo.ts

@@ -373,7 +373,7 @@ function askPermission(state: State, item: Permit): void {
       resources: item.patterns,
       metadata: item.metadata ?? {},
       save: item.always,
-      source: { type: "tool", messageID: item.ref.msg, callID: item.ref.call },
+      source: { type: "tool", messageID: item.ref.msg, id: item.ref.call },
       tool,
     },
   })
@@ -805,7 +805,7 @@ function emitForm(state: State, kind: FormKind = "question"): void {
     title: form.title,
     metadata:
       kind === "question"
-        ? { kind: "question", tool: { messageID: ref.msg, callID: ref.call } }
+        ? { kind: "question", tool: { messageID: ref.msg, id: ref.call } }
         : { kind: "mcp", message: `Synthetic ${kind} MCP elicitation` },
     fields: form.fields,
   }

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

@@ -164,13 +164,13 @@ function text(value: unknown): string | undefined {
   return next || undefined
 }
 
-function sourceKey(messageID: string, callID: string) {
-  return `${messageID}\u0000${callID}`
+function sourceKey(messageID: string, id: string) {
+  return `${messageID}\u0000${id}`
 }
 
 function permissionTool(request: PermissionRequest, tools: Map<string, SessionMessageAssistantTool>) {
   if (request.source?.type !== "tool") return request
-  const tool = tools.get(sourceKey(request.source.messageID, request.source.callID))
+  const tool = tools.get(sourceKey(request.source.messageID, request.source.id))
   return tool ? { ...request, tool } : request
 }
 
@@ -444,7 +444,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       ...new Set(
         permissions.flatMap((request) => {
           if (request.source?.type !== "tool") return []
-          const key = sourceKey(request.source.messageID, request.source.callID)
+          const key = sourceKey(request.source.messageID, request.source.id)
           return child.toolSources.has(key) ? [] : [request.source.messageID]
         }),
       ),
@@ -475,7 +475,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       permissions.some(
         (request) =>
           request.source?.type === "tool" &&
-          !child.toolSources.has(sourceKey(request.source.messageID, request.source.callID)),
+          !child.toolSources.has(sourceKey(request.source.messageID, request.source.id)),
       )
     )
       throw new Error("Permission source tool is unavailable")
@@ -737,12 +737,12 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       return
     }
     if (event.type === "session.tool.input.started") {
-      if (child.finishedTools.has(sourceKey(event.data.assistantMessageID, event.data.callID))) return
+      if (child.finishedTools.has(sourceKey(event.data.assistantMessageID, event.data.id))) return
       childTool(
         child,
         {
           type: "tool",
-          id: event.data.callID,
+          id: event.data.id,
           name: event.data.name,
           state: { status: "streaming", input: "" },
           time: { created: event.created },
@@ -752,7 +752,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       return
     }
     if (event.type === "session.tool.input.delta" || event.type === "session.tool.input.ended") {
-      const current = child.tools.get(sourceKey(event.data.assistantMessageID, event.data.callID))
+      const current = child.tools.get(sourceKey(event.data.assistantMessageID, event.data.id))
       if (!current || current.part.state.status !== "streaming") return
       childTool(
         child,
@@ -769,14 +769,14 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       return
     }
     if (event.type === "session.tool.called") {
-      const key = sourceKey(event.data.assistantMessageID, event.data.callID)
+      const key = sourceKey(event.data.assistantMessageID, event.data.id)
       if (child.finishedTools.has(key)) return
       const current = child.tools.get(key)
       childTool(
         child,
         {
           type: "tool",
-          id: event.data.callID,
+          id: event.data.id,
           name: current?.part.name ?? "tool",
           executed: event.data.executed,
           providerState: event.data.state,
@@ -790,7 +790,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       return
     }
     if (event.type === "session.tool.progress") {
-      const key = sourceKey(event.data.assistantMessageID, event.data.callID)
+      const key = sourceKey(event.data.assistantMessageID, event.data.id)
       if (child.finishedTools.has(key)) return
       const current = child.tools.get(key)
       const part = current?.part
@@ -798,7 +798,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
         child,
         {
           type: "tool",
-          id: event.data.callID,
+          id: event.data.id,
           name: part?.name ?? "tool",
           executed: part?.executed,
           providerState: part?.providerState,
@@ -819,7 +819,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       return
     }
     if (event.type === "session.tool.success" || event.type === "session.tool.failed") {
-      const key = sourceKey(event.data.assistantMessageID, event.data.callID)
+      const key = sourceKey(event.data.assistantMessageID, event.data.id)
       if (child.finishedTools.has(key)) return
       const current = child.tools.get(key)
       const part = current?.part
@@ -828,7 +828,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
         child,
         {
           type: "tool",
-          id: event.data.callID,
+          id: event.data.id,
           name: part?.name ?? "tool",
           executed: event.data.executed,
           providerState: part?.providerState,
@@ -947,11 +947,11 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
       if (!active(signal)) return
       if (event.type === "session.tool.input.started") {
         if (canonicalToolName(event.data.name) === "subagent")
-          pendingCalls.set(sourceKey(event.data.assistantMessageID, event.data.callID), {})
+          pendingCalls.set(sourceKey(event.data.assistantMessageID, event.data.id), {})
         return
       }
       if (event.type === "session.tool.called") {
-        const key = sourceKey(event.data.assistantMessageID, event.data.callID)
+        const key = sourceKey(event.data.assistantMessageID, event.data.id)
         if (pendingCalls.has(key)) pendingCalls.set(key, event.data.input)
         return
       }
@@ -961,7 +961,7 @@ export function createSubagentTracker(input: SubagentTrackerInput): SubagentTrac
         event.type !== "session.tool.failed"
       )
         return
-      const key = sourceKey(event.data.assistantMessageID, event.data.callID)
+      const key = sourceKey(event.data.assistantMessageID, event.data.id)
       const pending = pendingCalls.get(key)
       if (event.type !== "session.tool.progress") pendingCalls.delete(key)
       const found = childSessionID(record(event.data.metadata))

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

@@ -91,12 +91,12 @@ type Wait = {
 }
 
 // One active session.shell call. The HTTP response is the completion signal;
-// callID correlates the live shell events once shell.started is observed, and
+// id correlates the live shell events once shell.started is observed, and
 // abort cancels the blocking request when the user interrupts the turn.
 type ShellWait = {
   eventID: string
   messageID: string
-  callID?: string
+  id?: string
   resolve: () => void
   abort: () => void
 }
@@ -291,27 +291,27 @@ function streamPartKey(messageID: string, partID: string) {
   return `${messageID}\u0000${partID}`
 }
 
-function permissionSourceKey(messageID: string, callID: string) {
-  return streamPartKey(messageID, callID)
+function permissionSourceKey(messageID: string, id: string) {
+  return streamPartKey(messageID, id)
 }
 
 function permissionTool(request: PermissionRequest, tools: Map<string, SessionMessageAssistantTool>) {
   if (request.source?.type !== "tool") return request
-  const tool = tools.get(permissionSourceKey(request.source.messageID, request.source.callID))
+  const tool = tools.get(permissionSourceKey(request.source.messageID, request.source.id))
   return tool ? { ...request, tool } : request
 }
 
 // Direct shell calls use one "start" commit rendering `$ command` and one "progress"
 // commit rendering the merged output (see toolEntryBody in tool.ts).
 function shellCommit(
-  callID: string,
+  id: string,
   command: string,
   next: Pick<StreamCommit, "text" | "phase" | "toolState" | "toolError">,
 ): StreamCommit {
   return {
     kind: "tool",
     source: "tool",
-    partID: `shell:${callID}`,
+    partID: `shell:${id}`,
     tool: "shell",
     shell: { command },
     ...next,
@@ -319,7 +319,7 @@ function shellCommit(
 }
 
 function shellTerminal(
-  callID: string,
+  id: string,
   command: string,
   shell: { status: string; exit?: number | string },
   output: { output: string; cursor: number; size: number; truncated: boolean },
@@ -332,10 +332,10 @@ function shellTerminal(
       : shell.status === "exited"
         ? `Shell exited with code ${shell.exit ?? "unknown"}`
         : `Shell ${shell.status}`
-  if (!error) return [shellCommit(callID, command, { text, phase: "progress", toolState: "completed" })]
+  if (!error) return [shellCommit(id, command, { text, phase: "progress", toolState: "completed" })]
   return [
-    ...(text ? [shellCommit(callID, command, { text, phase: "progress", toolState: "running" })] : []),
-    shellCommit(callID, command, { text: error, phase: "final", toolState: "error", toolError: error }),
+    ...(text ? [shellCommit(id, command, { text, phase: "progress", toolState: "running" })] : []),
+    shellCommit(id, command, { text: error, phase: "final", toolState: "error", toolError: error }),
   ]
 }
 
@@ -570,7 +570,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
   const sourcePending = (key: string) =>
     state.permissions.some(
       (request) =>
-        request.source?.type === "tool" && permissionSourceKey(request.source.messageID, request.source.callID) === key,
+        request.source?.type === "tool" && permissionSourceKey(request.source.messageID, request.source.id) === key,
     )
 
   const pruneToolSources = () => {
@@ -647,7 +647,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
     }
     if (message.type === "shell") {
       state.shellCommands.set(message.shellID, message.command)
-      if (state.shellWait?.messageID === message.id) state.shellWait.callID = message.shellID
+      if (state.shellWait?.messageID === message.id) state.shellWait.id = message.shellID
       const completed = message.time.completed !== undefined
       if (!render) {
         // Suppressed history: mark settled shells rendered so live redelivery
@@ -673,7 +673,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
         state.shellEnded.add(message.shellID)
         write(shellTerminal(message.shellID, message.command, message, message.output))
       }
-      if (completed && state.shellWait?.callID === message.shellID) state.shellWait.resolve()
+      if (completed && state.shellWait?.id === message.shellID) state.shellWait.resolve()
       return
     }
     if (message.type === "compaction") {
@@ -776,14 +776,14 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
   ) => {
     const pending = new Set(
       permissions.flatMap((request) =>
-        request.source?.type === "tool" ? [permissionSourceKey(request.source.messageID, request.source.callID)] : [],
+        request.source?.type === "tool" ? [permissionSourceKey(request.source.messageID, request.source.id)] : [],
       ),
     )
     const messageIDs = [
       ...new Set(
         permissions.flatMap((request) => {
           if (request.source?.type !== "tool") return []
-          const key = permissionSourceKey(request.source.messageID, request.source.callID)
+          const key = permissionSourceKey(request.source.messageID, request.source.id)
           return state.toolSources.has(key) ? [] : [request.source.messageID]
         }),
       ),
@@ -992,7 +992,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
     if (event.type === "session.shell.started") {
       state.shellCommands.set(event.data.shell.id, event.data.shell.command)
       const wait = state.shellWait
-      if (wait?.eventID === event.id) wait.callID = event.data.shell.id
+      if (wait?.eventID === event.id) wait.id = event.data.shell.id
       if (state.shellStarted.has(event.data.shell.id)) return
       state.shellStarted.add(event.data.shell.id)
       write(
@@ -1025,7 +1025,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
         commits.push(...shellTerminal(event.data.shell.id, command, event.data.shell, event.data.output))
       }
       const wait = state.shellWait
-      const owned = wait?.callID === event.data.shell.id
+      const owned = wait?.id === event.data.shell.id
       write(commits, owned || state.wait || state.shellWait ? undefined : { phase: "idle", status: "" })
       if (owned) wait.resolve()
       return
@@ -1109,7 +1109,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
     if (event.type === "session.tool.input.started") {
       renderTool(event.data.assistantMessageID, {
         type: "tool",
-        id: event.data.callID,
+        id: event.data.id,
         name: event.data.name,
         state: { status: "streaming", input: "" },
         time: { created: event.created },
@@ -1117,7 +1117,7 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       return
     }
     if (event.type === "session.tool.input.delta" || event.type === "session.tool.input.ended") {
-      const current = state.tools.get(streamPartKey(event.data.assistantMessageID, event.data.callID))
+      const current = state.tools.get(streamPartKey(event.data.assistantMessageID, event.data.id))
       if (!current || current.part.state.status !== "streaming") return
       renderTool(event.data.assistantMessageID, {
         ...current.part,
@@ -1130,12 +1130,12 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       return
     }
     if (event.type === "session.tool.called") {
-      const key = streamPartKey(event.data.assistantMessageID, event.data.callID)
+      const key = streamPartKey(event.data.assistantMessageID, event.data.id)
       if (state.finishedTools.has(key)) return
       const current = state.tools.get(key)
       const item: SessionMessageAssistantTool = {
         type: "tool",
-        id: event.data.callID,
+        id: event.data.id,
         name: current?.part.name ?? "tool",
         executed: event.data.executed,
         providerState: event.data.state,
@@ -1146,13 +1146,13 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       return
     }
     if (event.type === "session.tool.progress") {
-      const key = streamPartKey(event.data.assistantMessageID, event.data.callID)
+      const key = streamPartKey(event.data.assistantMessageID, event.data.id)
       if (state.finishedTools.has(key)) return
       const current = state.tools.get(key)
       const part = current?.part
       renderTool(event.data.assistantMessageID, {
         type: "tool",
-        id: event.data.callID,
+        id: event.data.id,
         name: part?.name ?? "tool",
         executed: part?.executed,
         providerState: part?.providerState,
@@ -1166,12 +1166,12 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
       return
     }
     if (event.type === "session.tool.success" || event.type === "session.tool.failed") {
-      const current = state.tools.get(streamPartKey(event.data.assistantMessageID, event.data.callID))
+      const current = state.tools.get(streamPartKey(event.data.assistantMessageID, event.data.id))
       const part = current?.part
       const failed = event.type === "session.tool.failed"
       const item: SessionMessageAssistantTool = {
         type: "tool",
-        id: event.data.callID,
+        id: event.data.id,
         name: part?.name ?? "tool",
         executed: event.data.executed,
         providerState: part?.providerState,

packages/tui/src/mini/types.ts

@@ -244,11 +244,11 @@ type MiniToolState =
 // Retained only for the noninteractive run JSON/V1 compatibility boundary.
 // Interactive Mini commits carry SessionMessageAssistantTool directly.
 export type MiniToolPart = {
-  id: string
+  partID: string
   sessionID: string
   messageID: string
   type?: "tool"
-  callID: string
+  id: string
   tool: string
   state: MiniToolState
 }

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

@@ -2227,7 +2227,7 @@ function useToolPermission(part: () => SessionMessageAssistantTool | undefined)
   return createMemo(() => {
     if (local.permission.mode === "auto") return false
     const request = data.session.permission.list(ctx.sessionID)?.[0]
-    return request?.source?.type === "tool" && request.source.callID === part()?.id
+    return request?.source?.type === "tool" && request.source.id === part()?.id
   })
 }