@spotpatch/shared 1.9.0 → 1.10.0

package/dist/index.js

@@ -2,62 +2,68 @@ import {
   DATA_FLOW_SCHEMA_VERSION,
   DATA_FLOW_URL_QUERY_KEY_LIMIT,
   DEFAULT_DATA_FLOW_LIMITS,
-  DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
+  DEFAULT_RUNTIME_DATA_FLOW_LIMITS
+} from "./chunk-RK46Y7LD.js";
+import {
+  AGENT_APPLY_MODES,
+  AGENT_CAPABILITY_STATES,
+  AGENT_CHECK_STATUSES,
+  AGENT_FILE_CHANGE_KINDS,
+  AGENT_JOB_STATUSES,
+  AGENT_WORKSPACE_SNAPSHOT_LIMITS,
+  AGENT_WORKSPACE_STATES,
+  DEFAULT_AGENT_LIMITS,
+  ERROR_CODES,
+  ERROR_CODE_VALUES,
+  MAX_ANNOTATION_INSTRUCTION_CHARACTERS,
+  MAX_ANNOTATION_TARGETS,
+  MAX_TARGET_INSTRUCTION_CHARACTERS,
+  SPOTPATCH_LOCALES,
+  SPOTPATCH_LOCALE_PREFERENCES,
+  SpotPatchError,
+  activeAdapterSummarySchema,
+  agentCapabilityRequestSchema,
+  agentJobActionRequestSchema,
+  agentJobCreateRequestSchema,
+  agentWorkspaceHealthRequestSchema,
+  dataFlowComponentReportRequestSchema,
+  dataFlowPageReportRequestSchema,
+  dispatchSummarySchema,
+  externalHandoffCapabilityRequestSchema,
+  externalHandoffCapabilitySchema,
+  externalHandoffPublishDeliverySchema,
+  externalHandoffPublishRequestSchema,
+  externalHandoffPublishResultSchema,
+  externalHandoffReportableDispatchPhaseSchema,
+  externalHandoffResolveDeliveryRequestSchema,
+  externalHandoffSnapshotSchema,
+  externalHandoffStatusRequestSchema,
+  externalHandoffStatusResultSchema,
+  externalHandoffSummarySchema,
+  isErrorCode,
+  openEditorRequestSchema,
+  runtimeBootstrapRequestSchema,
+  sourceContextRequestSchema,
+  spotAnnotationRequestSchema,
+  spotTargetContextRequestSchema
+} from "./chunk-MOGITGPP.js";
+import {
   SPOTPATCH_API_BASE,
   SPOTPATCH_ENDPOINTS,
   SPOTPATCH_TOKEN_HEADER,
   getAgentJobEndpoint
-} from "./chunk-K2UAPG7T.js";
-
-// src/errors/spotpatch-error.ts
-var SpotPatchError = class extends Error {
-  code;
-  constructor(code, message = code, options) {
-    super(message, options);
-    this.name = "SpotPatchError";
-    this.code = code;
-  }
-};
-
-// src/errors/error-code.ts
-var ERROR_CODES = {
-  INVALID_REQUEST: "INVALID_REQUEST",
-  INVALID_TOKEN: "INVALID_TOKEN",
-  ORIGIN_NOT_ALLOWED: "ORIGIN_NOT_ALLOWED",
-  SOURCE_NOT_FOUND: "SOURCE_NOT_FOUND",
-  SOURCE_OUTSIDE_ROOT: "SOURCE_OUTSIDE_ROOT",
-  SOURCE_TOO_LARGE: "SOURCE_TOO_LARGE",
-  EDITOR_OPEN_FAILED: "EDITOR_OPEN_FAILED",
-  DATA_FLOW_DISABLED: "DATA_FLOW_DISABLED",
-  DATA_FLOW_SOURCE_STALE: "DATA_FLOW_SOURCE_STALE",
-  DATA_FLOW_ANALYSIS_CANCELLED: "DATA_FLOW_ANALYSIS_CANCELLED",
-  AI_DISABLED: "AI_DISABLED",
-  PROVIDER_NOT_CONFIGURED: "PROVIDER_NOT_CONFIGURED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_PROTOCOL_UNSUPPORTED: "PROVIDER_PROTOCOL_UNSUPPORTED",
-  MODEL_NOT_ALLOWED: "MODEL_NOT_ALLOWED",
-  MODEL_TOOL_CALL_UNSUPPORTED: "MODEL_TOOL_CALL_UNSUPPORTED",
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  AGENT_BUSY: "AGENT_BUSY",
-  AGENT_LIMIT_EXCEEDED: "AGENT_LIMIT_EXCEEDED",
-  AGENT_CANCELLED: "AGENT_CANCELLED",
-  WORKTREE_DIRTY: "WORKTREE_DIRTY",
-  WORKTREE_NOT_REPOSITORY: "WORKTREE_NOT_REPOSITORY",
-  WORKTREE_OPERATION_IN_PROGRESS: "WORKTREE_OPERATION_IN_PROGRESS",
-  WORKTREE_CONFLICTED: "WORKTREE_CONFLICTED",
-  WORKTREE_LOCAL_CHANGES_TOO_LARGE: "WORKTREE_LOCAL_CHANGES_TOO_LARGE",
-  WORKTREE_UNTRACKED_UNSUPPORTED: "WORKTREE_UNTRACKED_UNSUPPORTED",
-  WORKTREE_LOCAL_CHANGES_UNSUPPORTED: "WORKTREE_LOCAL_CHANGES_UNSUPPORTED",
-  TOOL_DENIED: "TOOL_DENIED",
-  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
-  TOOL_ARGUMENTS_INVALID: "TOOL_ARGUMENTS_INVALID",
-  TOOL_CALL_ID_CONFLICT: "TOOL_CALL_ID_CONFLICT",
-  TOOL_PATH_DENIED: "TOOL_PATH_DENIED",
-  PATCH_REJECTED: "PATCH_REJECTED",
-  VALIDATION_FAILED: "VALIDATION_FAILED",
-  APPLY_CONFLICT: "APPLY_CONFLICT",
-  INTERNAL_ERROR: "INTERNAL_ERROR"
-};
+} from "./chunk-ZCG3DLSW.js";
+import {
+  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
+} from "./chunk-2LVIH7OA.js";
 
 // src/security/redaction.ts
 var INLINE_DATA_PATTERN = /data:[^\s"'<>]*;base64,[a-z0-9+/_=-]+/giu;
@@ -128,16 +134,6 @@ function sanitizeUrl(value, baseUrl) {
   }
 }
 
-// src/model/annotation.ts
-var MAX_ANNOTATION_TARGETS = 20;
-var MAX_TARGET_INSTRUCTION_CHARACTERS = 2e3;
-var MAX_ANNOTATION_INSTRUCTION_CHARACTERS = 4e3;
-var SPOTPATCH_LOCALES = Object.freeze(["en-US", "zh-CN"]);
-var SPOTPATCH_LOCALE_PREFERENCES = Object.freeze([
-  "auto",
-  ...SPOTPATCH_LOCALES
-]);
-
 // src/model/data-flow-adapters.ts
 var DATA_FLOW_QUERY_ADAPTER_MODULES = Object.freeze([
   "@tanstack/react-query",
@@ -591,69 +587,6 @@ import { z as z2 } from "zod";
 // src/model/editor.ts
 var SPOTPATCH_EDITOR_PREFERENCES = ["auto", "vscode", "cursor"];
 
-// src/model/agent.ts
-var AGENT_APPLY_MODES = Object.freeze([
-  "review",
-  "auto",
-  "trusted-auto"
-]);
-var DEFAULT_AGENT_LIMITS = Object.freeze({
-  maxTurns: 20,
-  maxToolCalls: 80,
-  maxChangedFiles: 20,
-  maxDiffBytes: 512e3,
-  maxReadBytesPerFile: 256e3,
-  maxToolOutputCharacters: 4e4,
-  maxProviderResponseBytes: 2e6,
-  providerConnectTimeoutMs: 15e3,
-  providerFirstByteTimeoutMs: 3e4,
-  providerIdleTimeoutMs: 6e4,
-  checkTimeoutMs: 12e4,
-  jobTimeoutMs: 6e5
-});
-var AGENT_JOB_STATUSES = Object.freeze([
-  "queued",
-  "preparing",
-  "running",
-  "validating",
-  "awaiting-review",
-  "applying",
-  "applied",
-  "completed",
-  "cancelling",
-  "cancelled",
-  "reverting",
-  "reverted",
-  "failed"
-]);
-var AGENT_CAPABILITY_STATES = Object.freeze([
-  "unknown",
-  "probing",
-  "agent-ready",
-  "prompt-only",
-  "unavailable"
-]);
-var AGENT_WORKSPACE_STATES = Object.freeze([
-  "ready",
-  "consent-required",
-  "blocked"
-]);
-var AGENT_WORKSPACE_SNAPSHOT_LIMITS = Object.freeze({
-  maxUntrackedFiles: 1e3,
-  maxUntrackedBytes: 20 * 1024 * 1024
-});
-var AGENT_FILE_CHANGE_KINDS = Object.freeze([
-  "added",
-  "modified",
-  "deleted"
-]);
-var AGENT_CHECK_STATUSES = Object.freeze([
-  "passed",
-  "failed",
-  "cancelled",
-  "timed-out"
-]);
-
 // src/model/runtime-config.ts
 var SPOTPATCH_NEXT_BUNDLERS = Object.freeze(["turbopack", "webpack"]);
 var SPOTPATCH_NEXT_ROUTER_KINDS = Object.freeze([
@@ -704,6 +637,7 @@ var runtimeConfigBaseShape = {
   debug: z2.boolean(),
   dataFlow: runtimeDataFlowConfigSchema,
   editor: z2.enum(SPOTPATCH_EDITOR_PREFERENCES),
+  externalAgent: z2.strictObject({ enabled: z2.boolean() }),
   frameworkVersion: boundedText2(64),
   locale: z2.enum(SPOTPATCH_LOCALE_PREFERENCES),
   maxTargets: z2.number().int().min(1).max(MAX_ANNOTATION_TARGETS),
@@ -749,170 +683,37 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
-// src/protocol/requests.ts
+// src/protocol/agent-schemas.ts
 import { z as z3 } from "zod";
-var runtimeBootstrapRequestSchema = z3.strictObject({});
-var sourceCoordinatesSchema = z3.strictObject({
-  fileId: z3.string().min(1).max(128),
-  line: z3.number().int().positive(),
-  column: z3.number().int().positive()
-});
-var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: z3.number().int().positive()
-}).strict();
-var openEditorRequestSchema = sourceCoordinatesSchema.strict();
-var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
-  schemaVersion: z3.literal(1),
-  sourceVersion: z3.string().min(1).max(128).optional()
-}).strict();
-var dataFlowComponentIdentityRequestSchema = z3.strictObject({
-  schemaVersion: z3.literal(1),
-  componentSourceId: z3.string().min(1).max(128),
-  sourceVersion: z3.string().min(1).max(128)
-});
-var dataFlowComponentReportRequestSchema = z3.union([
-  dataFlowSourceCoordinatesRequestSchema,
-  dataFlowComponentIdentityRequestSchema
-]);
-var dataFlowPageReportRequestSchema = z3.strictObject({
-  schemaVersion: z3.literal(1),
-  targets: z3.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
-});
 var profileIdSchema2 = z3.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
 var boundedString = (maximum) => z3.string().max(maximum);
-var sourceRefSchema = z3.strictObject({
-  fileId: boundedString(128).optional(),
-  relativePath: boundedString(1024).optional(),
-  line: z3.number().int().positive().optional(),
-  column: z3.number().int().positive().optional(),
-  origin: z3.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
-  confidence: z3.enum(["exact", "probable", "approximate", "unknown"])
-});
-var matchedStyleRuleSchema = z3.strictObject({
-  selector: boundedString(2048),
-  declarations: boundedString(8192),
-  source: boundedString(1024).optional(),
-  media: boundedString(1024).optional()
-});
-var codeContextSchema = z3.strictObject({
-  relativePath: boundedString(1024),
-  language: z3.enum(["tsx", "jsx"]),
-  startLine: z3.number().int().positive(),
-  endLine: z3.number().int().positive(),
-  excerpt: boundedString(16e3),
-  boundary: z3.enum(["component", "nearby-lines"])
-});
-var pageContextSchema = z3.strictObject({
-  url: boundedString(2048),
-  pathname: boundedString(2048),
-  title: boundedString(1024),
-  viewportWidth: z3.number().nonnegative(),
-  viewportHeight: z3.number().nonnegative(),
-  devicePixelRatio: z3.number().positive()
-});
-var spotTargetContextRequestSchema = z3.strictObject({
-  instruction: z3.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
-  page: pageContextSchema.optional(),
-  source: sourceRefSchema,
-  react: z3.strictObject({
-    supported: z3.boolean(),
-    version: boundedString(64).optional(),
-    componentName: boundedString(256).optional(),
-    componentSourceId: boundedString(128).optional(),
-    sourceVersion: boundedString(128).optional(),
-    componentStack: z3.array(boundedString(256)).max(64),
-    source: sourceRefSchema.optional()
-  }),
-  element: z3.strictObject({
-    tagName: boundedString(128),
-    selector: boundedString(2048),
-    sanitizedHtml: boundedString(8192),
-    textPreview: boundedString(2048).optional(),
-    role: boundedString(256).optional(),
-    rect: z3.strictObject({
-      x: z3.number(),
-      y: z3.number(),
-      width: z3.number().nonnegative(),
-      height: z3.number().nonnegative()
-    })
-  }),
-  styles: z3.strictObject({
-    classNames: z3.array(boundedString(512)).max(256),
-    inlineStyle: boundedString(8192).optional(),
-    matchedRules: z3.array(matchedStyleRuleSchema).max(256),
-    computed: z3.record(boundedString(256), boundedString(2048)),
-    warnings: z3.array(boundedString(1024)).max(64)
-  }),
-  code: codeContextSchema.optional(),
-  warnings: z3.array(boundedString(1024)).max(64)
-});
-var spotAnnotationRequestSchema = z3.strictObject({
-  schemaVersion: z3.literal(3),
-  id: boundedString(128),
-  locale: z3.enum(SPOTPATCH_LOCALES),
-  page: pageContextSchema,
-  targets: z3.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
-  createdAt: z3.iso.datetime()
-}).superRefine((annotation, context) => {
-  const total = annotation.targets.reduce(
-    (characters, target) => characters + target.instruction.length,
-    0
-  );
-  if (total > MAX_ANNOTATION_INSTRUCTION_CHARACTERS) {
-    context.addIssue({
-      code: "custom",
-      message: "Combined target instructions exceed the annotation limit.",
-      path: ["targets"]
-    });
-  }
-});
-var agentCapabilityRequestSchema = z3.strictObject({
-  providerProfileId: profileIdSchema2,
-  modelProfileId: profileIdSchema2
-});
-var agentWorkspaceHealthRequestSchema = z3.strictObject({});
-var agentJobCreateRequestSchema = z3.strictObject({
-  annotation: spotAnnotationRequestSchema,
-  applyMode: z3.enum(AGENT_APPLY_MODES).optional(),
+var errorCodeSchema = z3.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = z3.strictObject({
   providerProfileId: profileIdSchema2,
+  providerLabel: boundedString(100),
   modelProfileId: profileIdSchema2,
-  providerDataConsent: z3.literal(true),
-  trustedFastModeConsent: z3.literal(true).optional(),
-  workingTreeMode: z3.enum(["require-clean", "include-local-changes"]).default("require-clean")
-});
-var agentJobActionRequestSchema = z3.strictObject({});
-
-// src/protocol/agent-schemas.ts
-import { z as z4 } from "zod";
-var profileIdSchema3 = z4.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString2 = (maximum) => z4.string().max(maximum);
-var errorCodeSchema = z4.enum(ERROR_CODES);
-var agentCapabilitySnapshotSchema = z4.strictObject({
-  providerProfileId: profileIdSchema3,
-  providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema3,
-  modelLabel: boundedString2(100),
-  protocol: z4.enum(["responses", "chat-completions"]),
-  state: z4.enum(AGENT_CAPABILITY_STATES),
-  authenticated: z4.boolean(),
-  modelAvailable: z4.boolean(),
-  toolCalling: z4.boolean(),
-  toolResultContinuation: z4.boolean(),
-  streaming: z4.boolean(),
-  checkedAt: z4.iso.datetime().optional(),
+  modelLabel: boundedString(100),
+  protocol: z3.enum(["responses", "chat-completions"]),
+  state: z3.enum(AGENT_CAPABILITY_STATES),
+  authenticated: z3.boolean(),
+  modelAvailable: z3.boolean(),
+  toolCalling: z3.boolean(),
+  toolResultContinuation: z3.boolean(),
+  streaming: z3.boolean(),
+  checkedAt: z3.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-var agentWorkspaceHealthSnapshotSchema = z4.strictObject({
-  state: z4.enum(AGENT_WORKSPACE_STATES),
-  checkedAt: z4.iso.datetime(),
-  changes: z4.strictObject({
-    staged: z4.number().int().nonnegative(),
-    unstaged: z4.number().int().nonnegative(),
-    untracked: z4.number().int().nonnegative(),
-    conflicted: z4.number().int().nonnegative(),
-    total: z4.number().int().nonnegative()
+var agentWorkspaceHealthSnapshotSchema = z3.strictObject({
+  state: z3.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: z3.iso.datetime(),
+  changes: z3.strictObject({
+    staged: z3.number().int().nonnegative(),
+    unstaged: z3.number().int().nonnegative(),
+    untracked: z3.number().int().nonnegative(),
+    conflicted: z3.number().int().nonnegative(),
+    total: z3.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: z4.boolean(),
+  canIncludeLocalChanges: z3.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -930,42 +731,42 @@ var agentWorkspaceHealthSnapshotSchema = z4.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = z4.strictObject({
-  relativePath: boundedString2(1024),
-  kind: z4.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: z4.number().int().nonnegative(),
-  deletions: z4.number().int().nonnegative()
-});
-var agentCheckResultSchema = z4.strictObject({
-  checkId: profileIdSchema3,
-  label: boundedString2(100),
-  status: z4.enum(AGENT_CHECK_STATUSES),
-  durationMs: z4.number().int().nonnegative(),
-  output: boundedString2(8e4)
-});
-var agentJobSnapshotSchema = z4.strictObject({
-  jobId: z4.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: z4.enum(AGENT_JOB_STATUSES),
-  providerProfileId: profileIdSchema3,
-  providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema3,
-  modelLabel: boundedString2(100),
-  phaseMessage: boundedString2(1024),
-  createdAt: z4.iso.datetime(),
-  updatedAt: z4.iso.datetime(),
-  canCancel: z4.boolean(),
-  canApply: z4.boolean(),
-  canRevert: z4.boolean(),
+var agentChangedFileSchema = z3.strictObject({
+  relativePath: boundedString(1024),
+  kind: z3.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: z3.number().int().nonnegative(),
+  deletions: z3.number().int().nonnegative()
+});
+var agentCheckResultSchema = z3.strictObject({
+  checkId: profileIdSchema2,
+  label: boundedString(100),
+  status: z3.enum(AGENT_CHECK_STATUSES),
+  durationMs: z3.number().int().nonnegative(),
+  output: boundedString(8e4)
+});
+var agentJobSnapshotSchema = z3.strictObject({
+  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: z3.enum(AGENT_JOB_STATUSES),
+  providerProfileId: profileIdSchema2,
+  providerLabel: boundedString(100),
+  modelProfileId: profileIdSchema2,
+  modelLabel: boundedString(100),
+  phaseMessage: boundedString(1024),
+  createdAt: z3.iso.datetime(),
+  updatedAt: z3.iso.datetime(),
+  canCancel: z3.boolean(),
+  canApply: z3.boolean(),
+  canRevert: z3.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = z4.strictObject({
-  jobId: z4.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  summary: boundedString2(8e4),
-  diff: boundedString2(1e6),
-  files: z4.array(agentChangedFileSchema).max(100),
-  checks: z4.array(agentCheckResultSchema).max(100)
+var agentJobResultSchema = z3.strictObject({
+  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  summary: boundedString(8e4),
+  diff: boundedString(1e6),
+  files: z3.array(agentChangedFileSchema).max(100),
+  checks: z3.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = z4.strictObject({
+var agentJobResultResponseSchema = z3.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -977,46 +778,46 @@ var agentJobResultResponseSchema = z4.strictObject({
     });
   }
 });
-var agentJobEventBaseSchema = z4.strictObject({
-  schemaVersion: z4.literal(2),
-  sequence: z4.number().int().positive(),
-  jobId: z4.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: z4.enum(AGENT_JOB_STATUSES),
-  timestamp: z4.iso.datetime()
+var agentJobEventBaseSchema = z3.strictObject({
+  schemaVersion: z3.literal(2),
+  sequence: z3.number().int().positive(),
+  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: z3.enum(AGENT_JOB_STATUSES),
+  timestamp: z3.iso.datetime()
 });
-var agentJobEventSchema = z4.discriminatedUnion("type", [
+var agentJobEventSchema = z3.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: z4.literal("snapshot"),
-    data: z4.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: z3.literal("snapshot"),
+    data: z3.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: z4.literal("phase"),
-    data: z4.strictObject({ message: boundedString2(1024) })
+    type: z3.literal("phase"),
+    data: z3.strictObject({ message: boundedString(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: z4.literal("tool"),
-    data: z4.strictObject({
-      turn: z4.number().int().positive(),
-      toolCallId: boundedString2(256),
-      toolName: boundedString2(100),
-      state: z4.enum(["started", "succeeded", "failed"]),
-      relativePath: boundedString2(1024).optional(),
-      checkLabel: boundedString2(100).optional()
+    type: z3.literal("tool"),
+    data: z3.strictObject({
+      turn: z3.number().int().positive(),
+      toolCallId: boundedString(256),
+      toolName: boundedString(100),
+      state: z3.enum(["started", "succeeded", "failed"]),
+      relativePath: boundedString(1024).optional(),
+      checkLabel: boundedString(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: z4.literal("check"),
-    data: z4.strictObject({ result: agentCheckResultSchema })
+    type: z3.literal("check"),
+    data: z3.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: z4.literal("result-ready"),
-    data: z4.strictObject({ hasResult: z4.literal(true) })
+    type: z3.literal("result-ready"),
+    data: z3.strictObject({ hasResult: z3.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: z4.literal("error"),
-    data: z4.strictObject({
+    type: z3.literal("error"),
+    data: z3.strictObject({
       code: errorCodeSchema,
-      message: boundedString2(1024)
+      message: boundedString(1024)
     })
   })
 ]).superRefine((event, context) => {
@@ -1066,6 +867,16 @@ export {
   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,
@@ -1080,6 +891,7 @@ export {
   SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER,
   SpotPatchError,
+  activeAdapterSummarySchema,
   agentCapabilityRequestSchema,
   agentCapabilitySnapshotSchema,
   agentChangedFileSchema,
@@ -1096,8 +908,21 @@ export {
   dataDependencySchema,
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
+  dispatchSummarySchema,
+  externalHandoffCapabilityRequestSchema,
+  externalHandoffCapabilitySchema,
+  externalHandoffPublishDeliverySchema,
+  externalHandoffPublishRequestSchema,
+  externalHandoffPublishResultSchema,
+  externalHandoffReportableDispatchPhaseSchema,
+  externalHandoffResolveDeliveryRequestSchema,
+  externalHandoffSnapshotSchema,
+  externalHandoffStatusRequestSchema,
+  externalHandoffStatusResultSchema,
+  externalHandoffSummarySchema,
   formatSourceMarker,
   getAgentJobEndpoint,
+  isErrorCode,
   isSensitiveName,
   limitDataFlowReportCollections,
   networkObservationSchema,