@spotpatch/shared 1.9.0 → 1.10.0

package/dist/index.cjs

@@ -44,6 +44,16 @@ __export(index_exports, {
   DEFAULT_DATA_FLOW_LIMITS: () => DEFAULT_DATA_FLOW_LIMITS,
   DEFAULT_RUNTIME_DATA_FLOW_LIMITS: () => DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
   ERROR_CODES: () => ERROR_CODES,
+  ERROR_CODE_VALUES: () => ERROR_CODE_VALUES,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS: () => EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES: () => EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES,
+  EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION: () => EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION,
+  EXTERNAL_HANDOFF_DISPATCH_PHASES: () => EXTERNAL_HANDOFF_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_FRAMEWORKS: () => EXTERNAL_HANDOFF_FRAMEWORKS,
+  EXTERNAL_HANDOFF_LIMITS: () => EXTERNAL_HANDOFF_LIMITS,
+  EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES: () => EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION: () => EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION,
+  EXTERNAL_HANDOFF_STATES: () => EXTERNAL_HANDOFF_STATES,
   MAX_ANNOTATION_INSTRUCTION_CHARACTERS: () => MAX_ANNOTATION_INSTRUCTION_CHARACTERS,
   MAX_ANNOTATION_TARGETS: () => MAX_ANNOTATION_TARGETS,
   MAX_TARGET_INSTRUCTION_CHARACTERS: () => MAX_TARGET_INSTRUCTION_CHARACTERS,
@@ -58,6 +68,7 @@ __export(index_exports, {
   SPOTPATCH_REPOSITORY_URL: () => SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER: () => SPOTPATCH_TOKEN_HEADER,
   SpotPatchError: () => SpotPatchError,
+  activeAdapterSummarySchema: () => activeAdapterSummarySchema,
   agentCapabilityRequestSchema: () => agentCapabilityRequestSchema,
   agentCapabilitySnapshotSchema: () => agentCapabilitySnapshotSchema,
   agentChangedFileSchema: () => agentChangedFileSchema,
@@ -74,8 +85,21 @@ __export(index_exports, {
   dataDependencySchema: () => dataDependencySchema,
   dataFlowComponentReportRequestSchema: () => dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema: () => dataFlowPageReportRequestSchema,
+  dispatchSummarySchema: () => dispatchSummarySchema,
+  externalHandoffCapabilityRequestSchema: () => externalHandoffCapabilityRequestSchema,
+  externalHandoffCapabilitySchema: () => externalHandoffCapabilitySchema,
+  externalHandoffPublishDeliverySchema: () => externalHandoffPublishDeliverySchema,
+  externalHandoffPublishRequestSchema: () => externalHandoffPublishRequestSchema,
+  externalHandoffPublishResultSchema: () => externalHandoffPublishResultSchema,
+  externalHandoffReportableDispatchPhaseSchema: () => externalHandoffReportableDispatchPhaseSchema,
+  externalHandoffResolveDeliveryRequestSchema: () => externalHandoffResolveDeliveryRequestSchema,
+  externalHandoffSnapshotSchema: () => externalHandoffSnapshotSchema,
+  externalHandoffStatusRequestSchema: () => externalHandoffStatusRequestSchema,
+  externalHandoffStatusResultSchema: () => externalHandoffStatusResultSchema,
+  externalHandoffSummarySchema: () => externalHandoffSummarySchema,
   formatSourceMarker: () => formatSourceMarker,
   getAgentJobEndpoint: () => getAgentJobEndpoint,
+  isErrorCode: () => isErrorCode,
   isSensitiveName: () => isSensitiveName,
   limitDataFlowReportCollections: () => limitDataFlowReportCollections,
   networkObservationSchema: () => networkObservationSchema,
@@ -125,6 +149,24 @@ var ERROR_CODES = {
   AGENT_BUSY: "AGENT_BUSY",
   AGENT_LIMIT_EXCEEDED: "AGENT_LIMIT_EXCEEDED",
   AGENT_CANCELLED: "AGENT_CANCELLED",
+  EXTERNAL_HANDOFF_DISABLED: "EXTERNAL_HANDOFF_DISABLED",
+  EXTERNAL_HANDOFF_UNAVAILABLE: "EXTERNAL_HANDOFF_UNAVAILABLE",
+  HANDOFF_VALIDATION_FAILED: "HANDOFF_VALIDATION_FAILED",
+  HANDOFF_SOURCE_STALE: "HANDOFF_SOURCE_STALE",
+  HANDOFF_NOT_FOUND: "HANDOFF_NOT_FOUND",
+  HANDOFF_EXPIRED: "HANDOFF_EXPIRED",
+  HANDOFF_CURSOR_INVALID: "HANDOFF_CURSOR_INVALID",
+  HANDOFF_RESPONSE_TOO_LARGE: "HANDOFF_RESPONSE_TOO_LARGE",
+  BRIDGE_UNAUTHORIZED: "BRIDGE_UNAUTHORIZED",
+  BRIDGE_PROTOCOL_MISMATCH: "BRIDGE_PROTOCOL_MISMATCH",
+  BRIDGE_BUSY: "BRIDGE_BUSY",
+  EXTERNAL_AGENT_BUSY: "EXTERNAL_AGENT_BUSY",
+  ACTIVE_ADAPTER_CONFLICT: "ACTIVE_ADAPTER_CONFLICT",
+  ACTIVE_ADAPTER_LEASE_INVALID: "ACTIVE_ADAPTER_LEASE_INVALID",
+  ACTIVE_DISPATCH_INVALID: "ACTIVE_DISPATCH_INVALID",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_AMBIGUOUS: "SESSION_AMBIGUOUS",
+  SESSION_CLOSED: "SESSION_CLOSED",
   WORKTREE_DIRTY: "WORKTREE_DIRTY",
   WORKTREE_NOT_REPOSITORY: "WORKTREE_NOT_REPOSITORY",
   WORKTREE_OPERATION_IN_PROGRESS: "WORKTREE_OPERATION_IN_PROGRESS",
@@ -142,6 +184,10 @@ var ERROR_CODES = {
   APPLY_CONFLICT: "APPLY_CONFLICT",
   INTERNAL_ERROR: "INTERNAL_ERROR"
 };
+var ERROR_CODE_VALUES = Object.freeze(Object.values(ERROR_CODES));
+function isErrorCode(value) {
+  return typeof value === "string" && ERROR_CODE_VALUES.includes(value);
+}
 
 // src/security/redaction.ts
 var INLINE_DATA_PATTERN = /data:[^\s"'<>]*;base64,[a-z0-9+/_=-]+/giu;
@@ -712,7 +758,11 @@ var SPOTPATCH_ENDPOINTS = Object.freeze({
   dataFlowPageReport: `${SPOTPATCH_API_BASE}/data-flow/page-report`,
   agentCapability: `${SPOTPATCH_API_BASE}/agent/capability`,
   agentWorkspaceHealth: `${SPOTPATCH_API_BASE}/agent/workspace-health`,
-  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`
+  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`,
+  externalHandoffCapability: `${SPOTPATCH_API_BASE}/external-handoff/capability`,
+  externalHandoffPublish: `${SPOTPATCH_API_BASE}/external-handoff/publish`,
+  externalHandoffStatus: `${SPOTPATCH_API_BASE}/external-handoff/status`,
+  externalHandoffResolveDelivery: `${SPOTPATCH_API_BASE}/external-handoff/resolve-delivery`
 });
 function getAgentJobEndpoint(jobId, action) {
   return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
@@ -834,6 +884,7 @@ var runtimeConfigBaseShape = {
   debug: import_zod2.z.boolean(),
   dataFlow: runtimeDataFlowConfigSchema,
   editor: import_zod2.z.enum(SPOTPATCH_EDITOR_PREFERENCES),
+  externalAgent: import_zod2.z.strictObject({ enabled: import_zod2.z.boolean() }),
   frameworkVersion: boundedText2(64),
   locale: import_zod2.z.enum(SPOTPATCH_LOCALE_PREFERENCES),
   maxTargets: import_zod2.z.number().int().min(1).max(MAX_ANNOTATION_TARGETS),
@@ -879,6 +930,9 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
+// src/protocol/external-handoff.ts
+var import_zod4 = require("zod");
+
 // src/protocol/requests.ts
 var import_zod3 = require("zod");
 var runtimeBootstrapRequestSchema = import_zod3.z.strictObject({});
@@ -1012,37 +1066,196 @@ var agentJobCreateRequestSchema = import_zod3.z.strictObject({
 });
 var agentJobActionRequestSchema = import_zod3.z.strictObject({});
 
+// src/protocol/external-handoff-constants.ts
+var EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION = 1;
+var EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION = 2;
+var EXTERNAL_HANDOFF_STATES = Object.freeze([
+  "available",
+  "expired",
+  "superseded"
+]);
+var EXTERNAL_HANDOFF_FRAMEWORKS = Object.freeze(["vite", "next"]);
+var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS = Object.freeze([
+  "claude-channel",
+  "codex-app-server"
+]);
+var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES = Object.freeze([
+  "ready",
+  "busy",
+  "blocked"
+]);
+var EXTERNAL_HANDOFF_DISPATCH_PHASES = Object.freeze([
+  "queued",
+  "dispatching",
+  "dispatched",
+  "working",
+  "completed",
+  "failed",
+  "delivery-unknown"
+]);
+var EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES = Object.freeze([
+  "dispatching",
+  "dispatched",
+  "working",
+  "completed",
+  "failed",
+  "delivery-unknown"
+]);
+var EXTERNAL_HANDOFF_LIMITS = Object.freeze({
+  maximumSnapshotBytes: 256 * 1024,
+  maximumPublishBodyBytes: 256 * 1024,
+  maximumBrokerRequestBytes: 8 * 1024,
+  maximumDescriptorBytes: 8 * 1024,
+  maximumHistorySummaries: 8,
+  maximumConnectorReceipts: 64,
+  handoffTtlMs: 15 * 60 * 1e3,
+  defaultWaitMs: 2e4,
+  maximumWaitMs: 25e3,
+  maximumWaiters: 8,
+  maximumDescriptorsPerScan: 32,
+  maximumProjectAncestors: 64,
+  maximumBrokerHeaderBytes: 8 * 1024,
+  maximumBrokerSockets: 32,
+  brokerDiscoveryTimeoutMs: 750,
+  brokerRequestTimeoutMs: 2e3,
+  brokerWaitGraceMs: 2e3,
+  maximumSetupConfigBytes: 1024 * 1024,
+  maximumRequestIdRecords: 16,
+  requestIdTtlMs: 15 * 60 * 1e3,
+  activeHeartbeatIntervalMs: 3e3,
+  activeLeaseDurationMs: 1e4,
+  activeTransportWriteTimeoutMs: 5e3,
+  activeDispatchTimeoutMs: 30 * 60 * 1e3,
+  activeStatusPollMs: 1e3
+});
+
+// src/protocol/external-handoff.ts
+var opaqueIdSchema2 = import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var isoTimestampSchema = import_zod4.z.iso.datetime();
+var externalHandoffReportableDispatchPhaseSchema = import_zod4.z.enum(
+  EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES
+);
+var externalHandoffPageSummarySchema = import_zod4.z.strictObject({
+  origin: import_zod4.z.string().min(1).max(2048),
+  pathname: import_zod4.z.string().min(1).max(2048)
+});
+var externalHandoffSummarySchema = import_zod4.z.strictObject({
+  sessionId: opaqueIdSchema2,
+  framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  revision: import_zod4.z.number().int().positive(),
+  cursor: opaqueIdSchema2,
+  targetCount: import_zod4.z.number().int().positive(),
+  page: externalHandoffPageSummarySchema,
+  publishedAt: isoTimestampSchema,
+  expiresAt: isoTimestampSchema,
+  state: import_zod4.z.enum(EXTERNAL_HANDOFF_STATES),
+  pickupCount: import_zod4.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
+  pickedUpAt: isoTimestampSchema.optional()
+});
+var externalHandoffSnapshotSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  cursor: opaqueIdSchema2,
+  session: import_zod4.z.strictObject({
+    id: opaqueIdSchema2,
+    framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
+  }),
+  revision: import_zod4.z.number().int().positive(),
+  publishedAt: isoTimestampSchema,
+  expiresAt: isoTimestampSchema,
+  annotation: spotAnnotationRequestSchema
+});
+var activeAdapterSummarySchema = import_zod4.z.strictObject({
+  kind: import_zod4.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  state: import_zod4.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
+  canDispatch: import_zod4.z.boolean(),
+  connectedAt: isoTimestampSchema,
+  updatedAt: isoTimestampSchema
+}).superRefine((value, context) => {
+  if (value.canDispatch !== (value.state === "ready")) {
+    context.addIssue({
+      code: "custom",
+      message: "canDispatch must match the ready state.",
+      path: ["canDispatch"]
+    });
+  }
+});
+var dispatchSummarySchema = import_zod4.z.strictObject({
+  adapterKind: import_zod4.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  revision: import_zod4.z.number().int().positive(),
+  phase: import_zod4.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
+  updatedAt: isoTimestampSchema
+});
+var externalHandoffCapabilityRequestSchema = import_zod4.z.strictObject({});
+var externalHandoffPublishRequestSchema = import_zod4.z.strictObject({
+  requestId: opaqueIdSchema2,
+  annotation: spotAnnotationRequestSchema
+});
+var externalHandoffStatusRequestSchema = import_zod4.z.strictObject({
+  cursor: opaqueIdSchema2.optional()
+});
+var externalHandoffResolveDeliveryRequestSchema = import_zod4.z.strictObject({
+  cursor: opaqueIdSchema2,
+  confirmation: import_zod4.z.literal("workspace-reviewed")
+});
+var externalHandoffCapabilitySchema = import_zod4.z.strictObject({
+  enabled: import_zod4.z.literal(true),
+  brokerReady: import_zod4.z.boolean(),
+  activeWaitCount: import_zod4.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
+  snapshotSchemaVersion: import_zod4.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  brokerProtocolVersion: import_zod4.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  activeAdapter: activeAdapterSummarySchema.nullable(),
+  dispatch: dispatchSummarySchema.nullable()
+});
+var externalHandoffPublishDeliverySchema = import_zod4.z.discriminatedUnion("mode", [
+  import_zod4.z.strictObject({ mode: import_zod4.z.literal("inbox") }),
+  import_zod4.z.strictObject({
+    mode: import_zod4.z.literal("active"),
+    adapter: activeAdapterSummarySchema,
+    dispatch: dispatchSummarySchema
+  })
+]);
+var externalHandoffPublishResultSchema = import_zod4.z.strictObject({
+  handoff: externalHandoffSummarySchema,
+  delivery: externalHandoffPublishDeliverySchema,
+  replayed: import_zod4.z.boolean()
+});
+var externalHandoffStatusResultSchema = import_zod4.z.strictObject({
+  handoff: externalHandoffSummarySchema,
+  activeAdapter: activeAdapterSummarySchema.nullable(),
+  dispatch: dispatchSummarySchema.nullable()
+});
+
 // src/protocol/agent-schemas.ts
-var import_zod4 = require("zod");
-var profileIdSchema3 = import_zod4.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString2 = (maximum) => import_zod4.z.string().max(maximum);
-var errorCodeSchema = import_zod4.z.enum(ERROR_CODES);
-var agentCapabilitySnapshotSchema = import_zod4.z.strictObject({
+var import_zod5 = require("zod");
+var profileIdSchema3 = import_zod5.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString2 = (maximum) => import_zod5.z.string().max(maximum);
+var errorCodeSchema = import_zod5.z.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = import_zod5.z.strictObject({
   providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
   modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
-  protocol: import_zod4.z.enum(["responses", "chat-completions"]),
-  state: import_zod4.z.enum(AGENT_CAPABILITY_STATES),
-  authenticated: import_zod4.z.boolean(),
-  modelAvailable: import_zod4.z.boolean(),
-  toolCalling: import_zod4.z.boolean(),
-  toolResultContinuation: import_zod4.z.boolean(),
-  streaming: import_zod4.z.boolean(),
-  checkedAt: import_zod4.z.iso.datetime().optional(),
+  protocol: import_zod5.z.enum(["responses", "chat-completions"]),
+  state: import_zod5.z.enum(AGENT_CAPABILITY_STATES),
+  authenticated: import_zod5.z.boolean(),
+  modelAvailable: import_zod5.z.boolean(),
+  toolCalling: import_zod5.z.boolean(),
+  toolResultContinuation: import_zod5.z.boolean(),
+  streaming: import_zod5.z.boolean(),
+  checkedAt: import_zod5.z.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-var agentWorkspaceHealthSnapshotSchema = import_zod4.z.strictObject({
-  state: import_zod4.z.enum(AGENT_WORKSPACE_STATES),
-  checkedAt: import_zod4.z.iso.datetime(),
-  changes: import_zod4.z.strictObject({
-    staged: import_zod4.z.number().int().nonnegative(),
-    unstaged: import_zod4.z.number().int().nonnegative(),
-    untracked: import_zod4.z.number().int().nonnegative(),
-    conflicted: import_zod4.z.number().int().nonnegative(),
-    total: import_zod4.z.number().int().nonnegative()
+var agentWorkspaceHealthSnapshotSchema = import_zod5.z.strictObject({
+  state: import_zod5.z.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: import_zod5.z.iso.datetime(),
+  changes: import_zod5.z.strictObject({
+    staged: import_zod5.z.number().int().nonnegative(),
+    unstaged: import_zod5.z.number().int().nonnegative(),
+    untracked: import_zod5.z.number().int().nonnegative(),
+    conflicted: import_zod5.z.number().int().nonnegative(),
+    total: import_zod5.z.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: import_zod4.z.boolean(),
+  canIncludeLocalChanges: import_zod5.z.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -1060,42 +1273,42 @@ var agentWorkspaceHealthSnapshotSchema = import_zod4.z.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = import_zod4.z.strictObject({
+var agentChangedFileSchema = import_zod5.z.strictObject({
   relativePath: boundedString2(1024),
-  kind: import_zod4.z.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: import_zod4.z.number().int().nonnegative(),
-  deletions: import_zod4.z.number().int().nonnegative()
+  kind: import_zod5.z.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: import_zod5.z.number().int().nonnegative(),
+  deletions: import_zod5.z.number().int().nonnegative()
 });
-var agentCheckResultSchema = import_zod4.z.strictObject({
+var agentCheckResultSchema = import_zod5.z.strictObject({
   checkId: profileIdSchema3,
   label: boundedString2(100),
-  status: import_zod4.z.enum(AGENT_CHECK_STATUSES),
-  durationMs: import_zod4.z.number().int().nonnegative(),
+  status: import_zod5.z.enum(AGENT_CHECK_STATUSES),
+  durationMs: import_zod5.z.number().int().nonnegative(),
   output: boundedString2(8e4)
 });
-var agentJobSnapshotSchema = import_zod4.z.strictObject({
-  jobId: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod4.z.enum(AGENT_JOB_STATUSES),
+var agentJobSnapshotSchema = import_zod5.z.strictObject({
+  jobId: import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod5.z.enum(AGENT_JOB_STATUSES),
   providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
   modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
   phaseMessage: boundedString2(1024),
-  createdAt: import_zod4.z.iso.datetime(),
-  updatedAt: import_zod4.z.iso.datetime(),
-  canCancel: import_zod4.z.boolean(),
-  canApply: import_zod4.z.boolean(),
-  canRevert: import_zod4.z.boolean(),
+  createdAt: import_zod5.z.iso.datetime(),
+  updatedAt: import_zod5.z.iso.datetime(),
+  canCancel: import_zod5.z.boolean(),
+  canApply: import_zod5.z.boolean(),
+  canRevert: import_zod5.z.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = import_zod4.z.strictObject({
-  jobId: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+var agentJobResultSchema = import_zod5.z.strictObject({
+  jobId: import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
   summary: boundedString2(8e4),
   diff: boundedString2(1e6),
-  files: import_zod4.z.array(agentChangedFileSchema).max(100),
-  checks: import_zod4.z.array(agentCheckResultSchema).max(100)
+  files: import_zod5.z.array(agentChangedFileSchema).max(100),
+  checks: import_zod5.z.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = import_zod4.z.strictObject({
+var agentJobResultResponseSchema = import_zod5.z.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -1107,44 +1320,44 @@ var agentJobResultResponseSchema = import_zod4.z.strictObject({
     });
   }
 });
-var agentJobEventBaseSchema = import_zod4.z.strictObject({
-  schemaVersion: import_zod4.z.literal(2),
-  sequence: import_zod4.z.number().int().positive(),
-  jobId: import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: import_zod4.z.enum(AGENT_JOB_STATUSES),
-  timestamp: import_zod4.z.iso.datetime()
+var agentJobEventBaseSchema = import_zod5.z.strictObject({
+  schemaVersion: import_zod5.z.literal(2),
+  sequence: import_zod5.z.number().int().positive(),
+  jobId: import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod5.z.enum(AGENT_JOB_STATUSES),
+  timestamp: import_zod5.z.iso.datetime()
 });
-var agentJobEventSchema = import_zod4.z.discriminatedUnion("type", [
+var agentJobEventSchema = import_zod5.z.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("snapshot"),
-    data: import_zod4.z.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: import_zod5.z.literal("snapshot"),
+    data: import_zod5.z.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("phase"),
-    data: import_zod4.z.strictObject({ message: boundedString2(1024) })
+    type: import_zod5.z.literal("phase"),
+    data: import_zod5.z.strictObject({ message: boundedString2(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("tool"),
-    data: import_zod4.z.strictObject({
-      turn: import_zod4.z.number().int().positive(),
+    type: import_zod5.z.literal("tool"),
+    data: import_zod5.z.strictObject({
+      turn: import_zod5.z.number().int().positive(),
       toolCallId: boundedString2(256),
       toolName: boundedString2(100),
-      state: import_zod4.z.enum(["started", "succeeded", "failed"]),
+      state: import_zod5.z.enum(["started", "succeeded", "failed"]),
       relativePath: boundedString2(1024).optional(),
       checkLabel: boundedString2(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("check"),
-    data: import_zod4.z.strictObject({ result: agentCheckResultSchema })
+    type: import_zod5.z.literal("check"),
+    data: import_zod5.z.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("result-ready"),
-    data: import_zod4.z.strictObject({ hasResult: import_zod4.z.literal(true) })
+    type: import_zod5.z.literal("result-ready"),
+    data: import_zod5.z.strictObject({ hasResult: import_zod5.z.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod4.z.literal("error"),
-    data: import_zod4.z.strictObject({
+    type: import_zod5.z.literal("error"),
+    data: import_zod5.z.strictObject({
       code: errorCodeSchema,
       message: boundedString2(1024)
     })
@@ -1197,6 +1410,16 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   DEFAULT_DATA_FLOW_LIMITS,
   DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
   ERROR_CODES,
+  ERROR_CODE_VALUES,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS,
+  EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES,
+  EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION,
+  EXTERNAL_HANDOFF_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_FRAMEWORKS,
+  EXTERNAL_HANDOFF_LIMITS,
+  EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES,
+  EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION,
+  EXTERNAL_HANDOFF_STATES,
   MAX_ANNOTATION_INSTRUCTION_CHARACTERS,
   MAX_ANNOTATION_TARGETS,
   MAX_TARGET_INSTRUCTION_CHARACTERS,
@@ -1211,6 +1434,7 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER,
   SpotPatchError,
+  activeAdapterSummarySchema,
   agentCapabilityRequestSchema,
   agentCapabilitySnapshotSchema,
   agentChangedFileSchema,
@@ -1227,8 +1451,21 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   dataDependencySchema,
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
+  dispatchSummarySchema,
+  externalHandoffCapabilityRequestSchema,
+  externalHandoffCapabilitySchema,
+  externalHandoffPublishDeliverySchema,
+  externalHandoffPublishRequestSchema,
+  externalHandoffPublishResultSchema,
+  externalHandoffReportableDispatchPhaseSchema,
+  externalHandoffResolveDeliveryRequestSchema,
+  externalHandoffSnapshotSchema,
+  externalHandoffStatusRequestSchema,
+  externalHandoffStatusResultSchema,
+  externalHandoffSummarySchema,
   formatSourceMarker,
   getAgentJobEndpoint,
+  isErrorCode,
   isSensitiveName,
   limitDataFlowReportCollections,
   networkObservationSchema,