@spotpatch/shared 1.10.0 → 1.11.0

package/dist/index.cjs

@@ -45,6 +45,22 @@ __export(index_exports, {
   DEFAULT_RUNTIME_DATA_FLOW_LIMITS: () => DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
   ERROR_CODES: () => ERROR_CODES,
   ERROR_CODE_VALUES: () => ERROR_CODE_VALUES,
+  EXTERNAL_AGENT_ACTIONS: () => EXTERNAL_AGENT_ACTIONS,
+  EXTERNAL_AGENT_AUTH_READINESS: () => EXTERNAL_AGENT_AUTH_READINESS,
+  EXTERNAL_AGENT_CONNECTION_STATES: () => EXTERNAL_AGENT_CONNECTION_STATES,
+  EXTERNAL_AGENT_CONTROL_LIMITS: () => EXTERNAL_AGENT_CONTROL_LIMITS,
+  EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION: () => EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+  EXTERNAL_AGENT_DELIVERY_STATUSES: () => EXTERNAL_AGENT_DELIVERY_STATUSES,
+  EXTERNAL_AGENT_ERROR_CODES: () => EXTERNAL_AGENT_ERROR_CODES,
+  EXTERNAL_AGENT_ERROR_RECOVERABILITY: () => EXTERNAL_AGENT_ERROR_RECOVERABILITY,
+  EXTERNAL_AGENT_ERROR_STAGES: () => EXTERNAL_AGENT_ERROR_STAGES,
+  EXTERNAL_AGENT_EXECUTION_STATUSES: () => EXTERNAL_AGENT_EXECUTION_STATUSES,
+  EXTERNAL_AGENT_GRANT_STATES: () => EXTERNAL_AGENT_GRANT_STATES,
+  EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS: () => EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS,
+  EXTERNAL_AGENT_MANAGED_PHASES: () => EXTERNAL_AGENT_MANAGED_PHASES,
+  EXTERNAL_AGENT_MANAGED_PROFILE: () => EXTERNAL_AGENT_MANAGED_PROFILE,
+  EXTERNAL_AGENT_MODES: () => EXTERNAL_AGENT_MODES,
+  EXTERNAL_AGENT_VALIDATION_OUTCOMES: () => EXTERNAL_AGENT_VALIDATION_OUTCOMES,
   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,
@@ -86,6 +102,16 @@ __export(index_exports, {
   dataFlowComponentReportRequestSchema: () => dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema: () => dataFlowPageReportRequestSchema,
   dispatchSummarySchema: () => dispatchSummarySchema,
+  externalAgentControlCancelRequestSchema: () => externalAgentControlCancelRequestSchema,
+  externalAgentControlConnectRequestSchema: () => externalAgentControlConnectRequestSchema,
+  externalAgentControlDisconnectRequestSchema: () => externalAgentControlDisconnectRequestSchema,
+  externalAgentControlStatusRequestSchema: () => externalAgentControlStatusRequestSchema,
+  externalAgentControlStatusSchema: () => externalAgentControlStatusSchema,
+  externalAgentErrorSchema: () => externalAgentErrorSchema,
+  externalAgentEventSchema: () => externalAgentEventSchema,
+  externalAgentEventsRequestSchema: () => externalAgentEventsRequestSchema,
+  externalAgentManagedResultSchema: () => externalAgentManagedResultSchema,
+  externalAgentResultRequestSchema: () => externalAgentResultRequestSchema,
   externalHandoffCapabilityRequestSchema: () => externalHandoffCapabilityRequestSchema,
   externalHandoffCapabilitySchema: () => externalHandoffCapabilitySchema,
   externalHandoffPublishDeliverySchema: () => externalHandoffPublishDeliverySchema,
@@ -102,6 +128,10 @@ __export(index_exports, {
   isErrorCode: () => isErrorCode,
   isSensitiveName: () => isSensitiveName,
   limitDataFlowReportCollections: () => limitDataFlowReportCollections,
+  managedCheckSummarySchema: () => managedCheckSummarySchema,
+  managedFileSummarySchema: () => managedFileSummarySchema,
+  managedTaskStatusSchema: () => managedTaskStatusSchema,
+  managedTimingSummarySchema: () => managedTimingSummarySchema,
   networkObservationSchema: () => networkObservationSchema,
   openEditorRequestSchema: () => openEditorRequestSchema,
   pageDataFlowReportSchema: () => pageDataFlowReportSchema,
@@ -762,7 +792,13 @@ var SPOTPATCH_ENDPOINTS = Object.freeze({
   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`
+  externalHandoffResolveDelivery: `${SPOTPATCH_API_BASE}/external-handoff/resolve-delivery`,
+  externalAgentControlStatus: `${SPOTPATCH_API_BASE}/external-agent/control/status`,
+  externalAgentControlConnect: `${SPOTPATCH_API_BASE}/external-agent/control/connect`,
+  externalAgentControlDisconnect: `${SPOTPATCH_API_BASE}/external-agent/control/disconnect`,
+  externalAgentControlCancel: `${SPOTPATCH_API_BASE}/external-agent/control/cancel`,
+  externalAgentEvents: `${SPOTPATCH_API_BASE}/external-agent/events`,
+  externalAgentResult: `${SPOTPATCH_API_BASE}/external-agent/result`
 });
 function getAgentJobEndpoint(jobId, action) {
   return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
@@ -930,113 +966,345 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
+// src/protocol/external-agent-control.ts
+var import_zod3 = require("zod");
+var EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION = 1;
+var EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS = Object.freeze(["codex"]);
+var EXTERNAL_AGENT_MODES = Object.freeze(["inbox", "managed"]);
+var EXTERNAL_AGENT_CONNECTION_STATES = Object.freeze([
+  "disconnected",
+  "diagnosing",
+  "awaiting-consent",
+  "connecting",
+  "ready",
+  "busy",
+  "degraded",
+  "error",
+  "disconnecting"
+]);
+var EXTERNAL_AGENT_AUTH_READINESS = Object.freeze([
+  "authenticated",
+  "auth-not-required",
+  "signed-out",
+  "unknown"
+]);
+var EXTERNAL_AGENT_GRANT_STATES = Object.freeze([
+  "missing",
+  "valid",
+  "invalid"
+]);
+var EXTERNAL_AGENT_DELIVERY_STATUSES = Object.freeze([
+  "queued",
+  "dispatching",
+  "accepted",
+  "unknown"
+]);
+var EXTERNAL_AGENT_EXECUTION_STATUSES = Object.freeze([
+  "not-observable",
+  "started",
+  "terminal-succeeded",
+  "terminal-failed",
+  "interrupted",
+  "unknown"
+]);
+var EXTERNAL_AGENT_MANAGED_PHASES = Object.freeze([
+  "preparing",
+  "running",
+  "auditing",
+  "validating",
+  "applying",
+  "completed",
+  "review-required",
+  "failed",
+  "cancelled",
+  "cleanup-warning"
+]);
+var EXTERNAL_AGENT_VALIDATION_OUTCOMES = Object.freeze([
+  "passed",
+  "failed",
+  "not-configured",
+  "unavailable"
+]);
+var EXTERNAL_AGENT_CHECK_OUTCOMES = Object.freeze([
+  "passed",
+  "failed",
+  "unavailable"
+]);
+var EXTERNAL_AGENT_ERROR_STAGES = Object.freeze([
+  "integration",
+  "binary",
+  "handshake",
+  "auth",
+  "model",
+  "protocol",
+  "snapshot",
+  "audit",
+  "validation",
+  "apply",
+  "cleanup"
+]);
+var EXTERNAL_AGENT_ERROR_RECOVERABILITY = Object.freeze([
+  "retry",
+  "user-action",
+  "reconfigure",
+  "none"
+]);
+var EXTERNAL_AGENT_ERROR_CODES = Object.freeze([
+  "AGENT_BINARY_NOT_FOUND",
+  "AGENT_BINARY_UNTRUSTED",
+  "AGENT_VERSION_UNSUPPORTED",
+  "APP_SERVER_HANDSHAKE_FAILED",
+  "AGENT_AUTH_REQUIRED",
+  "AGENT_MODEL_UNAVAILABLE",
+  "AGENT_PROTOCOL_INCOMPATIBLE",
+  "CODEX_CONFIG_ISOLATION_UNSUPPORTED",
+  "MANAGED_GRANT_INVALID",
+  "MANAGED_PLATFORM_UNSUPPORTED",
+  "MANAGED_GIT_REQUIRED",
+  "MANAGED_SNAPSHOT_FAILED",
+  "MANAGED_SCOPE_VIOLATION",
+  "MANAGED_CHANGE_LIMIT_EXCEEDED",
+  "MANAGED_VALIDATION_FAILED",
+  "MANAGED_WORKSPACE_CONFLICT",
+  "MANAGED_APPLY_FAILED",
+  "MANAGED_CLEANUP_INCOMPLETE"
+]);
+var EXTERNAL_AGENT_ACTIONS = Object.freeze([
+  "install-agent",
+  "use-supported-version",
+  "sign-in",
+  "choose-available-model",
+  "use-inbox",
+  "confirm-managed-access",
+  "review-candidate-diff",
+  "review-workspace-conflict",
+  "retry",
+  "inspect-cleanup-warning"
+]);
+var EXTERNAL_AGENT_MANAGED_PROFILE = "managed-apply-v1";
+var EXTERNAL_AGENT_CONTROL_LIMITS = Object.freeze({
+  maximumEventSubscribers: 4,
+  eventHeartbeatMs: 15e3,
+  eventReconnectMinimumMs: 500,
+  eventReconnectMaximumMs: 1e4,
+  maximumChangedFiles: DEFAULT_AGENT_LIMITS.maxChangedFiles,
+  maximumChecks: 64,
+  maximumEventLineBytes: 64 * 1024,
+  maximumResultDiffBytes: DEFAULT_AGENT_LIMITS.maxDiffBytes
+});
+var isoTimestampSchema = import_zod3.z.iso.datetime();
+var requestIdSchema = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var safeRelativePathSchema = import_zod3.z.string().min(1).max(4096).superRefine((value, context) => {
+  const segments = value.split("/");
+  if (value.startsWith("/") || value.includes("\\") || segments.some(
+    (segment) => segment.length === 0 || segment === "." || segment === ".."
+  )) {
+    context.addIssue({ code: "custom", message: "Expected a safe relative path." });
+  }
+});
+var externalAgentErrorSchema = import_zod3.z.strictObject({
+  code: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_CODES),
+  stage: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_STAGES),
+  recoverability: import_zod3.z.enum(EXTERNAL_AGENT_ERROR_RECOVERABILITY),
+  action: import_zod3.z.enum(EXTERNAL_AGENT_ACTIONS)
+});
+var managedFileSummarySchema = import_zod3.z.strictObject({
+  path: safeRelativePathSchema,
+  additions: import_zod3.z.number().int().nonnegative(),
+  deletions: import_zod3.z.number().int().nonnegative()
+});
+var managedCheckSummarySchema = import_zod3.z.strictObject({
+  id: import_zod3.z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/u),
+  outcome: import_zod3.z.enum(EXTERNAL_AGENT_CHECK_OUTCOMES),
+  durationMs: import_zod3.z.number().int().nonnegative(),
+  exitCode: import_zod3.z.number().int().optional()
+});
+var managedTimingSummarySchema = import_zod3.z.strictObject({
+  preparing: import_zod3.z.number().int().nonnegative().optional(),
+  agent: import_zod3.z.number().int().nonnegative().optional(),
+  auditing: import_zod3.z.number().int().nonnegative().optional(),
+  validating: import_zod3.z.number().int().nonnegative().optional(),
+  applying: import_zod3.z.number().int().nonnegative().optional(),
+  total: import_zod3.z.number().int().nonnegative().optional()
+});
+var managedTaskStatusSchema = import_zod3.z.strictObject({
+  revision: import_zod3.z.number().int().positive(),
+  deliveryStatus: import_zod3.z.enum(EXTERNAL_AGENT_DELIVERY_STATUSES),
+  executionStatus: import_zod3.z.enum(EXTERNAL_AGENT_EXECUTION_STATUSES),
+  managedPhase: import_zod3.z.enum(EXTERNAL_AGENT_MANAGED_PHASES),
+  validationOutcome: import_zod3.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES).optional(),
+  files: import_zod3.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: import_zod3.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  resultExpiresAt: isoTimestampSchema.optional()
+});
+var externalAgentControlStatusSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION),
+  sequence: import_zod3.z.number().int().nonnegative(),
+  mode: import_zod3.z.enum(EXTERNAL_AGENT_MODES),
+  adapter: import_zod3.z.strictObject({
+    kind: import_zod3.z.enum(EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS),
+    maturity: import_zod3.z.literal("experimental"),
+    availability: import_zod3.z.enum(["available", "unavailable"])
+  }),
+  connectionState: import_zod3.z.enum(EXTERNAL_AGENT_CONNECTION_STATES),
+  authReadiness: import_zod3.z.enum(EXTERNAL_AGENT_AUTH_READINESS),
+  grantState: import_zod3.z.enum(EXTERNAL_AGENT_GRANT_STATES),
+  requestedModel: import_zod3.z.string().min(1).max(128).optional(),
+  effectiveModel: import_zod3.z.string().min(1).max(128).optional(),
+  task: managedTaskStatusSchema.optional(),
+  error: externalAgentErrorSchema.optional(),
+  updatedAt: isoTimestampSchema
+});
+var externalAgentControlStatusRequestSchema = import_zod3.z.strictObject({});
+var externalAgentControlConnectRequestSchema = import_zod3.z.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: import_zod3.z.literal("codex"),
+  profile: import_zod3.z.literal(EXTERNAL_AGENT_MANAGED_PROFILE)
+});
+var externalAgentControlDisconnectRequestSchema = import_zod3.z.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: import_zod3.z.literal("codex"),
+  revokeGrant: import_zod3.z.boolean()
+});
+var externalAgentControlCancelRequestSchema = import_zod3.z.strictObject({
+  requestId: requestIdSchema,
+  revision: import_zod3.z.number().int().positive()
+});
+var externalAgentEventsRequestSchema = import_zod3.z.strictObject({
+  afterSequence: import_zod3.z.number().int().nonnegative().optional()
+});
+var externalAgentEventSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.strictObject({
+    type: import_zod3.z.literal("status"),
+    data: externalAgentControlStatusSchema
+  }),
+  import_zod3.z.strictObject({
+    type: import_zod3.z.literal("heartbeat"),
+    sequence: import_zod3.z.number().int().nonnegative(),
+    emittedAt: isoTimestampSchema
+  })
+]);
+var externalAgentResultRequestSchema = import_zod3.z.strictObject({
+  revision: import_zod3.z.number().int().positive()
+});
+var externalAgentManagedResultSchema = import_zod3.z.strictObject({
+  revision: import_zod3.z.number().int().positive(),
+  diff: import_zod3.z.string().max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumResultDiffBytes),
+  files: import_zod3.z.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: import_zod3.z.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  validationOutcome: import_zod3.z.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES),
+  expiresAt: isoTimestampSchema
+});
+
 // src/protocol/external-handoff.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/protocol/requests.ts
-var import_zod3 = require("zod");
-var runtimeBootstrapRequestSchema = import_zod3.z.strictObject({});
-var sourceCoordinatesSchema = import_zod3.z.strictObject({
-  fileId: import_zod3.z.string().min(1).max(128),
-  line: import_zod3.z.number().int().positive(),
-  column: import_zod3.z.number().int().positive()
+var import_zod4 = require("zod");
+var runtimeBootstrapRequestSchema = import_zod4.z.strictObject({});
+var sourceCoordinatesSchema = import_zod4.z.strictObject({
+  fileId: import_zod4.z.string().min(1).max(128),
+  line: import_zod4.z.number().int().positive(),
+  column: import_zod4.z.number().int().positive()
 });
 var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: import_zod3.z.number().int().positive()
+  maxLines: import_zod4.z.number().int().positive()
 }).strict();
 var openEditorRequestSchema = sourceCoordinatesSchema.strict();
 var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
-  schemaVersion: import_zod3.z.literal(1),
-  sourceVersion: import_zod3.z.string().min(1).max(128).optional()
+  schemaVersion: import_zod4.z.literal(1),
+  sourceVersion: import_zod4.z.string().min(1).max(128).optional()
 }).strict();
-var dataFlowComponentIdentityRequestSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(1),
-  componentSourceId: import_zod3.z.string().min(1).max(128),
-  sourceVersion: import_zod3.z.string().min(1).max(128)
+var dataFlowComponentIdentityRequestSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(1),
+  componentSourceId: import_zod4.z.string().min(1).max(128),
+  sourceVersion: import_zod4.z.string().min(1).max(128)
 });
-var dataFlowComponentReportRequestSchema = import_zod3.z.union([
+var dataFlowComponentReportRequestSchema = import_zod4.z.union([
   dataFlowSourceCoordinatesRequestSchema,
   dataFlowComponentIdentityRequestSchema
 ]);
-var dataFlowPageReportRequestSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(1),
-  targets: import_zod3.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
+var dataFlowPageReportRequestSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(1),
+  targets: import_zod4.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
 });
-var profileIdSchema2 = import_zod3.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString = (maximum) => import_zod3.z.string().max(maximum);
-var sourceRefSchema = import_zod3.z.strictObject({
+var profileIdSchema2 = import_zod4.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString = (maximum) => import_zod4.z.string().max(maximum);
+var sourceRefSchema = import_zod4.z.strictObject({
   fileId: boundedString(128).optional(),
   relativePath: boundedString(1024).optional(),
-  line: import_zod3.z.number().int().positive().optional(),
-  column: import_zod3.z.number().int().positive().optional(),
-  origin: import_zod3.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
-  confidence: import_zod3.z.enum(["exact", "probable", "approximate", "unknown"])
+  line: import_zod4.z.number().int().positive().optional(),
+  column: import_zod4.z.number().int().positive().optional(),
+  origin: import_zod4.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  confidence: import_zod4.z.enum(["exact", "probable", "approximate", "unknown"])
 });
-var matchedStyleRuleSchema = import_zod3.z.strictObject({
+var matchedStyleRuleSchema = import_zod4.z.strictObject({
   selector: boundedString(2048),
   declarations: boundedString(8192),
   source: boundedString(1024).optional(),
   media: boundedString(1024).optional()
 });
-var codeContextSchema = import_zod3.z.strictObject({
+var codeContextSchema = import_zod4.z.strictObject({
   relativePath: boundedString(1024),
-  language: import_zod3.z.enum(["tsx", "jsx"]),
-  startLine: import_zod3.z.number().int().positive(),
-  endLine: import_zod3.z.number().int().positive(),
+  language: import_zod4.z.enum(["tsx", "jsx"]),
+  startLine: import_zod4.z.number().int().positive(),
+  endLine: import_zod4.z.number().int().positive(),
   excerpt: boundedString(16e3),
-  boundary: import_zod3.z.enum(["component", "nearby-lines"])
+  boundary: import_zod4.z.enum(["component", "nearby-lines"])
 });
-var pageContextSchema = import_zod3.z.strictObject({
+var pageContextSchema = import_zod4.z.strictObject({
   url: boundedString(2048),
   pathname: boundedString(2048),
   title: boundedString(1024),
-  viewportWidth: import_zod3.z.number().nonnegative(),
-  viewportHeight: import_zod3.z.number().nonnegative(),
-  devicePixelRatio: import_zod3.z.number().positive()
+  viewportWidth: import_zod4.z.number().nonnegative(),
+  viewportHeight: import_zod4.z.number().nonnegative(),
+  devicePixelRatio: import_zod4.z.number().positive()
 });
-var spotTargetContextRequestSchema = import_zod3.z.strictObject({
-  instruction: import_zod3.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+var spotTargetContextRequestSchema = import_zod4.z.strictObject({
+  instruction: import_zod4.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
   page: pageContextSchema.optional(),
   source: sourceRefSchema,
-  react: import_zod3.z.strictObject({
-    supported: import_zod3.z.boolean(),
+  react: import_zod4.z.strictObject({
+    supported: import_zod4.z.boolean(),
     version: boundedString(64).optional(),
     componentName: boundedString(256).optional(),
     componentSourceId: boundedString(128).optional(),
     sourceVersion: boundedString(128).optional(),
-    componentStack: import_zod3.z.array(boundedString(256)).max(64),
+    componentStack: import_zod4.z.array(boundedString(256)).max(64),
     source: sourceRefSchema.optional()
   }),
-  element: import_zod3.z.strictObject({
+  element: import_zod4.z.strictObject({
     tagName: boundedString(128),
     selector: boundedString(2048),
     sanitizedHtml: boundedString(8192),
     textPreview: boundedString(2048).optional(),
     role: boundedString(256).optional(),
-    rect: import_zod3.z.strictObject({
-      x: import_zod3.z.number(),
-      y: import_zod3.z.number(),
-      width: import_zod3.z.number().nonnegative(),
-      height: import_zod3.z.number().nonnegative()
+    rect: import_zod4.z.strictObject({
+      x: import_zod4.z.number(),
+      y: import_zod4.z.number(),
+      width: import_zod4.z.number().nonnegative(),
+      height: import_zod4.z.number().nonnegative()
     })
   }),
-  styles: import_zod3.z.strictObject({
-    classNames: import_zod3.z.array(boundedString(512)).max(256),
+  styles: import_zod4.z.strictObject({
+    classNames: import_zod4.z.array(boundedString(512)).max(256),
     inlineStyle: boundedString(8192).optional(),
-    matchedRules: import_zod3.z.array(matchedStyleRuleSchema).max(256),
-    computed: import_zod3.z.record(boundedString(256), boundedString(2048)),
-    warnings: import_zod3.z.array(boundedString(1024)).max(64)
+    matchedRules: import_zod4.z.array(matchedStyleRuleSchema).max(256),
+    computed: import_zod4.z.record(boundedString(256), boundedString(2048)),
+    warnings: import_zod4.z.array(boundedString(1024)).max(64)
   }),
   code: codeContextSchema.optional(),
-  warnings: import_zod3.z.array(boundedString(1024)).max(64)
+  warnings: import_zod4.z.array(boundedString(1024)).max(64)
 });
-var spotAnnotationRequestSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(3),
+var spotAnnotationRequestSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(3),
   id: boundedString(128),
-  locale: import_zod3.z.enum(SPOTPATCH_LOCALES),
+  locale: import_zod4.z.enum(SPOTPATCH_LOCALES),
   page: pageContextSchema,
-  targets: import_zod3.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
-  createdAt: import_zod3.z.iso.datetime()
+  targets: import_zod4.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  createdAt: import_zod4.z.iso.datetime()
 }).superRefine((annotation, context) => {
   const total = annotation.targets.reduce(
     (characters, target) => characters + target.instruction.length,
@@ -1050,21 +1318,21 @@ var spotAnnotationRequestSchema = import_zod3.z.strictObject({
     });
   }
 });
-var agentCapabilityRequestSchema = import_zod3.z.strictObject({
+var agentCapabilityRequestSchema = import_zod4.z.strictObject({
   providerProfileId: profileIdSchema2,
   modelProfileId: profileIdSchema2
 });
-var agentWorkspaceHealthRequestSchema = import_zod3.z.strictObject({});
-var agentJobCreateRequestSchema = import_zod3.z.strictObject({
+var agentWorkspaceHealthRequestSchema = import_zod4.z.strictObject({});
+var agentJobCreateRequestSchema = import_zod4.z.strictObject({
   annotation: spotAnnotationRequestSchema,
-  applyMode: import_zod3.z.enum(AGENT_APPLY_MODES).optional(),
+  applyMode: import_zod4.z.enum(AGENT_APPLY_MODES).optional(),
   providerProfileId: profileIdSchema2,
   modelProfileId: profileIdSchema2,
-  providerDataConsent: import_zod3.z.literal(true),
-  trustedFastModeConsent: import_zod3.z.literal(true).optional(),
-  workingTreeMode: import_zod3.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+  providerDataConsent: import_zod4.z.literal(true),
+  trustedFastModeConsent: import_zod4.z.literal(true).optional(),
+  workingTreeMode: import_zod4.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
 });
-var agentJobActionRequestSchema = import_zod3.z.strictObject({});
+var agentJobActionRequestSchema = import_zod4.z.strictObject({});
 
 // src/protocol/external-handoff-constants.ts
 var EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -1130,46 +1398,46 @@ var EXTERNAL_HANDOFF_LIMITS = Object.freeze({
 });
 
 // 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(
+var opaqueIdSchema2 = import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var isoTimestampSchema2 = import_zod5.z.iso.datetime();
+var externalHandoffReportableDispatchPhaseSchema = import_zod5.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 externalHandoffPageSummarySchema = import_zod5.z.strictObject({
+  origin: import_zod5.z.string().min(1).max(2048),
+  pathname: import_zod5.z.string().min(1).max(2048)
 });
-var externalHandoffSummarySchema = import_zod4.z.strictObject({
+var externalHandoffSummarySchema = import_zod5.z.strictObject({
   sessionId: opaqueIdSchema2,
-  framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
-  revision: import_zod4.z.number().int().positive(),
+  framework: import_zod5.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  revision: import_zod5.z.number().int().positive(),
   cursor: opaqueIdSchema2,
-  targetCount: import_zod4.z.number().int().positive(),
+  targetCount: import_zod5.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),
+  publishedAt: isoTimestampSchema2,
+  expiresAt: isoTimestampSchema2,
+  state: import_zod5.z.enum(EXTERNAL_HANDOFF_STATES),
+  pickupCount: import_zod5.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
+  pickedUpAt: isoTimestampSchema2.optional()
+});
+var externalHandoffSnapshotSchema = import_zod5.z.strictObject({
+  schemaVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
   cursor: opaqueIdSchema2,
-  session: import_zod4.z.strictObject({
+  session: import_zod5.z.strictObject({
     id: opaqueIdSchema2,
-    framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
+    framework: import_zod5.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
   }),
-  revision: import_zod4.z.number().int().positive(),
-  publishedAt: isoTimestampSchema,
-  expiresAt: isoTimestampSchema,
+  revision: import_zod5.z.number().int().positive(),
+  publishedAt: isoTimestampSchema2,
+  expiresAt: isoTimestampSchema2,
   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
+var activeAdapterSummarySchema = import_zod5.z.strictObject({
+  kind: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  state: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
+  canDispatch: import_zod5.z.boolean(),
+  connectedAt: isoTimestampSchema2,
+  updatedAt: isoTimestampSchema2
 }).superRefine((value, context) => {
   if (value.canDispatch !== (value.state === "ready")) {
     context.addIssue({
@@ -1179,83 +1447,83 @@ var activeAdapterSummarySchema = import_zod4.z.strictObject({
     });
   }
 });
-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 dispatchSummarySchema = import_zod5.z.strictObject({
+  adapterKind: import_zod5.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  revision: import_zod5.z.number().int().positive(),
+  phase: import_zod5.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
+  updatedAt: isoTimestampSchema2
 });
-var externalHandoffCapabilityRequestSchema = import_zod4.z.strictObject({});
-var externalHandoffPublishRequestSchema = import_zod4.z.strictObject({
+var externalHandoffCapabilityRequestSchema = import_zod5.z.strictObject({});
+var externalHandoffPublishRequestSchema = import_zod5.z.strictObject({
   requestId: opaqueIdSchema2,
   annotation: spotAnnotationRequestSchema
 });
-var externalHandoffStatusRequestSchema = import_zod4.z.strictObject({
+var externalHandoffStatusRequestSchema = import_zod5.z.strictObject({
   cursor: opaqueIdSchema2.optional()
 });
-var externalHandoffResolveDeliveryRequestSchema = import_zod4.z.strictObject({
+var externalHandoffResolveDeliveryRequestSchema = import_zod5.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),
+  confirmation: import_zod5.z.literal("workspace-reviewed")
+});
+var externalHandoffCapabilitySchema = import_zod5.z.strictObject({
+  enabled: import_zod5.z.literal(true),
+  brokerReady: import_zod5.z.boolean(),
+  activeWaitCount: import_zod5.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
+  snapshotSchemaVersion: import_zod5.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  brokerProtocolVersion: import_zod5.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"),
+var externalHandoffPublishDeliverySchema = import_zod5.z.discriminatedUnion("mode", [
+  import_zod5.z.strictObject({ mode: import_zod5.z.literal("inbox") }),
+  import_zod5.z.strictObject({
+    mode: import_zod5.z.literal("active"),
     adapter: activeAdapterSummarySchema,
     dispatch: dispatchSummarySchema
   })
 ]);
-var externalHandoffPublishResultSchema = import_zod4.z.strictObject({
+var externalHandoffPublishResultSchema = import_zod5.z.strictObject({
   handoff: externalHandoffSummarySchema,
   delivery: externalHandoffPublishDeliverySchema,
-  replayed: import_zod4.z.boolean()
+  replayed: import_zod5.z.boolean()
 });
-var externalHandoffStatusResultSchema = import_zod4.z.strictObject({
+var externalHandoffStatusResultSchema = import_zod5.z.strictObject({
   handoff: externalHandoffSummarySchema,
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
 });
 
 // src/protocol/agent-schemas.ts
-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({
+var import_zod6 = require("zod");
+var profileIdSchema3 = import_zod6.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString2 = (maximum) => import_zod6.z.string().max(maximum);
+var errorCodeSchema = import_zod6.z.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = import_zod6.z.strictObject({
   providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
   modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
-  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(),
+  protocol: import_zod6.z.enum(["responses", "chat-completions"]),
+  state: import_zod6.z.enum(AGENT_CAPABILITY_STATES),
+  authenticated: import_zod6.z.boolean(),
+  modelAvailable: import_zod6.z.boolean(),
+  toolCalling: import_zod6.z.boolean(),
+  toolResultContinuation: import_zod6.z.boolean(),
+  streaming: import_zod6.z.boolean(),
+  checkedAt: import_zod6.z.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-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()
+var agentWorkspaceHealthSnapshotSchema = import_zod6.z.strictObject({
+  state: import_zod6.z.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: import_zod6.z.iso.datetime(),
+  changes: import_zod6.z.strictObject({
+    staged: import_zod6.z.number().int().nonnegative(),
+    unstaged: import_zod6.z.number().int().nonnegative(),
+    untracked: import_zod6.z.number().int().nonnegative(),
+    conflicted: import_zod6.z.number().int().nonnegative(),
+    total: import_zod6.z.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: import_zod5.z.boolean(),
+  canIncludeLocalChanges: import_zod6.z.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -1273,42 +1541,42 @@ var agentWorkspaceHealthSnapshotSchema = import_zod5.z.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = import_zod5.z.strictObject({
+var agentChangedFileSchema = import_zod6.z.strictObject({
   relativePath: boundedString2(1024),
-  kind: import_zod5.z.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: import_zod5.z.number().int().nonnegative(),
-  deletions: import_zod5.z.number().int().nonnegative()
+  kind: import_zod6.z.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: import_zod6.z.number().int().nonnegative(),
+  deletions: import_zod6.z.number().int().nonnegative()
 });
-var agentCheckResultSchema = import_zod5.z.strictObject({
+var agentCheckResultSchema = import_zod6.z.strictObject({
   checkId: profileIdSchema3,
   label: boundedString2(100),
-  status: import_zod5.z.enum(AGENT_CHECK_STATUSES),
-  durationMs: import_zod5.z.number().int().nonnegative(),
+  status: import_zod6.z.enum(AGENT_CHECK_STATUSES),
+  durationMs: import_zod6.z.number().int().nonnegative(),
   output: boundedString2(8e4)
 });
-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),
+var agentJobSnapshotSchema = import_zod6.z.strictObject({
+  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod6.z.enum(AGENT_JOB_STATUSES),
   providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
   modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
   phaseMessage: boundedString2(1024),
-  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(),
+  createdAt: import_zod6.z.iso.datetime(),
+  updatedAt: import_zod6.z.iso.datetime(),
+  canCancel: import_zod6.z.boolean(),
+  canApply: import_zod6.z.boolean(),
+  canRevert: import_zod6.z.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = import_zod5.z.strictObject({
-  jobId: import_zod5.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+var agentJobResultSchema = import_zod6.z.strictObject({
+  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
   summary: boundedString2(8e4),
   diff: boundedString2(1e6),
-  files: import_zod5.z.array(agentChangedFileSchema).max(100),
-  checks: import_zod5.z.array(agentCheckResultSchema).max(100)
+  files: import_zod6.z.array(agentChangedFileSchema).max(100),
+  checks: import_zod6.z.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = import_zod5.z.strictObject({
+var agentJobResultResponseSchema = import_zod6.z.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -1320,44 +1588,44 @@ var agentJobResultResponseSchema = import_zod5.z.strictObject({
     });
   }
 });
-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 agentJobEventBaseSchema = import_zod6.z.strictObject({
+  schemaVersion: import_zod6.z.literal(2),
+  sequence: import_zod6.z.number().int().positive(),
+  jobId: import_zod6.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: import_zod6.z.enum(AGENT_JOB_STATUSES),
+  timestamp: import_zod6.z.iso.datetime()
 });
-var agentJobEventSchema = import_zod5.z.discriminatedUnion("type", [
+var agentJobEventSchema = import_zod6.z.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: import_zod5.z.literal("snapshot"),
-    data: import_zod5.z.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: import_zod6.z.literal("snapshot"),
+    data: import_zod6.z.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod5.z.literal("phase"),
-    data: import_zod5.z.strictObject({ message: boundedString2(1024) })
+    type: import_zod6.z.literal("phase"),
+    data: import_zod6.z.strictObject({ message: boundedString2(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod5.z.literal("tool"),
-    data: import_zod5.z.strictObject({
-      turn: import_zod5.z.number().int().positive(),
+    type: import_zod6.z.literal("tool"),
+    data: import_zod6.z.strictObject({
+      turn: import_zod6.z.number().int().positive(),
       toolCallId: boundedString2(256),
       toolName: boundedString2(100),
-      state: import_zod5.z.enum(["started", "succeeded", "failed"]),
+      state: import_zod6.z.enum(["started", "succeeded", "failed"]),
       relativePath: boundedString2(1024).optional(),
       checkLabel: boundedString2(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod5.z.literal("check"),
-    data: import_zod5.z.strictObject({ result: agentCheckResultSchema })
+    type: import_zod6.z.literal("check"),
+    data: import_zod6.z.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod5.z.literal("result-ready"),
-    data: import_zod5.z.strictObject({ hasResult: import_zod5.z.literal(true) })
+    type: import_zod6.z.literal("result-ready"),
+    data: import_zod6.z.strictObject({ hasResult: import_zod6.z.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: import_zod5.z.literal("error"),
-    data: import_zod5.z.strictObject({
+    type: import_zod6.z.literal("error"),
+    data: import_zod6.z.strictObject({
       code: errorCodeSchema,
       message: boundedString2(1024)
     })
@@ -1411,6 +1679,22 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   DEFAULT_RUNTIME_DATA_FLOW_LIMITS,
   ERROR_CODES,
   ERROR_CODE_VALUES,
+  EXTERNAL_AGENT_ACTIONS,
+  EXTERNAL_AGENT_AUTH_READINESS,
+  EXTERNAL_AGENT_CONNECTION_STATES,
+  EXTERNAL_AGENT_CONTROL_LIMITS,
+  EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+  EXTERNAL_AGENT_DELIVERY_STATUSES,
+  EXTERNAL_AGENT_ERROR_CODES,
+  EXTERNAL_AGENT_ERROR_RECOVERABILITY,
+  EXTERNAL_AGENT_ERROR_STAGES,
+  EXTERNAL_AGENT_EXECUTION_STATUSES,
+  EXTERNAL_AGENT_GRANT_STATES,
+  EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS,
+  EXTERNAL_AGENT_MANAGED_PHASES,
+  EXTERNAL_AGENT_MANAGED_PROFILE,
+  EXTERNAL_AGENT_MODES,
+  EXTERNAL_AGENT_VALIDATION_OUTCOMES,
   EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS,
   EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES,
   EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION,
@@ -1452,6 +1736,16 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
   dispatchSummarySchema,
+  externalAgentControlCancelRequestSchema,
+  externalAgentControlConnectRequestSchema,
+  externalAgentControlDisconnectRequestSchema,
+  externalAgentControlStatusRequestSchema,
+  externalAgentControlStatusSchema,
+  externalAgentErrorSchema,
+  externalAgentEventSchema,
+  externalAgentEventsRequestSchema,
+  externalAgentManagedResultSchema,
+  externalAgentResultRequestSchema,
   externalHandoffCapabilityRequestSchema,
   externalHandoffCapabilitySchema,
   externalHandoffPublishDeliverySchema,
@@ -1468,6 +1762,10 @@ var SPOTPATCH_REPOSITORY_URL = "https://github.com/huanglvjing/spotpatch";
   isErrorCode,
   isSensitiveName,
   limitDataFlowReportCollections,
+  managedCheckSummarySchema,
+  managedFileSummarySchema,
+  managedTaskStatusSchema,
+  managedTimingSummarySchema,
   networkObservationSchema,
   openEditorRequestSchema,
   pageDataFlowReportSchema,