@get-bb/plugin-sdk 0.4.87 → 0.4.94

package/dist/provider-bridge-acp.js

@@ -1751,6 +1751,8 @@ var threadEventTokenUsageBreakdownSchema = z15.object({
   totalTokens: z15.number(),
   inputTokens: z15.number(),
   cachedInputTokens: z15.number(),
+  cacheReadInputTokens: z15.number().nonnegative().optional(),
+  cacheWriteInputTokens: z15.number().nonnegative().optional(),
   outputTokens: z15.number(),
   reasoningOutputTokens: z15.number()
 });
@@ -3760,9 +3762,11 @@ async function resolveExecutablePath(command) {
 }
 async function readCliVersion(command) {
   try {
-    const { stdout, stderr } = await execFileAsync(command, ["--version"], {
+    const probe = execFileAsync(command, ["--version"], {
       timeout: CLI_PROBE_TIMEOUT_MS
     });
+    probe.child.stdin?.end();
+    const { stdout, stderr } = await probe;
     return `${stdout}
 ${stderr}`.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/u)?.[0] ?? null;
   } catch {
@@ -3785,6 +3789,13 @@ function clampPercent(value) {
   );
 }
 
+// ../provider-bridge-protocol/src/bridge-kit/provider-tool-call-contract.ts
+import { z as z32 } from "zod";
+var providerToolCallCancellationSchema = z32.object({
+  requestId: z32.union([z32.string(), z32.number().int()])
+});
+var PROVIDER_TOOL_CALL_CANCELLED_METHOD = "notifications/cancelled";
+
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility.ts
 function createProviderVisibilityMetadata(args) {
   return {
@@ -3797,8 +3808,8 @@ function createProviderVisibilityMetadata(args) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
-import { z as z32 } from "zod";
-var ignoredJsonRpcResultSchema = z32.unknown();
+import { z as z33 } from "zod";
+var ignoredJsonRpcResultSchema = z33.unknown();
 
 // ../provider-bridge-acp/src/bridge/bridge.ts
 import { execFile as execFile4 } from "node:child_process";
@@ -3808,21 +3819,21 @@ import { createServer } from "node:net";
 import { dirname as dirname2, isAbsolute, basename as basename3, relative, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 
 // ../provider-bridge-acp/src/wire.ts
-import { z as z33 } from "zod";
-var acpTextContentBlockSchema = z33.object({
-  type: z33.literal("text"),
-  text: z33.string()
+import { z as z34 } from "zod";
+var acpTextContentBlockSchema = z34.object({
+  type: z34.literal("text"),
+  text: z34.string()
 }).passthrough();
-var acpOtherContentBlockSchema = z33.object({
-  type: z33.string()
+var acpOtherContentBlockSchema = z34.object({
+  type: z34.string()
 }).passthrough();
-var acpContentBlockSchema = z33.union([
+var acpContentBlockSchema = z34.union([
   acpTextContentBlockSchema,
   acpOtherContentBlockSchema
 ]);
@@ -3845,7 +3856,7 @@ var ACP_TOOL_KINDS = [
   "switch_mode",
   "other"
 ];
-var acpToolKindSchema = z33.enum(ACP_TOOL_KINDS);
+var acpToolKindSchema = z34.enum(ACP_TOOL_KINDS);
 var ACP_TOOL_KIND_SET = new Set(ACP_TOOL_KINDS);
 var ACP_TOOL_CALL_STATUSES = [
   "pending",
@@ -3854,48 +3865,48 @@ var ACP_TOOL_CALL_STATUSES = [
   "failed",
   "cancelled"
 ];
-var acpToolCallStatusSchema = z33.enum(ACP_TOOL_CALL_STATUSES);
+var acpToolCallStatusSchema = z34.enum(ACP_TOOL_CALL_STATUSES);
 var ACP_TOOL_CALL_STATUS_SET = new Set(
   ACP_TOOL_CALL_STATUSES
 );
-var acpToolCallContentSchema = z33.union([
-  z33.object({
-    type: z33.literal("content"),
+var acpToolCallContentSchema = z34.union([
+  z34.object({
+    type: z34.literal("content"),
     content: acpContentBlockSchema
   }).passthrough(),
-  z33.object({
-    type: z33.literal("diff"),
-    path: z33.string(),
-    oldText: z33.string().nullable().optional(),
-    newText: z33.string()
+  z34.object({
+    type: z34.literal("diff"),
+    path: z34.string(),
+    oldText: z34.string().nullable().optional(),
+    newText: z34.string()
   }).passthrough(),
-  z33.object({
-    type: z33.literal("terminal"),
-    terminalId: z33.string()
+  z34.object({
+    type: z34.literal("terminal"),
+    terminalId: z34.string()
   }).passthrough()
 ]);
-var acpToolCallContentListSchema = z33.array(z33.unknown()).transform(
+var acpToolCallContentListSchema = z34.array(z34.unknown()).transform(
   (entries) => entries.flatMap((entry) => {
     const parsed = acpToolCallContentSchema.safeParse(entry);
     return parsed.success ? [parsed.data] : [];
   })
 );
-var acpToolCallLocationSchema = z33.object({
-  path: z33.string(),
-  line: z33.number().optional().nullable()
+var acpToolCallLocationSchema = z34.object({
+  path: z34.string(),
+  line: z34.number().optional().nullable()
 }).passthrough();
-var acpToolCallNameSchema = z33.union([z33.string(), z33.null()]).transform((value) => value ?? void 0).optional();
-var acpToolCallFieldsSchema = z33.object({
-  toolCallId: z33.string(),
-  title: z33.string().optional(),
+var acpToolCallNameSchema = z34.union([z34.string(), z34.null()]).transform((value) => value ?? void 0).optional();
+var acpToolCallFieldsSchema = z34.object({
+  toolCallId: z34.string(),
+  title: z34.string().optional(),
   name: acpToolCallNameSchema,
   kind: acpToolKindSchema.optional(),
-  rawKind: z33.string().optional(),
+  rawKind: z34.string().optional(),
   status: acpToolCallStatusSchema.optional(),
   content: acpToolCallContentListSchema.optional(),
-  locations: z33.array(acpToolCallLocationSchema).optional(),
-  rawInput: z33.unknown().optional(),
-  rawOutput: z33.unknown().optional()
+  locations: z34.array(acpToolCallLocationSchema).optional(),
+  rawInput: z34.unknown().optional(),
+  rawOutput: z34.unknown().optional()
 });
 function openAcpToolCallEnums(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -3921,43 +3932,43 @@ function openAcpToolCallEnums(value) {
   }
   return next;
 }
-var acpAgentMessageChunkUpdateSchema = z33.object({
-  sessionUpdate: z33.literal("agent_message_chunk"),
+var acpAgentMessageChunkUpdateSchema = z34.object({
+  sessionUpdate: z34.literal("agent_message_chunk"),
   content: acpContentBlockSchema
 }).passthrough();
-var acpAgentThoughtChunkUpdateSchema = z33.object({
-  sessionUpdate: z33.literal("agent_thought_chunk"),
+var acpAgentThoughtChunkUpdateSchema = z34.object({
+  sessionUpdate: z34.literal("agent_thought_chunk"),
   content: acpContentBlockSchema
 }).passthrough();
-var acpToolCallUpdateEventSchema = z33.preprocess(
+var acpToolCallUpdateEventSchema = z34.preprocess(
   openAcpToolCallEnums,
   acpToolCallFieldsSchema.extend({
-    sessionUpdate: z33.enum(["tool_call", "tool_call_update"])
+    sessionUpdate: z34.enum(["tool_call", "tool_call_update"])
   }).passthrough()
 );
-var acpPlanEntryStatusSchema = z33.enum([
+var acpPlanEntryStatusSchema = z34.enum([
   "pending",
   "in_progress",
   "completed"
 ]);
-var acpPlanUpdateSchema = z33.object({
-  sessionUpdate: z33.literal("plan"),
-  entries: z33.array(
-    z33.object({
-      content: z33.string(),
+var acpPlanUpdateSchema = z34.object({
+  sessionUpdate: z34.literal("plan"),
+  entries: z34.array(
+    z34.object({
+      content: z34.string(),
       status: acpPlanEntryStatusSchema.optional()
     }).passthrough()
   )
 }).passthrough();
-var acpUsageUpdateSchema = z33.object({
-  sessionUpdate: z33.literal("usage_update"),
-  used: z33.number().int().nonnegative(),
-  size: z33.number().int().nonnegative()
+var acpUsageUpdateSchema = z34.object({
+  sessionUpdate: z34.literal("usage_update"),
+  used: z34.number().int().nonnegative(),
+  size: z34.number().int().nonnegative()
 }).passthrough();
-var acpOtherSessionUpdateSchema = z33.object({
-  sessionUpdate: z33.string()
+var acpOtherSessionUpdateSchema = z34.object({
+  sessionUpdate: z34.string()
 }).passthrough();
-var acpSessionUpdateSchema = z33.union([
+var acpSessionUpdateSchema = z34.union([
   acpAgentMessageChunkUpdateSchema,
   acpAgentThoughtChunkUpdateSchema,
   acpToolCallUpdateEventSchema,
@@ -3965,55 +3976,55 @@ var acpSessionUpdateSchema = z33.union([
   acpUsageUpdateSchema,
   acpOtherSessionUpdateSchema
 ]);
-var acpSessionNotificationParamsSchema = z33.object({
-  sessionId: z33.string(),
+var acpSessionNotificationParamsSchema = z34.object({
+  sessionId: z34.string(),
   update: acpSessionUpdateSchema
 }).passthrough();
 var ACP_PROTOCOL_VERSION = 1;
-var acpInitializeResultSchema = z33.object({
-  protocolVersion: z33.number(),
-  agentCapabilities: z33.object({
-    loadSession: z33.boolean().optional(),
-    sessionCapabilities: z33.object({
-      fork: z33.object({}).passthrough().nullable().optional()
+var acpInitializeResultSchema = z34.object({
+  protocolVersion: z34.number(),
+  agentCapabilities: z34.object({
+    loadSession: z34.boolean().optional(),
+    sessionCapabilities: z34.object({
+      fork: z34.object({}).passthrough().nullable().optional()
     }).passthrough().optional(),
-    promptCapabilities: z33.object({
-      image: z33.boolean().optional(),
-      audio: z33.boolean().optional(),
-      embeddedContext: z33.boolean().optional()
+    promptCapabilities: z34.object({
+      image: z34.boolean().optional(),
+      audio: z34.boolean().optional(),
+      embeddedContext: z34.boolean().optional()
     }).passthrough().optional()
   }).passthrough().optional(),
-  authMethods: z33.array(z33.object({ id: z33.string() }).passthrough()).optional()
+  authMethods: z34.array(z34.object({ id: z34.string() }).passthrough()).optional()
 }).passthrough();
-var acpOptionalString = z33.union([z33.string(), z33.null()]).transform((value) => value ?? void 0).optional();
-var acpConfigOptionSelectOptionSchema = z33.object({
-  value: z33.string(),
+var acpOptionalString = z34.union([z34.string(), z34.null()]).transform((value) => value ?? void 0).optional();
+var acpConfigOptionSelectOptionSchema = z34.object({
+  value: z34.string(),
   name: acpOptionalString
 }).passthrough();
-var acpConfigOptionSchema = z33.object({
-  id: z33.string(),
+var acpConfigOptionSchema = z34.object({
+  id: z34.string(),
   name: acpOptionalString,
   category: acpOptionalString,
-  type: z33.string(),
+  type: z34.string(),
   currentValue: acpOptionalString,
-  options: z33.array(acpConfigOptionSelectOptionSchema).optional()
+  options: z34.array(acpConfigOptionSelectOptionSchema).optional()
 }).passthrough();
-var acpSessionModelSchema = z33.object({
-  modelId: z33.string(),
+var acpSessionModelSchema = z34.object({
+  modelId: z34.string(),
   name: acpOptionalString,
   description: acpOptionalString
 }).passthrough();
-var acpSessionModelsSchema = z33.object({
+var acpSessionModelsSchema = z34.object({
   currentModelId: acpOptionalString,
-  availableModels: z33.array(acpSessionModelSchema).optional()
+  availableModels: z34.array(acpSessionModelSchema).optional()
 }).passthrough();
-var acpLooseConfigOptionSchema = z33.object({
-  id: z33.string().optional(),
-  name: z33.unknown().optional(),
+var acpLooseConfigOptionSchema = z34.object({
+  id: z34.string().optional(),
+  name: z34.unknown().optional(),
   category: acpOptionalString,
-  type: z33.unknown().optional(),
-  currentValue: z33.unknown().optional(),
-  options: z33.unknown().optional()
+  type: z34.unknown().optional(),
+  currentValue: z34.unknown().optional(),
+  options: z34.unknown().optional()
 }).passthrough();
 function parseAcpConfigOptions(options, ctx) {
   if (options == null) {
@@ -4057,119 +4068,119 @@ function parseAcpConfigOptions(options, ctx) {
   }
   return parsedOptions;
 }
-var acpSessionNewResultSchema = z33.object({
-  sessionId: z33.string(),
+var acpSessionNewResultSchema = z34.object({
+  sessionId: z34.string(),
   models: acpSessionModelsSchema.optional(),
-  configOptions: z33.array(z33.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
+  configOptions: z34.array(z34.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
 }).passthrough();
-var acpConfigStateResultSchema = z33.object({
+var acpConfigStateResultSchema = z34.object({
   models: acpSessionModelsSchema.optional(),
-  configOptions: z33.array(z33.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
+  configOptions: z34.array(z34.unknown()).nullable().optional().transform((options, ctx) => parseAcpConfigOptions(options, ctx))
 }).passthrough();
 var acpSessionForkResultSchema = acpConfigStateResultSchema.extend({
-  sessionId: z33.string()
+  sessionId: z34.string()
 });
-var acpStopReasonSchema = z33.enum([
+var acpStopReasonSchema = z34.enum([
   "end_turn",
   "max_tokens",
   "max_turn_requests",
   "refusal",
   "cancelled"
 ]);
-var acpPromptResultSchema = z33.object({
+var acpPromptResultSchema = z34.object({
   stopReason: acpStopReasonSchema
 }).passthrough();
-var acpPermissionOptionKindSchema = z33.enum([
+var acpPermissionOptionKindSchema = z34.enum([
   "allow_once",
   "allow_always",
   "reject_once",
   "reject_always"
 ]);
-var acpPermissionOptionSchema = z33.object({
-  optionId: z33.string(),
-  name: z33.string(),
+var acpPermissionOptionSchema = z34.object({
+  optionId: z34.string(),
+  name: z34.string(),
   kind: acpPermissionOptionKindSchema
 }).passthrough();
-var acpRequestPermissionParamsSchema = z33.object({
-  sessionId: z33.string(),
-  toolCall: z33.preprocess(
+var acpRequestPermissionParamsSchema = z34.object({
+  sessionId: z34.string(),
+  toolCall: z34.preprocess(
     openAcpToolCallEnums,
     acpToolCallFieldsSchema.partial().passthrough()
   ).optional(),
-  options: z33.array(acpPermissionOptionSchema).min(1)
+  options: z34.array(acpPermissionOptionSchema).min(1)
 }).passthrough();
-var acpReadTextFileParamsSchema = z33.object({
-  sessionId: z33.string(),
-  path: z33.string(),
-  line: z33.number().nullable().optional(),
-  limit: z33.number().nullable().optional()
+var acpReadTextFileParamsSchema = z34.object({
+  sessionId: z34.string(),
+  path: z34.string(),
+  line: z34.number().nullable().optional(),
+  limit: z34.number().nullable().optional()
 }).passthrough();
-var acpWriteTextFileParamsSchema = z33.object({
-  sessionId: z33.string(),
-  path: z33.string(),
-  content: z33.string()
+var acpWriteTextFileParamsSchema = z34.object({
+  sessionId: z34.string(),
+  path: z34.string(),
+  content: z34.string()
 }).passthrough();
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
 var ACP_DEFAULT_MODEL_ID = "acp-default";
 var acpModelListParamsSchema = modelListParamsSchema.extend({
-  providerOptions: z34.record(z34.string(), z34.unknown()).optional()
+  providerOptions: z35.record(z35.string(), z35.unknown()).optional()
 });
-var acpBridgeCommandSchema = z34.discriminatedUnion("method", [
-  z34.object({
-    method: z34.literal("initialize"),
+var acpBridgeCommandSchema = z35.discriminatedUnion("method", [
+  z35.object({
+    method: z35.literal("initialize"),
     params: initializeParamsSchema
   }),
-  z34.object({
-    method: z34.literal("model/list"),
+  z35.object({
+    method: z35.literal("model/list"),
     params: acpModelListParamsSchema
   }),
-  z34.object({
-    method: z34.literal("provider/health"),
+  z35.object({
+    method: z35.literal("provider/health"),
     params: providerMaintenanceParamsSchema
   }),
-  z34.object({
-    method: z34.literal("provider/usage"),
+  z35.object({
+    method: z35.literal("provider/usage"),
     params: providerMaintenanceParamsSchema
   }),
-  z34.object({
-    method: z34.literal("provider/installation/status"),
+  z35.object({
+    method: z35.literal("provider/installation/status"),
     params: providerInstallationStatusParamsSchema
   }),
-  z34.object({
-    method: z34.literal("provider/installation/run"),
+  z35.object({
+    method: z35.literal("provider/installation/run"),
     params: providerInstallationRunParamsSchema
   }),
-  z34.object({
-    method: z34.literal("thread/start"),
+  z35.object({
+    method: z35.literal("thread/start"),
     params: threadStartParamsSchema
   }),
-  z34.object({
-    method: z34.literal("thread/resume"),
+  z35.object({
+    method: z35.literal("thread/resume"),
     params: threadResumeParamsSchema
   }),
-  z34.object({
-    method: z34.literal("thread/fork"),
+  z35.object({
+    method: z35.literal("thread/fork"),
     params: threadForkParamsSchema
   }),
-  z34.object({
-    method: z34.literal("turn/start"),
+  z35.object({
+    method: z35.literal("turn/start"),
     params: turnStartParamsSchema
   }),
-  z34.object({
-    method: z34.literal("turn/steer"),
+  z35.object({
+    method: z35.literal("turn/steer"),
     params: turnSteerParamsSchema
   }),
-  z34.object({
-    method: z34.literal("thread/stop"),
+  z35.object({
+    method: z35.literal("thread/stop"),
     params: threadStopParamsSchema
   }),
-  z34.object({
-    method: z34.literal("thread/discard"),
+  z35.object({
+    method: z35.literal("thread/discard"),
     params: threadDiscardParamsSchema
   }),
-  z34.object({
-    method: z34.literal("skills/configure"),
+  z35.object({
+    method: z35.literal("skills/configure"),
     params: skillsConfigureParamsSchema
   })
 ]);
@@ -4184,53 +4195,53 @@ var ACP_UPDATE_METHOD = "acp/update";
 var ACP_FS_WRITE_METHOD = "acp/fs/write";
 var ACP_WARNING_METHOD = "acp/warning";
 var ACP_BRIDGE_NO_ACTIVE_TURN_ERROR_CODE = -32001;
-var acpTurnStartedNotificationParamsSchema = z34.object({
-  threadId: z34.string().min(1)
+var acpTurnStartedNotificationParamsSchema = z35.object({
+  threadId: z35.string().min(1)
 }).passthrough();
-var acpTurnCompletedNotificationParamsSchema = z34.object({
-  threadId: z34.string().min(1),
+var acpTurnCompletedNotificationParamsSchema = z35.object({
+  threadId: z35.string().min(1),
   stopReason: acpStopReasonSchema
 }).passthrough();
-var acpCompactionCompletedNotificationParamsSchema = z34.discriminatedUnion("status", [
-  z34.object({
-    threadId: z34.string().min(1),
-    status: z34.literal("completed")
+var acpCompactionCompletedNotificationParamsSchema = z35.discriminatedUnion("status", [
+  z35.object({
+    threadId: z35.string().min(1),
+    status: z35.literal("completed")
   }).passthrough(),
-  z34.object({
-    threadId: z34.string().min(1),
-    status: z34.literal("interrupted")
+  z35.object({
+    threadId: z35.string().min(1),
+    status: z35.literal("interrupted")
   }).passthrough(),
-  z34.object({
-    threadId: z34.string().min(1),
-    status: z34.literal("skipped"),
-    detail: z34.string().min(1)
+  z35.object({
+    threadId: z35.string().min(1),
+    status: z35.literal("skipped"),
+    detail: z35.string().min(1)
   }).passthrough(),
-  z34.object({
-    threadId: z34.string().min(1),
-    status: z34.literal("failed"),
-    error: z34.string().min(1)
+  z35.object({
+    threadId: z35.string().min(1),
+    status: z35.literal("failed"),
+    error: z35.string().min(1)
   }).passthrough()
 ]);
-var acpUpdateNotificationParamsSchema = z34.object({
-  threadId: z34.string().min(1),
+var acpUpdateNotificationParamsSchema = z35.object({
+  threadId: z35.string().min(1),
   update: acpSessionUpdateSchema
 }).passthrough();
-var acpFsWriteNotificationParamsSchema = z34.object({
-  threadId: z34.string().min(1),
-  path: z34.string().min(1),
-  kind: z34.enum(["add", "update"]),
-  oldText: z34.string().optional(),
-  content: z34.string()
+var acpFsWriteNotificationParamsSchema = z35.object({
+  threadId: z35.string().min(1),
+  path: z35.string().min(1),
+  kind: z35.enum(["add", "update"]),
+  oldText: z35.string().optional(),
+  content: z35.string()
 }).passthrough();
-var acpWarningNotificationParamsSchema = z34.object({
-  threadId: z34.string().min(1),
-  summary: z34.string().min(1),
-  details: z34.string().optional()
+var acpWarningNotificationParamsSchema = z35.object({
+  threadId: z35.string().min(1),
+  summary: z35.string().min(1),
+  details: z35.string().optional()
 }).passthrough();
 
 // ../provider-bridge-acp/src/dialect.ts
 import { basename } from "node:path";
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // ../provider-bridge-acp/src/bridge/provider-maintenance.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -4240,7 +4251,7 @@ import os from "node:os";
 import path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { promisify as promisify2 } from "node:util";
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var execFileAsync2 = promisify2(execFile2);
 var USAGE_FETCH_TIMEOUT_MS = 15e3;
 var CURSOR_DASHBOARD_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService";
@@ -4278,8 +4289,8 @@ async function readKeychainAccessToken() {
     return null;
   }
 }
-var cursorFileCredentialsSchema = z35.object({
-  accessToken: z35.string().min(1).nullish()
+var cursorFileCredentialsSchema = z36.object({
+  accessToken: z36.string().min(1).nullish()
 });
 async function readAccessToken() {
   const keychain = await readKeychainAccessToken();
@@ -4326,7 +4337,7 @@ function readAccountEmail() {
     database = new DatabaseSync(databasePath);
     database.exec("PRAGMA query_only = true");
     const row = database.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/cachedEmail");
-    const parsed = z35.object({ value: z35.string().email() }).safeParse(row);
+    const parsed = z36.object({ value: z36.string().email() }).safeParse(row);
     return parsed.success ? parsed.data.value : null;
   } catch {
     return null;
@@ -4430,14 +4441,14 @@ function buildAcpProviderInstallationRun(status, args) {
     verification: { kind: "installed" }
   };
 }
-var cursorNonNegativeIntegerSchema = z35.union([
-  z35.number().int().nonnegative(),
-  z35.string().regex(/^\d+$/u).transform(Number)
+var cursorNonNegativeIntegerSchema = z36.union([
+  z36.number().int().nonnegative(),
+  z36.string().regex(/^\d+$/u).transform(Number)
 ]).refine(Number.isSafeInteger);
-var cursorUsageResponseSchema = z35.object({
+var cursorUsageResponseSchema = z36.object({
   billingCycleEnd: cursorNonNegativeIntegerSchema.nullish(),
-  planUsage: z35.object({ totalPercentUsed: z35.number().nonnegative().default(0) }).nullish(),
-  spendLimitUsage: z35.object({
+  planUsage: z36.object({ totalPercentUsed: z36.number().nonnegative().default(0) }).nullish(),
+  spendLimitUsage: z36.object({
     overallLimit: cursorNonNegativeIntegerSchema.nullish(),
     overallUsed: cursorNonNegativeIntegerSchema.nullish(),
     individualLimit: cursorNonNegativeIntegerSchema.nullish(),
@@ -4446,8 +4457,8 @@ var cursorUsageResponseSchema = z35.object({
     pooledUsed: cursorNonNegativeIntegerSchema.nullish()
   }).nullish()
 }).passthrough();
-var cursorPlanResponseSchema = z35.object({
-  planInfo: z35.object({ planName: z35.string().min(1) }).nullish()
+var cursorPlanResponseSchema = z36.object({
+  planInfo: z36.object({ planName: z36.string().min(1) }).nullish()
 }).passthrough();
 function normalizeUsage(rawUsage, rawPlan, accountEmail = null) {
   const usage = cursorUsageResponseSchema.safeParse(rawUsage);
@@ -4659,17 +4670,17 @@ function toolKindPresentation(args) {
 }
 
 // ../provider-bridge-acp/src/tool-classification.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 
 // ../provider-bridge-acp/src/tool-call-operation.ts
 import path3 from "node:path";
-import { z as z36 } from "zod";
-var acpRawInputCommandSchema = z36.object({ command: z36.string() }).passthrough();
-var acpRawInputPathSchema = z36.object({
-  path: z36.string().optional(),
-  filePath: z36.string().optional(),
-  file_path: z36.string().optional(),
-  target_file: z36.string().optional()
+import { z as z37 } from "zod";
+var acpRawInputCommandSchema = z37.object({ command: z37.string() }).passthrough();
+var acpRawInputPathSchema = z37.object({
+  path: z37.string().optional(),
+  filePath: z37.string().optional(),
+  file_path: z37.string().optional(),
+  target_file: z37.string().optional()
 }).passthrough();
 function resolveAcpToolCallPath(value, options) {
   const cwd = options?.cwd;
@@ -4846,14 +4857,14 @@ function extractAcpToolCallOutputText(event) {
   ).trim();
   return rawOutputText.length > 0 ? rawOutputText : void 0;
 }
-var commandRawOutputSchema = z37.object({
-  exitCode: z37.number().int().nullable().optional(),
-  exit_code: z37.number().int().nullable().optional(),
-  stdout: z37.string().optional(),
-  stderr: z37.string().optional(),
-  output_for_prompt: z37.string().optional(),
-  signal: z37.string().nullable().optional(),
-  timed_out: z37.boolean().optional()
+var commandRawOutputSchema = z38.object({
+  exitCode: z38.number().int().nullable().optional(),
+  exit_code: z38.number().int().nullable().optional(),
+  stdout: z38.string().optional(),
+  stderr: z38.string().optional(),
+  output_for_prompt: z38.string().optional(),
+  signal: z38.string().nullable().optional(),
+  timed_out: z38.boolean().optional()
 }).passthrough();
 function emptyToUndefined(value) {
   return value === void 0 || value.length === 0 ? void 0 : value;
@@ -4922,10 +4933,10 @@ function extractAcpCommandResult(event) {
     ...output === void 0 ? {} : { output: scrubInlineImageDataUrls(output) }
   };
 }
-var optionalNonBlank = z37.string().optional().transform(
+var optionalNonBlank = z38.string().optional().transform(
   (value) => value !== void 0 && value.trim().length > 0 ? value : void 0
 );
-var searchRawInputSchema = z37.object({
+var searchRawInputSchema = z38.object({
   pattern: optionalNonBlank,
   query: optionalNonBlank,
   regex: optionalNonBlank,
@@ -4934,8 +4945,8 @@ var searchRawInputSchema = z37.object({
   path: optionalNonBlank,
   directory: optionalNonBlank
 }).passthrough();
-var fetchRawInputSchema = z37.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
-var thinkRawInputSchema = z37.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
+var fetchRawInputSchema = z38.object({ url: optionalNonBlank, uri: optionalNonBlank }).passthrough();
+var thinkRawInputSchema = z38.object({ thought: optionalNonBlank, thinking: optionalNonBlank }).passthrough();
 var SINGLE_TICKED_TOKEN_PATTERN = /^[^`]*`([^`\n]+)`[^`]*$/;
 var URL_PATTERN = /https?:\/\/[^\s`'"<>]+/g;
 function tickedTokenFromTitle(title) {
@@ -5128,10 +5139,10 @@ function classifyAcpToolCall2(event, injected, options) {
 
 // ../provider-bridge-acp/src/dialect.ts
 var GENERIC_ACP_DIALECT = { id: "acp" };
-var grokToolMetaSchema = z38.object({
-  "x.ai/tool": z38.object({
-    name: z38.string().optional(),
-    kind: z38.string().optional()
+var grokToolMetaSchema = z39.object({
+  "x.ai/tool": z39.object({
+    name: z39.string().optional(),
+    kind: z39.string().optional()
   }).passthrough()
 }).passthrough();
 function grokToolIdentity(event) {
@@ -5147,10 +5158,10 @@ function grokToolIdentity(event) {
   };
 }
 var GROK_SPAWN_SUBAGENT_TOOL = "spawn_subagent";
-var grokSpawnSubagentInputSchema = z38.object({
-  description: z38.string().optional(),
-  prompt: z38.string().optional(),
-  subagent_type: z38.string().optional()
+var grokSpawnSubagentInputSchema = z39.object({
+  description: z39.string().optional(),
+  prompt: z39.string().optional(),
+  subagent_type: z39.string().optional()
 }).passthrough();
 function grokClassifyToolCall(event) {
   if (grokToolIdentity(event)?.name !== GROK_SPAWN_SUBAGENT_TOOL) {
@@ -5179,14 +5190,14 @@ var GROK_ACP_DIALECT = {
   classifyToolCall: grokClassifyToolCall
 };
 var CURSOR_TASK_TOOL = "task";
-var cursorTaskRawInputSchema = z38.object({ _toolName: z38.string().optional() }).passthrough();
+var cursorTaskRawInputSchema = z39.object({ _toolName: z39.string().optional() }).passthrough();
 var CURSOR_TASK_METHOD = "cursor/task";
-var cursorTaskParamsSchema = z38.object({
-  toolCallId: z38.string(),
-  description: z38.string().optional(),
-  prompt: z38.string().optional(),
-  agentId: z38.string().optional(),
-  model: z38.string().optional()
+var cursorTaskParamsSchema = z39.object({
+  toolCallId: z39.string(),
+  description: z39.string().optional(),
+  prompt: z39.string().optional(),
+  agentId: z39.string().optional(),
+  model: z39.string().optional()
 }).passthrough();
 function cursorClassifyToolCall(event) {
   const parsed = cursorTaskRawInputSchema.safeParse(event.rawInput);
@@ -5234,23 +5245,23 @@ var CURSOR_ACP_DIALECT = {
   handleClientRequest: cursorHandleClientRequest,
   maintenance: CURSOR_ACP_MAINTENANCE
 };
-var ompBashRawInputSchema = z38.object({
-  command: z38.string(),
-  async: z38.boolean().optional()
+var ompBashRawInputSchema = z39.object({
+  command: z39.string(),
+  async: z39.boolean().optional()
 }).passthrough();
 var ompBashRawOutputSchema = commandRawOutputSchema.extend({
-  content: z38.array(
-    z38.object({
-      type: z38.literal("text"),
-      text: z38.string()
+  content: z39.array(
+    z39.object({
+      type: z39.literal("text"),
+      text: z39.string()
     }).passthrough()
   ),
-  details: z38.object({
-    exitCode: z38.number().int().optional(),
-    wallTimeMs: z38.number().nonnegative().optional(),
-    timedOut: z38.boolean().optional(),
-    signal: z38.unknown().optional(),
-    async: z38.unknown().optional()
+  details: z39.object({
+    exitCode: z39.number().int().optional(),
+    wallTimeMs: z39.number().nonnegative().optional(),
+    timedOut: z39.boolean().optional(),
+    signal: z39.unknown().optional(),
+    async: z39.unknown().optional()
   }).passthrough()
 });
 function stripOmpTrailingNotice(text, notice) {
@@ -5313,11 +5324,11 @@ var OMP_ACP_DIALECT = {
   id: "omp",
   commandResult: ompCommandResult
 };
-var openCodeCommandRawOutputSchema = z38.object({
-  output: z38.unknown().optional(),
-  metadata: z38.object({
-    exit: z38.number().int().nullable().optional(),
-    output: z38.string().optional()
+var openCodeCommandRawOutputSchema = z39.object({
+  output: z39.unknown().optional(),
+  metadata: z39.object({
+    exit: z39.number().int().nullable().optional(),
+    output: z39.string().optional()
   }).passthrough().optional()
 }).passthrough();
 function normalizeOpenCodeCommandEvent(event) {
@@ -7235,7 +7246,7 @@ import { basename as basename2, dirname, join as join2, resolve as resolve2 } fr
 // ../provider-bridge-acp/src/bridge/tool-proxy-mcp.ts
 import { createConnection } from "node:net";
 import { createInterface as createInterface2 } from "node:readline";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var ACP_BRIDGE_MCP_SERVER_NAME = "bb-bridge";
 var ENV_HOST = "BB_ACP_DYNAMIC_TOOL_HOST";
 var ENV_PORT = "BB_ACP_DYNAMIC_TOOL_PORT";
@@ -7243,41 +7254,46 @@ var ENV_TOKEN = "BB_ACP_DYNAMIC_TOOL_TOKEN";
 var ENV_THREAD_ID = "BB_ACP_DYNAMIC_TOOL_THREAD_ID";
 var ENV_TOOLS = "BB_ACP_DYNAMIC_TOOLS";
 var ENV_PROGRESS_INTERVAL_MS = "BB_ACP_DYNAMIC_TOOL_PROGRESS_INTERVAL_MS";
-var dynamicToolBridgeRequestSchema = z39.discriminatedUnion("kind", [
-  z39.object({
-    kind: z39.literal("initialized"),
-    threadId: z39.string().min(1),
-    token: z39.string().min(1),
-    toolCount: z39.number().int().nonnegative()
+var dynamicToolBridgeRequestSchema = z40.discriminatedUnion("kind", [
+  z40.object({
+    kind: z40.literal("initialized"),
+    threadId: z40.string().min(1),
+    token: z40.string().min(1),
+    toolCount: z40.number().int().nonnegative()
   }),
-  z39.object({
-    kind: z39.literal("toolCall"),
-    arguments: z39.record(z39.string(), z39.unknown()).default({}),
-    callId: z39.string().min(1),
-    threadId: z39.string().min(1),
-    token: z39.string().min(1),
-    tool: z39.string().min(1)
+  z40.object({
+    kind: z40.literal("toolCall"),
+    arguments: z40.record(z40.string(), z40.unknown()).default({}),
+    callId: z40.string().min(1),
+    threadId: z40.string().min(1),
+    token: z40.string().min(1),
+    tool: z40.string().min(1)
   })
 ]);
-var bridgeToolCallResponseSchema = z39.union([
-  z39.object({
-    ok: z39.literal(true),
-    content: z39.string(),
-    contentBlocks: z39.array(
-      z39.discriminatedUnion("type", [
-        z39.object({ type: z39.literal("text"), text: z39.string() }),
-        z39.object({
-          type: z39.literal("image"),
-          data: z39.string(),
-          mimeType: z39.string()
+var bridgeToolCallResponseSchema = z40.union([
+  z40.object({
+    ok: z40.literal(true),
+    content: z40.string(),
+    contentBlocks: z40.array(
+      z40.discriminatedUnion("type", [
+        z40.object({ type: z40.literal("text"), text: z40.string() }),
+        z40.object({
+          type: z40.literal("image"),
+          data: z40.string(),
+          mimeType: z40.string()
         })
       ])
     ).optional(),
-    images: z39.array(z39.object({ data: z39.string(), mimeType: z39.string() })).default([]),
-    isError: z39.boolean().optional()
+    images: z40.array(z40.object({ data: z40.string(), mimeType: z40.string() })).default([]),
+    isError: z40.boolean().optional()
   }),
-  z39.object({ ok: z39.literal(false), error: z39.string() })
+  z40.object({ ok: z40.literal(false), error: z40.string() })
 ]);
+var jsonRpcMessageSchema = z40.object({
+  id: z40.union([z40.string(), z40.number().int()]).optional(),
+  method: z40.string().optional(),
+  params: z40.unknown().optional()
+});
 var nextMcpToolCallId = 0;
 var TOOL_CALL_PROGRESS_INTERVAL_MS = 15e3;
 function buildAcpMcpServerConfig(args) {
@@ -7334,9 +7350,16 @@ function mcpToolCallId(toolName) {
   nextMcpToolCallId += 1;
   return `acp-mcp-${toolName}-${Date.now()}-${nextMcpToolCallId}`;
 }
-function callBridge(env, request) {
+function callBridge(env, request, signal) {
   return new Promise((resolve4, reject) => {
     const socket = createConnection({ host: env.host, port: env.port });
+    const abort = () => {
+      socket.destroy();
+      reject(new Error("ACP dynamic tool call cancelled"));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    socket.once("close", () => signal?.removeEventListener("abort", abort));
+    if (signal?.aborted) abort();
     let buffer = "";
     socket.setEncoding("utf8");
     socket.on("connect", () => {
@@ -7389,7 +7412,14 @@ function startProgressHeartbeat(args) {
   }, args.intervalMs ?? TOOL_CALL_PROGRESS_INTERVAL_MS);
   return () => clearInterval(timer);
 }
-async function handleRequest(env, message) {
+async function handleRequest(env, message, pending) {
+  if (message.method === PROVIDER_TOOL_CALL_CANCELLED_METHOD) {
+    const cancellation = providerToolCallCancellationSchema.safeParse(
+      message.params
+    );
+    if (cancellation.success) pending.get(cancellation.data.requestId)?.abort();
+    return;
+  }
   if (message.id === void 0 || message.method === void 0) {
     return;
   }
@@ -7420,6 +7450,7 @@ async function handleRequest(env, message) {
       });
       return;
     case "tools/call": {
+      if (pending.has(message.id)) return;
       const params = objectParams(message.params);
       const name = typeof params.name === "string" ? params.name : "";
       const tool = env.tools.find((candidate) => candidate.name === name);
@@ -7429,20 +7460,29 @@ async function handleRequest(env, message) {
       }
       const rawArguments = params.arguments;
       const toolArguments = rawArguments && typeof rawArguments === "object" && !Array.isArray(rawArguments) ? rawArguments : {};
+      const controller = new AbortController();
+      pending.set(message.id, controller);
       const progressToken = readProgressToken(message.params);
       const stopHeartbeat = progressToken === null ? () => {
       } : startProgressHeartbeat({
         intervalMs: env.progressIntervalMs,
         progressToken
       });
+      controller.signal.addEventListener("abort", stopHeartbeat, {
+        once: true
+      });
       try {
-        const result = await callBridge(env, {
-          kind: "toolCall",
-          arguments: toolArguments,
-          callId: mcpToolCallId(tool.name),
-          tool: tool.name
-        });
-        stopHeartbeat();
+        const result = await callBridge(
+          env,
+          {
+            kind: "toolCall",
+            arguments: toolArguments,
+            callId: mcpToolCallId(tool.name),
+            tool: tool.name
+          },
+          controller.signal
+        );
+        if (controller.signal.aborted) return;
         if (!result.ok) {
           writeResult(message.id, {
             content: [{ type: "text", text: result.error }],
@@ -7455,7 +7495,7 @@ async function handleRequest(env, message) {
           ...result.isError ? { isError: true } : {}
         });
       } catch (error) {
-        stopHeartbeat();
+        if (controller.signal.aborted) return;
         writeResult(message.id, {
           content: [
             {
@@ -7465,6 +7505,10 @@ async function handleRequest(env, message) {
           ],
           isError: true
         });
+      } finally {
+        stopHeartbeat();
+        controller.signal.removeEventListener("abort", stopHeartbeat);
+        pending.delete(message.id);
       }
       return;
     }
@@ -7478,7 +7522,11 @@ async function handleRequest(env, message) {
 }
 function runAcpDynamicToolMcpServer() {
   const env = readEnvironment();
+  const pending = /* @__PURE__ */ new Map();
   const rl = createInterface2({ input: process.stdin, terminal: false });
+  rl.on("close", () => {
+    for (const controller of pending.values()) controller.abort();
+  });
   rl.on("line", (line) => {
     const trimmed = line.trim();
     if (!trimmed) {
@@ -7486,11 +7534,11 @@ function runAcpDynamicToolMcpServer() {
     }
     let message;
     try {
-      message = JSON.parse(trimmed);
+      message = jsonRpcMessageSchema.parse(JSON.parse(trimmed));
     } catch {
       return;
     }
-    void handleRequest(env, message);
+    void handleRequest(env, message, pending);
   });
 }
 
@@ -7667,11 +7715,19 @@ var { send, sendResult, sendError } = createBridgeIo();
 function sendNotification(method, params) {
   send({ jsonrpc: "2.0", method, params });
 }
-function sendRuntimeRequest(method, params) {
+function sendRuntimeRequest(method, params, signal) {
+  signal?.throwIfAborted();
   runtimeRequestIdCounter += 1;
   const requestId = runtimeRequestIdCounter;
+  let abort;
   const responsePromise = new Promise(
     (resolveResponse, rejectResponse) => {
+      abort = () => {
+        pendingRuntimeRequests.delete(requestId);
+        sendNotification(PROVIDER_TOOL_CALL_CANCELLED_METHOD, { requestId });
+        rejectResponse(new Error("ACP dynamic tool call cancelled"));
+      };
+      signal?.addEventListener("abort", abort, { once: true });
       pendingRuntimeRequests.set(requestId, (response) => {
         if ("error" in response) {
           rejectResponse(
@@ -7689,7 +7745,9 @@ function sendRuntimeRequest(method, params) {
     method,
     params
   });
-  return responsePromise;
+  return responsePromise.finally(
+    () => signal?.removeEventListener("abort", abort)
+  );
 }
 var configuredSkillRoots = null;
 function sendThreadDeltas(threadId, deltas) {
@@ -7711,6 +7769,7 @@ function emitForSession(session, method, params) {
   );
 }
 function emitSessionError(session, message) {
+  for (const controller of session.pendingToolCalls) controller.abort();
   if (session.activePromptKind !== null) {
     emitForSession(session, "error", {
       threadId: session.bbThreadId,
@@ -7733,40 +7792,53 @@ function resolveBridgeProcessEnvForMcpServer() {
   }
   return [{ name: "ELECTRON_RUN_AS_NODE", value: electronRunAsNode }];
 }
-async function forwardDynamicToolCall(args) {
+async function forwardDynamicToolCall(args, signal) {
   const session = sessionsByBbThreadId.get(args.threadId);
   if (!session || !session.providerThreadId || session.stopping) {
     return { ok: false, error: "No active ACP session for dynamic tool call." };
   }
+  const controller = new AbortController();
+  session.pendingToolCalls.add(controller);
   session.translator.noteInjectedToolCall(session.bbThreadId, args.tool);
   try {
-    const result = await sendRuntimeRequest("item/tool/call", {
-      providerThreadId: session.providerThreadId,
-      threadId: session.bbThreadId,
-      turnId: null,
-      callId: args.callId,
-      tool: args.tool,
-      arguments: args.arguments
-    });
+    const result = await sendRuntimeRequest(
+      "item/tool/call",
+      {
+        providerThreadId: session.providerThreadId,
+        threadId: session.bbThreadId,
+        turnId: null,
+        callId: args.callId,
+        tool: args.tool,
+        arguments: args.arguments
+      },
+      AbortSignal.any([signal, controller.signal])
+    );
     return { ok: true, ...decodeToolCallResponsePayload(result) };
   } catch (error) {
     return {
       ok: false,
       error: error instanceof Error ? error.message : String(error)
     };
+  } finally {
+    session.pendingToolCalls.delete(controller);
   }
 }
 function handleDynamicToolBridgeSocket(bridge, socket) {
+  const controller = new AbortController();
+  socket.once("close", () => controller.abort());
+  let handled = false;
   let buffer = "";
   socket.setEncoding("utf8");
   socket.on("error", () => {
   });
   socket.on("data", (chunk) => {
+    if (handled) return;
     buffer += chunk;
     const newlineIndex = buffer.indexOf("\n");
     if (newlineIndex === -1) {
       return;
     }
+    handled = true;
     const line = buffer.slice(0, newlineIndex);
     let parsed;
     try {
@@ -7793,10 +7865,13 @@ function handleDynamicToolBridgeSocket(bridge, socket) {
 `);
       return;
     }
-    void forwardDynamicToolCall(request.data).then((response) => {
-      socket.end(`${JSON.stringify(response)}
+    void forwardDynamicToolCall(request.data, controller.signal).then(
+      (response) => {
+        if (controller.signal.aborted) return;
+        socket.end(`${JSON.stringify(response)}
 `);
-    });
+      }
+    );
   });
 }
 async function ensureDynamicToolBridge() {
@@ -7991,7 +8066,7 @@ async function authenticateAcpAgent(args) {
     await args.connection.request({
       method: "authenticate",
       params: { methodId, _meta: { headless: true } },
-      resultSchema: z40.unknown()
+      resultSchema: z41.unknown()
     });
   } catch (error) {
     throw new AcpAuthRequiredError(
@@ -8321,7 +8396,7 @@ async function selectAcpNativeModel(args) {
             configId: modelOption.id,
             value: selection.modelId
           },
-          resultSchema: z40.union([acpConfigStateResultSchema, z40.null()])
+          resultSchema: z41.union([acpConfigStateResultSchema, z41.null()])
         });
         setModel = false;
       } catch {
@@ -8332,7 +8407,7 @@ async function selectAcpNativeModel(args) {
       configState = await args.connection.request({
         method: "session/set_model",
         params: { sessionId: args.sessionId, modelId: selection.modelId },
-        resultSchema: z40.union([acpConfigStateResultSchema, z40.null()])
+        resultSchema: z41.union([acpConfigStateResultSchema, z41.null()])
       });
     }
     configOptions = configState?.configOptions ?? configOptions;
@@ -8643,6 +8718,7 @@ function liveSessionForThread(bbThreadId) {
   return session;
 }
 function removeSession(session) {
+  for (const controller of session.pendingToolCalls) controller.abort();
   if (sessionsByBbThreadId.get(session.bbThreadId) === session) {
     sessionsByBbThreadId.delete(session.bbThreadId);
   }
@@ -8755,6 +8831,7 @@ async function startAgentSession(request) {
     stopping: false,
     turnSettled: void 0,
     pendingPermissions: /* @__PURE__ */ new Set(),
+    pendingToolCalls: /* @__PURE__ */ new Set(),
     cursorMcpApproval: void 0,
     deferStartEmit: emitStartNotification
   };
@@ -8827,7 +8904,7 @@ async function startAgentSession(request) {
             cwd: params.cwd,
             mcpServers
           },
-          resultSchema: z40.union([acpConfigStateResultSchema, z40.null()])
+          resultSchema: z41.union([acpConfigStateResultSchema, z41.null()])
         });
         loadedConfigOptions = configState?.configOptions;
         loadedModels = configState?.models;
@@ -9007,6 +9084,7 @@ function finishTurn(session, stopReason) {
   if (session.activePromptKind !== "turn") {
     return;
   }
+  for (const controller of session.pendingToolCalls) controller.abort();
   session.activePromptKind = null;
   dropQueuedTurnInputs(session, "ACP turn ended before the steer was sent");
   session.promptRequestPending = false;
@@ -9272,12 +9350,12 @@ function decodeLaunchSpec(providerOptions) {
   );
   return launchSpec.success ? launchSpec.data : null;
 }
-var acpProviderOptionsSchema = z40.object({
-  additionalWorkspaceWriteRoots: z40.array(z40.string()).optional(),
-  acpDialect: z40.string().min(1).optional(),
-  parameterizedModelPicker: z40.boolean().optional(),
-  primaryModels: z40.array(z40.string().min(1)).optional(),
-  reasoningProbePriorityModelIds: z40.array(z40.string().min(1)).optional()
+var acpProviderOptionsSchema = z41.object({
+  additionalWorkspaceWriteRoots: z41.array(z41.string()).optional(),
+  acpDialect: z41.string().min(1).optional(),
+  parameterizedModelPicker: z41.boolean().optional(),
+  primaryModels: z41.array(z41.string().min(1)).optional(),
+  reasoningProbePriorityModelIds: z41.array(z41.string().min(1)).optional()
 }).passthrough();
 function decodeAcpModelPickerOptions(providerOptions) {
   const parsed = acpProviderOptionsSchema.parse(providerOptions ?? {});
@@ -9594,7 +9672,7 @@ var experimental_providerBridge = experimental_defineProviderBridge({
 });
 
 // ../provider-bridge-acp/src/probe.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var PROBE_TIMEOUT_MS = 1e4;
 function describe(error) {
   if (error instanceof AcpAgentExitedError) {
@@ -9652,9 +9730,9 @@ async function probeAcpAgent(request) {
     connected.kill();
   }
 }
-var acpAgentProbeSchema = z41.union([
-  z41.object({ reachable: z41.literal(true), fork: z41.boolean() }),
-  z41.object({ reachable: z41.literal(false), reason: z41.string() })
+var acpAgentProbeSchema = z42.union([
+  z42.object({ reachable: z42.literal(true), fork: z42.boolean() }),
+  z42.object({ reachable: z42.literal(false), reason: z42.string() })
 ]);
 export {
   acpAgentProbeSchema as experimental_acpAgentProbeSchema,