@get-bb/plugin-sdk 0.4.88 → 0.4.94

package/dist/provider-bridge.js

@@ -679,6 +679,12 @@ function addTokenUsage(total, last) {
     totalTokens: total.totalTokens + last.totalTokens,
     inputTokens: total.inputTokens + last.inputTokens,
     cachedInputTokens: total.cachedInputTokens + last.cachedInputTokens,
+    ...total.cacheReadInputTokens === void 0 && last.cacheReadInputTokens === void 0 ? {} : {
+      cacheReadInputTokens: (total.cacheReadInputTokens ?? 0) + (last.cacheReadInputTokens ?? 0)
+    },
+    ...total.cacheWriteInputTokens === void 0 && last.cacheWriteInputTokens === void 0 ? {} : {
+      cacheWriteInputTokens: (total.cacheWriteInputTokens ?? 0) + (last.cacheWriteInputTokens ?? 0)
+    },
     outputTokens: total.outputTokens + last.outputTokens,
     reasoningOutputTokens: total.reasoningOutputTokens + last.reasoningOutputTokens
   };
@@ -2805,6 +2811,8 @@ var threadEventTokenUsageBreakdownSchema = z17.object({
   totalTokens: z17.number(),
   inputTokens: z17.number(),
   cachedInputTokens: z17.number(),
+  cacheReadInputTokens: z17.number().nonnegative().optional(),
+  cacheWriteInputTokens: z17.number().nonnegative().optional(),
   outputTokens: z17.number(),
   reasoningOutputTokens: z17.number()
 });
@@ -3975,6 +3983,12 @@ function clampPercent(value) {
   );
 }
 
+// ../provider-bridge-protocol/src/bridge-kit/provider-tool-call-contract.ts
+import { z as z24 } from "zod";
+var providerToolCallCancellationSchema = z24.object({
+  requestId: z24.union([z24.string(), z24.number().int()])
+});
+
 // ../provider-bridge-protocol/src/bridge-kit/provider-visibility.ts
 function createProviderVisibilityMetadata(args) {
   return {
@@ -3987,10 +4001,10 @@ function createProviderVisibilityMetadata(args) {
 }
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../provider-bridge-protocol/src/errors.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var BRIDGE_JSON_RPC_ERRORS = {
   INVALID_PARAMS: -32602,
   METHOD_NOT_FOUND: -32601,
@@ -3999,12 +4013,12 @@ var BRIDGE_JSON_RPC_ERRORS = {
   SESSION_NOT_RESTORABLE: -32002,
   FORK_CHECKPOINT_UNSUPPORTED: -32003
 };
-var providerRecoveryHintSchema = z24.object({
+var providerRecoveryHintSchema = z25.object({
   kind: providerRecoveryKindSchema,
-  message: z24.string().min(1),
-  retryable: z24.boolean()
+  message: z25.string().min(1),
+  retryable: z25.boolean()
 });
-var bridgeErrorDataSchema = z24.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
+var bridgeErrorDataSchema = z25.object({ recovery: providerRecoveryHintSchema.optional() }).passthrough();
 
 // ../provider-bridge-protocol/src/bridge-kit/runtime-json-rpc.ts
 var JSON_RPC_INVALID_PARAMS_CODE = -32602;
@@ -4022,7 +4036,7 @@ var ProviderResponseEncodeError = class extends Error {
     this.name = "ProviderResponseEncodeError";
   }
 };
-var ignoredJsonRpcResultSchema = z25.unknown();
+var ignoredJsonRpcResultSchema = z26.unknown();
 
 // ../provider-bridge-protocol/src/version.ts
 var PROVIDER_BRIDGE_PROTOCOL_VERSION = 2;
@@ -4030,66 +4044,66 @@ var THREAD_DELTA_GRAMMAR_V2 = PROVIDER_BRIDGE_PROTOCOL_VERSION;
 var THREAD_DELTA_GRAMMAR_V3 = 3;
 
 // ../provider-bridge-protocol/src/handshake.ts
-import { z as z26 } from "zod";
-var bridgeGrammarVersionsSchema = z26.tuple([z26.number().int().positive(), z26.number().int().positive()]).refine(([min, max]) => min <= max, {
+import { z as z27 } from "zod";
+var bridgeGrammarVersionsSchema = z27.tuple([z27.number().int().positive(), z27.number().int().positive()]).refine(([min, max]) => min <= max, {
   message: "grammarVersions must be an ascending [min, max] range"
 });
-var bridgeSteerModeSchema = z26.enum(["inject", "queue"]);
-var bridgeCapabilitiesSchema = z26.object({
-  sessionRestore: z26.boolean().default(false),
-  threadArchive: z26.boolean().default(false),
-  threadRename: z26.boolean().default(false),
-  threadGoalClear: z26.boolean().default(false),
+var bridgeSteerModeSchema = z27.enum(["inject", "queue"]);
+var bridgeCapabilitiesSchema = z27.object({
+  sessionRestore: z27.boolean().default(false),
+  threadArchive: z27.boolean().default(false),
+  threadRename: z27.boolean().default(false),
+  threadGoalClear: z27.boolean().default(false),
   fork: providerForkSchema.default("none"),
-  approvalEnforcedBy: z26.enum(["runtime", "provider"]).default("runtime"),
+  approvalEnforcedBy: z27.enum(["runtime", "provider"]).default("runtime"),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ]),
   steerMode: bridgeSteerModeSchema.default("queue"),
-  skills: z26.object({ configure: z26.boolean().default(false) }).default({ configure: false })
+  skills: z27.object({ configure: z27.boolean().default(false) }).default({ configure: false })
 }).passthrough();
-var initializeParamsSchema = z26.object({
-  protocolVersion: z26.number().int().positive(),
-  client: z26.object({ name: z26.string().min(1), version: z26.string().min(1) }),
+var initializeParamsSchema = z27.object({
+  protocolVersion: z27.number().int().positive(),
+  client: z27.object({ name: z27.string().min(1), version: z27.string().min(1) }),
   grammarVersions: bridgeGrammarVersionsSchema.default([
     PROVIDER_BRIDGE_PROTOCOL_VERSION,
     PROVIDER_BRIDGE_PROTOCOL_VERSION
   ])
 }).passthrough();
-var initializeResultSchema = z26.object({
-  protocolVersion: z26.number().int().positive(),
-  capabilities: z26.preprocess(
+var initializeResultSchema = z27.object({
+  protocolVersion: z27.number().int().positive(),
+  capabilities: z27.preprocess(
     (value) => value ?? {},
     bridgeCapabilitiesSchema
   )
 }).passthrough();
 
 // ../provider-bridge-protocol/src/execution-options.ts
-import { z as z27 } from "zod";
-var bridgeExecutionOptionsSchema = z27.object({
-  model: z27.string().min(1).optional(),
+import { z as z28 } from "zod";
+var bridgeExecutionOptionsSchema = z28.object({
+  model: z28.string().min(1).optional(),
   serviceTier: serviceTierSchema.optional(),
   reasoningLevel: reasoningLevelSchema.optional(),
   promptMode: promptModeSchema.optional(),
-  instructions: z27.string().optional(),
-  envVars: z27.record(z27.string(), z27.string()).optional(),
-  providerOptions: z27.record(z27.string(), z27.unknown()).optional()
+  instructions: z28.string().optional(),
+  envVars: z28.record(z28.string(), z28.string()).optional(),
+  providerOptions: z28.record(z28.string(), z28.unknown()).optional()
 }).and(runtimePermissionPolicySchema);
 
 // ../provider-bridge-protocol/src/provider-maintenance.ts
-import { z as z28 } from "zod";
-var providerMaintenanceParamsSchema = z28.object({
-  providerId: z28.string().min(1),
-  cwd: z28.string().min(1).optional(),
-  providerOptions: z28.record(z28.string(), z28.unknown()).optional()
+import { z as z29 } from "zod";
+var providerMaintenanceParamsSchema = z29.object({
+  providerId: z29.string().min(1),
+  cwd: z29.string().min(1).optional(),
+  providerOptions: z29.record(z29.string(), z29.unknown()).optional()
 }).passthrough();
-var providerInstallationRequirementSchema = z28.enum(["thread_rewind"]);
+var providerInstallationRequirementSchema = z29.enum(["thread_rewind"]);
 var providerInstallationStatusParamsSchema = providerMaintenanceParamsSchema.extend({
   requirement: providerInstallationRequirementSchema.optional()
 });
-var providerHealthSchema = z28.object({
-  status: z28.enum([
+var providerHealthSchema = z29.object({
+  status: z29.enum([
     "ready",
     "not_installed",
     "unauthenticated",
@@ -4097,114 +4111,114 @@ var providerHealthSchema = z28.object({
     "unsupported_version",
     "unknown"
   ]),
-  statusMessage: z28.string().min(1).nullable(),
-  accountEmail: z28.string().nullable(),
-  planLabel: z28.string().min(1).nullable(),
-  installedVersion: z28.string().min(1).nullable(),
-  minimumSupportedVersion: z28.string().min(1).nullable(),
-  canInstall: z28.boolean(),
-  canUpdate: z28.boolean(),
-  loginCommand: z28.string().min(1).nullable()
+  statusMessage: z29.string().min(1).nullable(),
+  accountEmail: z29.string().nullable(),
+  planLabel: z29.string().min(1).nullable(),
+  installedVersion: z29.string().min(1).nullable(),
+  minimumSupportedVersion: z29.string().min(1).nullable(),
+  canInstall: z29.boolean(),
+  canUpdate: z29.boolean(),
+  loginCommand: z29.string().min(1).nullable()
 }).passthrough();
-var providerUsageWindowSchema = z28.object({
-  label: z28.string().min(1),
-  usedPercent: z28.number().min(0).max(100),
-  resetsAt: z28.string().min(1).nullable(),
-  cost: z28.object({
-    usedUsdCents: z28.number().int().nonnegative(),
-    limitUsdCents: z28.number().int().positive()
+var providerUsageWindowSchema = z29.object({
+  label: z29.string().min(1),
+  usedPercent: z29.number().min(0).max(100),
+  resetsAt: z29.string().min(1).nullable(),
+  cost: z29.object({
+    usedUsdCents: z29.number().int().nonnegative(),
+    limitUsdCents: z29.number().int().positive()
   }).optional()
 }).passthrough();
-var providerUsageSchema = z28.discriminatedUnion("status", [
-  z28.object({
-    status: z28.literal("ok"),
-    accountEmail: z28.string().email().nullable(),
-    planLabel: z28.string().min(1).nullable(),
-    windows: z28.array(providerUsageWindowSchema)
+var providerUsageSchema = z29.discriminatedUnion("status", [
+  z29.object({
+    status: z29.literal("ok"),
+    accountEmail: z29.string().email().nullable(),
+    planLabel: z29.string().min(1).nullable(),
+    windows: z29.array(providerUsageWindowSchema)
   }).passthrough(),
-  z28.object({ status: z28.literal("not_installed") }).passthrough(),
-  z28.object({ status: z28.literal("unauthenticated") }).passthrough(),
-  z28.object({ status: z28.literal("expired") }).passthrough(),
-  z28.object({
-    status: z28.literal("error"),
-    message: z28.string().min(1),
-    planLabel: z28.string().min(1).nullable().default(null),
-    accountEmail: z28.string().nullable().default(null)
+  z29.object({ status: z29.literal("not_installed") }).passthrough(),
+  z29.object({ status: z29.literal("unauthenticated") }).passthrough(),
+  z29.object({ status: z29.literal("expired") }).passthrough(),
+  z29.object({
+    status: z29.literal("error"),
+    message: z29.string().min(1),
+    planLabel: z29.string().min(1).nullable().default(null),
+    accountEmail: z29.string().nullable().default(null)
   }).passthrough()
 ]);
-var providerHealthResultSchema = z28.discriminatedUnion("supported", [
-  z28.object({ supported: z28.literal(false) }).passthrough(),
-  z28.object({
-    supported: z28.literal(true),
+var providerHealthResultSchema = z29.discriminatedUnion("supported", [
+  z29.object({ supported: z29.literal(false) }).passthrough(),
+  z29.object({
+    supported: z29.literal(true),
     health: providerHealthSchema
   }).passthrough()
 ]);
-var providerUsageResultSchema = z28.discriminatedUnion("supported", [
-  z28.object({ supported: z28.literal(false) }).passthrough(),
-  z28.object({
-    supported: z28.literal(true),
+var providerUsageResultSchema = z29.discriminatedUnion("supported", [
+  z29.object({ supported: z29.literal(false) }).passthrough(),
+  z29.object({
+    supported: z29.literal(true),
     usage: providerUsageSchema
   }).passthrough()
 ]);
-var providerInstallationActionKindSchema = z28.enum([
+var providerInstallationActionKindSchema = z29.enum([
   "install",
   "update"
 ]);
-var providerInstallationActionSchema = z28.object({
+var providerInstallationActionSchema = z29.object({
   kind: providerInstallationActionKindSchema,
-  label: z28.enum(["Install", "Update"]),
-  command: z28.string().min(1)
+  label: z29.enum(["Install", "Update"]),
+  command: z29.string().min(1)
 }).passthrough();
-var providerInstallationSourceSchema = z28.enum([
+var providerInstallationSourceSchema = z29.enum([
   "notInstalled",
   "npmGlobal",
   "external"
 ]);
-var providerInstallationStatusSchema = z28.object({
-  executableName: z28.string().min(1),
-  executablePath: z28.string().min(1).nullable(),
-  installed: z28.boolean(),
+var providerInstallationStatusSchema = z29.object({
+  executableName: z29.string().min(1),
+  executablePath: z29.string().min(1).nullable(),
+  installed: z29.boolean(),
   installSource: providerInstallationSourceSchema,
-  currentVersion: z28.string().min(1).nullable(),
-  latestVersion: z28.string().min(1).nullable(),
-  minimumSupportedVersion: z28.string().min(1).nullable(),
-  npmPackageName: z28.string().min(1).nullable(),
-  npmGlobalPackageVersion: z28.string().min(1).nullable(),
+  currentVersion: z29.string().min(1).nullable(),
+  latestVersion: z29.string().min(1).nullable(),
+  minimumSupportedVersion: z29.string().min(1).nullable(),
+  npmPackageName: z29.string().min(1).nullable(),
+  npmGlobalPackageVersion: z29.string().min(1).nullable(),
   installAction: providerInstallationActionSchema.nullable(),
-  needsUpdate: z28.boolean(),
-  versionUnsupported: z28.boolean()
+  needsUpdate: z29.boolean(),
+  versionUnsupported: z29.boolean()
 }).passthrough();
 var providerInstallationRunParamsSchema = providerMaintenanceParamsSchema.extend({
   action: providerInstallationActionKindSchema
 });
-var providerInstallationCommandSchema = z28.object({
-  command: z28.string().min(1),
-  args: z28.array(z28.string()).max(64),
-  displayCommand: z28.string().min(1)
+var providerInstallationCommandSchema = z29.object({
+  command: z29.string().min(1),
+  args: z29.array(z29.string()).max(64),
+  displayCommand: z29.string().min(1)
 }).passthrough();
-var providerInstallationVerificationSchema = z28.discriminatedUnion(
+var providerInstallationVerificationSchema = z29.discriminatedUnion(
   "kind",
   [
-    z28.object({ kind: z28.literal("installed") }).passthrough(),
-    z28.object({
-      kind: z28.literal("version_changed"),
-      previousVersion: z28.string().min(1)
+    z29.object({ kind: z29.literal("installed") }).passthrough(),
+    z29.object({
+      kind: z29.literal("version_changed"),
+      previousVersion: z29.string().min(1)
     }).passthrough(),
-    z28.object({
-      kind: z28.literal("version_at_least"),
-      version: z28.string().min(1)
+    z29.object({
+      kind: z29.literal("version_at_least"),
+      version: z29.string().min(1)
     }).passthrough()
   ]
 );
-var providerInstallationRunResultSchema = z28.discriminatedUnion(
+var providerInstallationRunResultSchema = z29.discriminatedUnion(
   "available",
   [
-    z28.object({
-      available: z28.literal(false),
-      message: z28.string().min(1)
+    z29.object({
+      available: z29.literal(false),
+      message: z29.string().min(1)
     }).passthrough(),
-    z28.object({
-      available: z28.literal(true),
+    z29.object({
+      available: z29.literal(true),
       command: providerInstallationCommandSchema,
       verification: providerInstallationVerificationSchema
     }).passthrough()
@@ -4212,7 +4226,7 @@ var providerInstallationRunResultSchema = z28.discriminatedUnion(
 );
 
 // ../provider-bridge-protocol/src/requests.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var BRIDGE_REQUEST_METHODS = {
   initialize: "initialize",
   modelList: "model/list",
@@ -4234,78 +4248,78 @@ var BRIDGE_REQUEST_METHODS = {
   skillsConfigure: "skills/configure"
 };
 var sessionConstructionFields = {
-  threadId: z29.string().min(1),
-  cwd: z29.string().min(1),
+  threadId: z30.string().min(1),
+  cwd: z30.string().min(1),
   options: bridgeExecutionOptionsSchema,
-  dynamicTools: z29.array(dynamicToolSchema).optional(),
-  disallowedTools: z29.array(z29.string().min(1)).optional(),
+  dynamicTools: z30.array(dynamicToolSchema).optional(),
+  disallowedTools: z30.array(z30.string().min(1)).optional(),
   instructionMode: instructionModeSchema
 };
-var modelListParamsSchema = z29.object({ cwd: z29.string().min(1).optional() }).passthrough();
-var threadStartParamsSchema = z29.object({
+var modelListParamsSchema = z30.object({ cwd: z30.string().min(1).optional() }).passthrough();
+var threadStartParamsSchema = z30.object({
   ...sessionConstructionFields,
-  input: z29.array(promptInputSchema).optional()
+  input: z30.array(promptInputSchema).optional()
 }).passthrough();
-var threadResumeParamsSchema = z29.object({
+var threadResumeParamsSchema = z30.object({
   ...sessionConstructionFields,
-  providerThreadId: z29.string().min(1)
+  providerThreadId: z30.string().min(1)
 }).passthrough();
-var threadForkParamsSchema = z29.object({
+var threadForkParamsSchema = z30.object({
   ...sessionConstructionFields,
-  sourceProviderThreadId: z29.string().min(1),
-  sourceProviderCheckpointId: z29.string().min(1).optional()
+  sourceProviderThreadId: z30.string().min(1),
+  sourceProviderCheckpointId: z30.string().min(1).optional()
 }).passthrough();
-var threadStopParamsSchema = z29.object({
-  threadId: z29.string().min(1),
-  providerThreadId: z29.string().min(1),
-  intent: z29.enum(["interrupt", "release"]),
-  activeTurnId: z29.string().min(1).nullable()
+var threadStopParamsSchema = z30.object({
+  threadId: z30.string().min(1),
+  providerThreadId: z30.string().min(1),
+  intent: z30.enum(["interrupt", "release"]),
+  activeTurnId: z30.string().min(1).nullable()
 }).passthrough();
-var threadRefParams = z29.object({
-  threadId: z29.string().min(1),
-  providerThreadId: z29.string().min(1)
+var threadRefParams = z30.object({
+  threadId: z30.string().min(1),
+  providerThreadId: z30.string().min(1)
 }).passthrough();
 var threadDiscardParamsSchema = threadRefParams;
 var threadArchiveParamsSchema = threadRefParams;
 var threadUnarchiveParamsSchema = threadRefParams;
 var threadGoalClearParamsSchema = threadRefParams;
-var threadNameSetParamsSchema = z29.object({
-  threadId: z29.string().min(1),
-  providerThreadId: z29.string().min(1),
-  title: z29.string().min(1)
+var threadNameSetParamsSchema = z30.object({
+  threadId: z30.string().min(1),
+  providerThreadId: z30.string().min(1),
+  title: z30.string().min(1)
 }).passthrough();
 var turnInputFields = {
-  threadId: z29.string().min(1),
-  providerThreadId: z29.string().min(1),
-  input: z29.array(promptInputSchema),
+  threadId: z30.string().min(1),
+  providerThreadId: z30.string().min(1),
+  input: z30.array(promptInputSchema),
   clientRequestId: clientTurnRequestIdSchema,
   options: bridgeExecutionOptionsSchema
 };
-var turnStartParamsSchema = z29.object(turnInputFields).passthrough();
-var turnSteerParamsSchema = z29.object({
+var turnStartParamsSchema = z30.object(turnInputFields).passthrough();
+var turnSteerParamsSchema = z30.object({
   ...turnInputFields,
-  expectedTurnId: z29.string().min(1)
+  expectedTurnId: z30.string().min(1)
 }).passthrough();
-var skillsConfigureRootSchema = z29.object({
-  id: z29.string().min(1),
-  path: z29.string().min(1),
-  skills: z29.array(
-    z29.object({
-      name: z29.string().min(1),
-      description: z29.string()
+var skillsConfigureRootSchema = z30.object({
+  id: z30.string().min(1),
+  path: z30.string().min(1),
+  skills: z30.array(
+    z30.object({
+      name: z30.string().min(1),
+      description: z30.string()
     }).passthrough()
   )
 }).passthrough();
-var skillsConfigureParamsSchema = z29.object({
-  roots: z29.array(skillsConfigureRootSchema)
+var skillsConfigureParamsSchema = z30.object({
+  roots: z30.array(skillsConfigureRootSchema)
 }).passthrough();
-var threadIdentityResultSchema = z29.object({
-  providerThreadId: z29.string().min(1),
-  sessionRestorable: z29.boolean().optional()
+var threadIdentityResultSchema = z30.object({
+  providerThreadId: z30.string().min(1),
+  sessionRestorable: z30.boolean().optional()
 }).passthrough();
 
 // ../provider-bridge-protocol/src/notifications.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var BRIDGE_NOTIFICATION_METHODS = {
   threadIdentity: "thread/identity",
   sessionReplaced: "session/replaced",
@@ -4313,142 +4327,142 @@ var BRIDGE_NOTIFICATION_METHODS = {
   providerRecovery: "provider/recovery",
   error: "error"
 };
-var threadIdentityNotificationSchema = z30.object({
-  threadId: z30.string().min(1),
-  providerThreadId: z30.string().min(1),
-  sessionRestorable: z30.boolean().optional()
+var threadIdentityNotificationSchema = z31.object({
+  threadId: z31.string().min(1),
+  providerThreadId: z31.string().min(1),
+  sessionRestorable: z31.boolean().optional()
 }).passthrough();
-var sessionReplacedNotificationSchema = z30.object({
-  threadId: z30.string().min(1),
-  providerThreadId: z30.string().min(1).nullable(),
-  reason: z30.string().min(1),
-  contextLost: z30.boolean().default(false),
-  showRuntimeNote: z30.boolean().default(false)
+var sessionReplacedNotificationSchema = z31.object({
+  threadId: z31.string().min(1),
+  providerThreadId: z31.string().min(1).nullable(),
+  reason: z31.string().min(1),
+  contextLost: z31.boolean().default(false),
+  showRuntimeNote: z31.boolean().default(false)
 }).passthrough();
-var providerRecoveryNotificationSchema = z30.object({
-  threadId: z30.string().min(1).optional(),
+var providerRecoveryNotificationSchema = z31.object({
+  threadId: z31.string().min(1).optional(),
   ...providerRecoveryHintSchema.shape
 }).passthrough();
-var errorNotificationSchema = z30.object({
-  threadId: z30.string().min(1).optional(),
-  providerThreadId: z30.string().min(1).optional(),
-  message: z30.string().min(1)
+var errorNotificationSchema = z31.object({
+  threadId: z31.string().min(1).optional(),
+  providerThreadId: z31.string().min(1).optional(),
+  message: z31.string().min(1)
 }).passthrough();
 
 // ../provider-bridge-protocol/src/thread-delta.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var THREAD_DELTA_NOTIFICATION_METHOD = "thread/delta";
 var deltaPresentationSchema = threadEventItemPresentationSchema;
 var THREAD_DELTA_KEY_SEPARATOR = "";
-var deltaKeyPartSchema = z31.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
+var deltaKeyPartSchema = z32.string().min(1).refine((value) => !value.includes(THREAD_DELTA_KEY_SEPARATOR), {
   message: "provider keys must not contain the internal key separator (\\u001f)"
 });
-var deltaItemKeySchema = z31.object({
+var deltaItemKeySchema = z32.object({
   providerItemId: deltaKeyPartSchema.optional(),
   channel: deltaKeyPartSchema.optional(),
   parentRef: deltaKeyPartSchema.optional()
 });
 var providerTurnIdSchema = deltaKeyPartSchema;
-var deltaFileChangeSchema = z31.object({
-  path: z31.string(),
-  kind: z31.enum(["add", "update", "delete"]),
-  movePath: z31.string().optional(),
-  diff: z31.string().optional(),
-  oldText: z31.string().optional(),
-  newText: z31.string().optional()
-});
-var deltaBackgroundTaskShapeSchema = z31.object({
-  type: z31.literal("backgroundTask"),
-  familyId: z31.string().min(1),
-  taskType: z31.string(),
-  description: z31.string(),
+var deltaFileChangeSchema = z32.object({
+  path: z32.string(),
+  kind: z32.enum(["add", "update", "delete"]),
+  movePath: z32.string().optional(),
+  diff: z32.string().optional(),
+  oldText: z32.string().optional(),
+  newText: z32.string().optional()
+});
+var deltaBackgroundTaskShapeSchema = z32.object({
+  type: z32.literal("backgroundTask"),
+  familyId: z32.string().min(1),
+  taskType: z32.string(),
+  description: z32.string(),
   status: threadEventItemStatusSchema,
   taskStatus: backgroundTaskStatusSchema,
-  skipTranscript: z31.boolean(),
-  workflowName: z31.string().optional(),
+  skipTranscript: z32.boolean(),
+  workflowName: z32.string().optional(),
   workflow: workflowProgressSnapshotSchema.optional(),
   usage: backgroundTaskUsageSchema.optional(),
-  summary: z31.string().optional(),
-  error: z31.string().optional(),
-  outputFile: z31.string().optional()
+  summary: z32.string().optional(),
+  error: z32.string().optional(),
+  outputFile: z32.string().optional()
 });
-var deltaFileReadShapeSchema = z31.object({
-  type: z31.literal("fileRead"),
-  path: z31.string(),
-  cmd: z31.string().optional()
+var deltaFileReadShapeSchema = z32.object({
+  type: z32.literal("fileRead"),
+  path: z32.string(),
+  cmd: z32.string().optional()
 });
-var deltaSearchShapeSchema = z31.object({
-  type: z31.literal("search"),
+var deltaSearchShapeSchema = z32.object({
+  type: z32.literal("search"),
   mode: threadEventSearchModeSchema,
-  query: z31.string(),
-  path: z31.string().optional(),
-  cmd: z31.string().optional()
+  query: z32.string(),
+  path: z32.string().optional(),
+  cmd: z32.string().optional()
 });
-var deltaDelegationShapeSchema = z31.object({
-  type: z31.literal("delegation"),
+var deltaDelegationShapeSchema = z32.object({
+  type: z32.literal("delegation"),
   childRef: deltaKeyPartSchema,
-  label: z31.string(),
-  background: z31.boolean(),
-  summary: z31.string().optional()
+  label: z32.string(),
+  background: z32.boolean(),
+  summary: z32.string().optional()
 });
-var deltaPlanStepsShapeSchema = z31.object({
-  type: z31.literal("planSteps"),
-  steps: z31.array(threadEventPlanStepSchema),
-  explanation: z31.string().optional()
+var deltaPlanStepsShapeSchema = z32.object({
+  type: z32.literal("planSteps"),
+  steps: z32.array(threadEventPlanStepSchema),
+  explanation: z32.string().optional()
 });
-var deltaExtensionShapeSchema = z31.object({
-  type: z31.literal("extension"),
+var deltaExtensionShapeSchema = z32.object({
+  type: z32.literal("extension"),
   kind: extensionKindSchema,
   payload: jsonValueSchema
 });
-var deltaItemShapeSchema = z31.discriminatedUnion("type", [
-  z31.object({
-    type: z31.literal("command"),
-    command: z31.string(),
-    cwd: z31.string(),
-    aggregatedOutput: z31.string().optional(),
-    exitCode: z31.number().optional(),
-    durationMs: z31.number().optional()
+var deltaItemShapeSchema = z32.discriminatedUnion("type", [
+  z32.object({
+    type: z32.literal("command"),
+    command: z32.string(),
+    cwd: z32.string(),
+    aggregatedOutput: z32.string().optional(),
+    exitCode: z32.number().optional(),
+    durationMs: z32.number().optional()
   }),
-  z31.object({
-    type: z31.literal("fileChange"),
-    changes: z31.array(deltaFileChangeSchema)
+  z32.object({
+    type: z32.literal("fileChange"),
+    changes: z32.array(deltaFileChangeSchema)
   }),
-  z31.object({
-    type: z31.literal("tool"),
-    tool: z31.string(),
-    server: z31.string().optional(),
-    args: z31.unknown().optional(),
-    result: z31.unknown().optional(),
-    error: z31.string().optional(),
-    durationMs: z31.number().optional()
+  z32.object({
+    type: z32.literal("tool"),
+    tool: z32.string(),
+    server: z32.string().optional(),
+    args: z32.unknown().optional(),
+    result: z32.unknown().optional(),
+    error: z32.string().optional(),
+    durationMs: z32.number().optional()
   }),
-  z31.object({ type: z31.literal("compaction") }),
-  z31.object({ type: z31.literal("agentMessage"), text: z31.string() }),
-  z31.object({
-    type: z31.literal("reasoning"),
-    summary: z31.array(z31.string()),
-    content: z31.array(z31.string())
+  z32.object({ type: z32.literal("compaction") }),
+  z32.object({ type: z32.literal("agentMessage"), text: z32.string() }),
+  z32.object({
+    type: z32.literal("reasoning"),
+    summary: z32.array(z32.string()),
+    content: z32.array(z32.string())
   }),
-  z31.object({ type: z31.literal("plan"), text: z31.string() }),
-  z31.object({
-    type: z31.literal("webSearch"),
-    queries: z31.array(z31.string()).min(1)
+  z32.object({ type: z32.literal("plan"), text: z32.string() }),
+  z32.object({
+    type: z32.literal("webSearch"),
+    queries: z32.array(z32.string()).min(1)
   }),
-  z31.object({
-    type: z31.literal("webFetch"),
-    url: z31.string(),
-    prompt: z31.string().nullable().optional(),
-    pattern: z31.string().nullable()
+  z32.object({
+    type: z32.literal("webFetch"),
+    url: z32.string(),
+    prompt: z32.string().nullable().optional(),
+    pattern: z32.string().nullable()
   }),
-  z31.object({ type: z31.literal("imageView"), path: z31.string() }),
-  z31.object({
-    type: z31.literal("imageGeneration"),
-    prompt: z31.string().nullable(),
-    path: z31.string().nullable(),
-    result: z31.string().optional(),
-    error: z31.string().nullable(),
-    transparentBackground: z31.boolean()
+  z32.object({ type: z32.literal("imageView"), path: z32.string() }),
+  z32.object({
+    type: z32.literal("imageGeneration"),
+    prompt: z32.string().nullable(),
+    path: z32.string().nullable(),
+    result: z32.string().optional(),
+    error: z32.string().nullable(),
+    transparentBackground: z32.boolean()
   }),
   deltaBackgroundTaskShapeSchema,
   deltaFileReadShapeSchema,
@@ -4457,22 +4471,22 @@ var deltaItemShapeSchema = z31.discriminatedUnion("type", [
   deltaPlanStepsShapeSchema,
   deltaExtensionShapeSchema
 ]);
-var deltaProgressSnapshotSchema = z31.discriminatedUnion("type", [
+var deltaProgressSnapshotSchema = z32.discriminatedUnion("type", [
   deltaBackgroundTaskShapeSchema,
   deltaDelegationShapeSchema
 ]);
-var deltaTextChannelSchema = z31.enum([
+var deltaTextChannelSchema = z32.enum([
   "agentMessage",
   "reasoningSummary",
   "reasoningText",
   "plan"
 ]);
-var deltaOutputChannelSchema = z31.enum(["command", "fileChange"]);
-var deltaErrorSchema = z31.object({ message: z31.string() });
-var deltaAttachSchema = z31.enum(["open", "currentOrLast"]);
-var deltaNoTurnFallbackSchema = z31.object({
+var deltaOutputChannelSchema = z32.enum(["command", "fileChange"]);
+var deltaErrorSchema = z32.object({ message: z32.string() });
+var deltaAttachSchema = z32.enum(["open", "currentOrLast"]);
+var deltaNoTurnFallbackSchema = z32.object({
   raw: providerRawEventSchema,
-  rawType: z31.string()
+  rawType: z32.string()
 });
 function requireExtensionPresentation(delta, ctx) {
   if (delta.item.type === "extension" && delta.presentation === void 0) {
@@ -4483,32 +4497,32 @@ function requireExtensionPresentation(delta, ctx) {
     });
   }
 }
-var threadDeltaSchema = z31.discriminatedUnion("kind", [
-  z31.object({
-    kind: z31.literal("input.accepted"),
+var threadDeltaSchema = z32.discriminatedUnion("kind", [
+  z32.object({
+    kind: z32.literal("input.accepted"),
     clientRequestId: clientTurnRequestIdSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("input.provider"),
-    text: z31.string().min(1),
+  z32.object({
+    kind: z32.literal("input.provider"),
+    text: z32.string().min(1),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("turn.open"),
+  z32.object({
+    kind: z32.literal("turn.open"),
     providerTurnId: providerTurnIdSchema.optional(),
     parentRef: deltaKeyPartSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("turn.boundary"),
+  z32.object({
+    kind: z32.literal("turn.boundary"),
     status: threadEventTurnStatusSchema,
     error: deltaErrorSchema.optional(),
-    providerCheckpointId: z31.string().min(1).optional(),
-    claimIfIdle: z31.boolean().optional(),
+    providerCheckpointId: z32.string().min(1).optional(),
+    claimIfIdle: z32.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("item.open"),
+  z32.object({
+    kind: z32.literal("item.open"),
     key: deltaItemKeySchema,
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
@@ -4516,140 +4530,140 @@ var threadDeltaSchema = z31.discriminatedUnion("kind", [
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z31.object({
-    kind: z31.literal("item.close"),
+  z32.object({
+    kind: z32.literal("item.close"),
     key: deltaItemKeySchema,
     status: threadEventItemStatusSchema,
-    resultText: z31.string().optional(),
-    exitCode: z31.number().optional(),
-    aggregatedOutput: z31.string().optional(),
-    approvalStatus: z31.literal("denied").optional(),
+    resultText: z32.string().optional(),
+    exitCode: z32.number().optional(),
+    aggregatedOutput: z32.string().optional(),
+    approvalStatus: z32.literal("denied").optional(),
     item: deltaItemShapeSchema,
     presentation: deltaPresentationSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }).superRefine(requireExtensionPresentation),
-  z31.object({
-    kind: z31.literal("item.progress"),
+  z32.object({
+    kind: z32.literal("item.progress"),
     key: deltaItemKeySchema,
-    message: z31.string().optional(),
+    message: z32.string().optional(),
     snapshot: deltaProgressSnapshotSchema.optional(),
-    flush: z31.boolean().optional(),
+    flush: z32.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("item.textDelta"),
+  z32.object({
+    kind: z32.literal("item.textDelta"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z31.string(),
+    text: z32.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("item.textClose"),
+  z32.object({
+    kind: z32.literal("item.textClose"),
     key: deltaItemKeySchema,
     channel: deltaTextChannelSchema,
-    text: z31.string().optional(),
+    text: z32.string().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("item.outputDelta"),
+  z32.object({
+    kind: z32.literal("item.outputDelta"),
     key: deltaItemKeySchema,
     channel: deltaOutputChannelSchema,
-    text: z31.string(),
+    text: z32.string(),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("command.outputSnapshot"),
+  z32.object({
+    kind: z32.literal("command.outputSnapshot"),
     key: deltaItemKeySchema,
-    text: z31.string(),
+    text: z32.string(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("usage"),
+  z32.object({
+    kind: z32.literal("usage"),
     total: threadEventTokenUsageBreakdownSchema,
     last: threadEventTokenUsageBreakdownSchema,
-    modelContextWindow: z31.number().nullable(),
+    modelContextWindow: z32.number().nullable(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("contextWindow"),
+  z32.object({
+    kind: z32.literal("contextWindow"),
     snapshot: contextSnapshotSchema.optional(),
-    used: z31.number().nullable(),
-    size: z31.number().nullable().optional(),
-    estimated: z31.boolean(),
+    used: z32.number().nullable(),
+    size: z32.number().nullable().optional(),
+    estimated: z32.boolean(),
     attach: deltaAttachSchema,
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z31.object({
-    kind: z31.literal("context.compacted"),
+  z32.object({
+    kind: z32.literal("context.compacted"),
     providerTurnId: providerTurnIdSchema.optional(),
     noTurnFallback: deltaNoTurnFallbackSchema.optional()
   }),
-  z31.object({ kind: z31.literal("context.cleared") }),
-  z31.object({
-    kind: z31.literal("turn.diff"),
-    diff: z31.string(),
+  z32.object({ kind: z32.literal("context.cleared") }),
+  z32.object({
+    kind: z32.literal("turn.diff"),
+    diff: z32.string(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z31.object({ kind: z31.literal("thread.started") }),
-  z31.object({
-    kind: z31.literal("thread.identity"),
-    providerThreadId: z31.string().min(1)
+  z32.object({ kind: z32.literal("thread.started") }),
+  z32.object({
+    kind: z32.literal("thread.identity"),
+    providerThreadId: z32.string().min(1)
   }),
-  z31.object({ kind: z31.literal("thread.name"), name: z31.string().min(1) }),
-  z31.object({
-    kind: z31.literal("extension.state"),
+  z32.object({ kind: z32.literal("thread.name"), name: z32.string().min(1) }),
+  z32.object({
+    kind: z32.literal("extension.state"),
     extensionKind: extensionKindSchema,
     payload: jsonValueSchema
   }),
-  z31.object({
-    kind: z31.literal("provider.rateLimits"),
+  z32.object({
+    kind: z32.literal("provider.rateLimits"),
     rateLimits: providerRateLimitStateSchema
   }),
-  z31.object({
-    kind: z31.literal("provider.error"),
-    message: z31.string(),
-    detail: z31.string().optional(),
-    willRetry: z31.boolean().optional(),
+  z32.object({
+    kind: z32.literal("provider.error"),
+    message: z32.string(),
+    detail: z32.string().optional(),
+    willRetry: z32.boolean().optional(),
     category: providerErrorCategorySchema.optional(),
     errorInfo: providerErrorInfoSchema.optional(),
-    settlesTurn: z31.boolean().optional(),
+    settlesTurn: z32.boolean().optional(),
     providerTurnId: providerTurnIdSchema.optional(),
-    threadScoped: z31.boolean().optional()
+    threadScoped: z32.boolean().optional()
   }),
-  z31.object({
-    kind: z31.literal("provider.modelFallback"),
-    originalModel: z31.string().min(1),
-    fallbackModel: z31.string().min(1),
-    reason: z31.enum(["refusal", "provider"]),
-    message: z31.string()
+  z32.object({
+    kind: z32.literal("provider.modelFallback"),
+    originalModel: z32.string().min(1),
+    fallbackModel: z32.string().min(1),
+    reason: z32.enum(["refusal", "provider"]),
+    message: z32.string()
   }),
-  z31.object({
-    kind: z31.literal("provider.warning"),
-    summary: z31.string().optional(),
-    details: z31.string().optional(),
+  z32.object({
+    kind: z32.literal("provider.warning"),
+    summary: z32.string().optional(),
+    details: z32.string().optional(),
     category: threadEventWarningCategorySchema.optional(),
-    vouchedTurn: z31.boolean().optional()
+    vouchedTurn: z32.boolean().optional()
   }),
-  z31.object({
-    kind: z31.literal("unhandled"),
+  z32.object({
+    kind: z32.literal("unhandled"),
     raw: providerRawEventSchema,
-    rawType: z31.string(),
-    vouchedTurn: z31.boolean(),
-    onlyIfNoTurn: z31.boolean().optional(),
+    rawType: z32.string(),
+    vouchedTurn: z32.boolean(),
+    onlyIfNoTurn: z32.boolean().optional(),
     parentRef: deltaKeyPartSchema.optional(),
     providerTurnId: providerTurnIdSchema.optional()
   }),
-  z31.object({ kind: z31.literal("session.ended") }),
-  z31.object({ kind: z31.literal("session.reset") })
+  z32.object({ kind: z32.literal("session.ended") }),
+  z32.object({ kind: z32.literal("session.reset") })
 ]);
-var threadDeltaNotificationParamsSchema = z31.object({
-  threadId: z31.string().min(1),
-  deltas: z31.array(threadDeltaSchema)
+var threadDeltaNotificationParamsSchema = z32.object({
+  threadId: z32.string().min(1),
+  deltas: z32.array(threadDeltaSchema)
 }).passthrough();
 
 // ../process-utils/src/index.ts
@@ -4672,10 +4686,10 @@ function sanitizeInheritedChildProcessEnv(args) {
 }
 
 // ../provider-bridge-acp/src/launch-spec.ts
-import { z as z32 } from "zod";
-var acpNativeSkillRootsSchema = z32.object({
-  user: z32.array(providerNativeRootInputSchema).default([]),
-  project: z32.array(providerNativeRootInputSchema).default([])
+import { z as z33 } from "zod";
+var acpNativeSkillRootsSchema = z33.object({
+  user: z33.array(providerNativeRootInputSchema).default([]),
+  project: z33.array(providerNativeRootInputSchema).default([])
 }).strict().superRefine((roots, context) => {
   const normalized = providerNativeRootsSchema.safeParse(
     normalizeProviderNativeRoots(roots)
@@ -4691,16 +4705,16 @@ var acpNativeSkillRootsSchema = z32.object({
     });
   }
 });
-var acpLaunchSpecSchema = z32.object({
-  displayName: z32.string().min(1),
-  command: z32.string().min(1),
-  args: z32.array(z32.string()),
-  env: z32.record(z32.string().min(1), z32.string()),
-  cwd: z32.string().min(1).optional(),
-  modelCli: z32.object({
-    listArgs: z32.array(z32.string()),
-    selectFlag: z32.string().min(1).optional(),
-    primaryModels: z32.array(z32.string())
+var acpLaunchSpecSchema = z33.object({
+  displayName: z33.string().min(1),
+  command: z33.string().min(1),
+  args: z33.array(z33.string()),
+  env: z33.record(z33.string().min(1), z33.string()),
+  cwd: z33.string().min(1).optional(),
+  modelCli: z33.object({
+    listArgs: z33.array(z33.string()),
+    selectFlag: z33.string().min(1).optional(),
+    primaryModels: z33.array(z33.string())
   }).strict().transform(
     (modelCli) => modelCli.listArgs.length > 0 ? modelCli : void 0
   ).optional(),
@@ -4738,35 +4752,35 @@ function normalizeAcpLaunchSpec(spec) {
 }
 
 // src/claude-task-tools.ts
-import { z as z33 } from "zod";
-var claudeTaskToolNameSchema = z33.enum([
+import { z as z34 } from "zod";
+var claudeTaskToolNameSchema = z34.enum([
   "TaskCreate",
   "TaskGet",
   "TaskList",
   "TaskUpdate"
 ]);
-var claudeTaskStatusSchema = z33.enum(["pending", "in_progress", "completed"]);
-var claudeTaskCreateOutputSchema = z33.object({
-  task: z33.object({
-    id: z33.string(),
-    subject: z33.string()
+var claudeTaskStatusSchema = z34.enum(["pending", "in_progress", "completed"]);
+var claudeTaskCreateOutputSchema = z34.object({
+  task: z34.object({
+    id: z34.string(),
+    subject: z34.string()
   }).passthrough()
 }).passthrough();
-var claudeTaskGetOutputSchema = z33.object({
-  task: z33.object({
-    id: z33.string(),
+var claudeTaskGetOutputSchema = z34.object({
+  task: z34.object({
+    id: z34.string(),
     status: claudeTaskStatusSchema,
-    subject: z33.string()
+    subject: z34.string()
   }).passthrough().nullable()
 }).passthrough();
-var claudeTaskUpdateOutputSchema = z33.object({
-  success: z33.boolean(),
-  taskId: z33.string()
+var claudeTaskUpdateOutputSchema = z34.object({
+  success: z34.boolean(),
+  taskId: z34.string()
 }).passthrough();
-var claudeTaskListOutputSchema = z33.object({
-  tasks: z33.array(z33.unknown())
+var claudeTaskListOutputSchema = z34.object({
+  tasks: z34.array(z34.unknown())
 }).passthrough();
-var claudeTaskToolOutputSchema = z33.union([
+var claudeTaskToolOutputSchema = z34.union([
   claudeTaskCreateOutputSchema,
   claudeTaskGetOutputSchema,
   claudeTaskListOutputSchema,