@spotpatch/shared 1.9.0 → 1.11.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-JU5HIWX7.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-JGOIBOFI.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,149 +683,248 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
-// src/protocol/requests.ts
+// src/protocol/external-agent-control.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 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 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 isoTimestampSchema = z3.iso.datetime();
+var requestIdSchema = z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var safeRelativePathSchema = z3.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 dataFlowComponentReportRequestSchema = z3.union([
-  dataFlowSourceCoordinatesRequestSchema,
-  dataFlowComponentIdentityRequestSchema
-]);
-var dataFlowPageReportRequestSchema = z3.strictObject({
-  schemaVersion: z3.literal(1),
-  targets: z3.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
+var externalAgentErrorSchema = z3.strictObject({
+  code: z3.enum(EXTERNAL_AGENT_ERROR_CODES),
+  stage: z3.enum(EXTERNAL_AGENT_ERROR_STAGES),
+  recoverability: z3.enum(EXTERNAL_AGENT_ERROR_RECOVERABILITY),
+  action: z3.enum(EXTERNAL_AGENT_ACTIONS)
 });
-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 managedFileSummarySchema = z3.strictObject({
+  path: safeRelativePathSchema,
+  additions: z3.number().int().nonnegative(),
+  deletions: z3.number().int().nonnegative()
 });
-var matchedStyleRuleSchema = z3.strictObject({
-  selector: boundedString(2048),
-  declarations: boundedString(8192),
-  source: boundedString(1024).optional(),
-  media: boundedString(1024).optional()
+var managedCheckSummarySchema = z3.strictObject({
+  id: z3.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/u),
+  outcome: z3.enum(EXTERNAL_AGENT_CHECK_OUTCOMES),
+  durationMs: z3.number().int().nonnegative(),
+  exitCode: z3.number().int().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 managedTimingSummarySchema = z3.strictObject({
+  preparing: z3.number().int().nonnegative().optional(),
+  agent: z3.number().int().nonnegative().optional(),
+  auditing: z3.number().int().nonnegative().optional(),
+  validating: z3.number().int().nonnegative().optional(),
+  applying: z3.number().int().nonnegative().optional(),
+  total: z3.number().int().nonnegative().optional()
 });
-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 managedTaskStatusSchema = z3.strictObject({
+  revision: z3.number().int().positive(),
+  deliveryStatus: z3.enum(EXTERNAL_AGENT_DELIVERY_STATUSES),
+  executionStatus: z3.enum(EXTERNAL_AGENT_EXECUTION_STATUSES),
+  managedPhase: z3.enum(EXTERNAL_AGENT_MANAGED_PHASES),
+  validationOutcome: z3.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES).optional(),
+  files: z3.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: z3.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  resultExpiresAt: isoTimestampSchema.optional()
 });
-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)
+var externalAgentControlStatusSchema = z3.strictObject({
+  schemaVersion: z3.literal(EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION),
+  sequence: z3.number().int().nonnegative(),
+  mode: z3.enum(EXTERNAL_AGENT_MODES),
+  adapter: z3.strictObject({
+    kind: z3.enum(EXTERNAL_AGENT_MANAGED_ADAPTER_KINDS),
+    maturity: z3.literal("experimental"),
+    availability: z3.enum(["available", "unavailable"])
   }),
-  code: codeContextSchema.optional(),
-  warnings: z3.array(boundedString(1024)).max(64)
+  connectionState: z3.enum(EXTERNAL_AGENT_CONNECTION_STATES),
+  authReadiness: z3.enum(EXTERNAL_AGENT_AUTH_READINESS),
+  grantState: z3.enum(EXTERNAL_AGENT_GRANT_STATES),
+  requestedModel: z3.string().min(1).max(128).optional(),
+  effectiveModel: z3.string().min(1).max(128).optional(),
+  task: managedTaskStatusSchema.optional(),
+  error: externalAgentErrorSchema.optional(),
+  updatedAt: isoTimestampSchema
 });
-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 externalAgentControlStatusRequestSchema = z3.strictObject({});
+var externalAgentControlConnectRequestSchema = z3.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: z3.literal("codex"),
+  profile: z3.literal(EXTERNAL_AGENT_MANAGED_PROFILE)
 });
-var agentCapabilityRequestSchema = z3.strictObject({
-  providerProfileId: profileIdSchema2,
-  modelProfileId: profileIdSchema2
+var externalAgentControlDisconnectRequestSchema = z3.strictObject({
+  requestId: requestIdSchema,
+  adapterKind: z3.literal("codex"),
+  revokeGrant: z3.boolean()
 });
-var agentWorkspaceHealthRequestSchema = z3.strictObject({});
-var agentJobCreateRequestSchema = z3.strictObject({
-  annotation: spotAnnotationRequestSchema,
-  applyMode: z3.enum(AGENT_APPLY_MODES).optional(),
-  providerProfileId: profileIdSchema2,
-  modelProfileId: profileIdSchema2,
-  providerDataConsent: z3.literal(true),
-  trustedFastModeConsent: z3.literal(true).optional(),
-  workingTreeMode: z3.enum(["require-clean", "include-local-changes"]).default("require-clean")
+var externalAgentControlCancelRequestSchema = z3.strictObject({
+  requestId: requestIdSchema,
+  revision: z3.number().int().positive()
+});
+var externalAgentEventsRequestSchema = z3.strictObject({
+  afterSequence: z3.number().int().nonnegative().optional()
+});
+var externalAgentEventSchema = z3.discriminatedUnion("type", [
+  z3.strictObject({
+    type: z3.literal("status"),
+    data: externalAgentControlStatusSchema
+  }),
+  z3.strictObject({
+    type: z3.literal("heartbeat"),
+    sequence: z3.number().int().nonnegative(),
+    emittedAt: isoTimestampSchema
+  })
+]);
+var externalAgentResultRequestSchema = z3.strictObject({
+  revision: z3.number().int().positive()
+});
+var externalAgentManagedResultSchema = z3.strictObject({
+  revision: z3.number().int().positive(),
+  diff: z3.string().max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumResultDiffBytes),
+  files: z3.array(managedFileSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChangedFiles),
+  checks: z3.array(managedCheckSummarySchema).max(EXTERNAL_AGENT_CONTROL_LIMITS.maximumChecks),
+  timings: managedTimingSummarySchema,
+  validationOutcome: z3.enum(EXTERNAL_AGENT_VALIDATION_OUTCOMES),
+  expiresAt: isoTimestampSchema
 });
-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 profileIdSchema2 = z4.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString = (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),
+  providerProfileId: profileIdSchema2,
+  providerLabel: boundedString(100),
+  modelProfileId: profileIdSchema2,
+  modelLabel: boundedString(100),
   protocol: z4.enum(["responses", "chat-completions"]),
   state: z4.enum(AGENT_CAPABILITY_STATES),
   authenticated: z4.boolean(),
@@ -931,26 +964,26 @@ var agentWorkspaceHealthSnapshotSchema = z4.strictObject({
   { message: "Agent workspace health fields are inconsistent." }
 );
 var agentChangedFileSchema = z4.strictObject({
-  relativePath: boundedString2(1024),
+  relativePath: boundedString(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),
+  checkId: profileIdSchema2,
+  label: boundedString(100),
   status: z4.enum(AGENT_CHECK_STATUSES),
   durationMs: z4.number().int().nonnegative(),
-  output: boundedString2(8e4)
+  output: boundedString(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),
+  providerProfileId: profileIdSchema2,
+  providerLabel: boundedString(100),
+  modelProfileId: profileIdSchema2,
+  modelLabel: boundedString(100),
+  phaseMessage: boundedString(1024),
   createdAt: z4.iso.datetime(),
   updatedAt: z4.iso.datetime(),
   canCancel: z4.boolean(),
@@ -960,8 +993,8 @@ var agentJobSnapshotSchema = z4.strictObject({
 });
 var agentJobResultSchema = z4.strictObject({
   jobId: z4.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  summary: boundedString2(8e4),
-  diff: boundedString2(1e6),
+  summary: boundedString(8e4),
+  diff: boundedString(1e6),
   files: z4.array(agentChangedFileSchema).max(100),
   checks: z4.array(agentCheckResultSchema).max(100)
 });
@@ -991,17 +1024,17 @@ var agentJobEventSchema = z4.discriminatedUnion("type", [
   }),
   agentJobEventBaseSchema.extend({
     type: z4.literal("phase"),
-    data: z4.strictObject({ message: boundedString2(1024) })
+    data: z4.strictObject({ message: boundedString(1024) })
   }),
   agentJobEventBaseSchema.extend({
     type: z4.literal("tool"),
     data: z4.strictObject({
       turn: z4.number().int().positive(),
-      toolCallId: boundedString2(256),
-      toolName: boundedString2(100),
+      toolCallId: boundedString(256),
+      toolName: boundedString(100),
       state: z4.enum(["started", "succeeded", "failed"]),
-      relativePath: boundedString2(1024).optional(),
-      checkLabel: boundedString2(100).optional()
+      relativePath: boundedString(1024).optional(),
+      checkLabel: boundedString(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
@@ -1016,7 +1049,7 @@ var agentJobEventSchema = z4.discriminatedUnion("type", [
     type: z4.literal("error"),
     data: z4.strictObject({
       code: errorCodeSchema,
-      message: boundedString2(1024)
+      message: boundedString(1024)
     })
   })
 ]).superRefine((event, context) => {
@@ -1066,6 +1099,32 @@ export {
   DEFAULT_DATA_FLOW_LIMITS,
   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,
+  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 +1139,7 @@ export {
   SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER,
   SpotPatchError,
+  activeAdapterSummarySchema,
   agentCapabilityRequestSchema,
   agentCapabilitySnapshotSchema,
   agentChangedFileSchema,
@@ -1096,10 +1156,37 @@ export {
   dataDependencySchema,
   dataFlowComponentReportRequestSchema,
   dataFlowPageReportRequestSchema,
+  dispatchSummarySchema,
+  externalAgentControlCancelRequestSchema,
+  externalAgentControlConnectRequestSchema,
+  externalAgentControlDisconnectRequestSchema,
+  externalAgentControlStatusRequestSchema,
+  externalAgentControlStatusSchema,
+  externalAgentErrorSchema,
+  externalAgentEventSchema,
+  externalAgentEventsRequestSchema,
+  externalAgentManagedResultSchema,
+  externalAgentResultRequestSchema,
+  externalHandoffCapabilityRequestSchema,
+  externalHandoffCapabilitySchema,
+  externalHandoffPublishDeliverySchema,
+  externalHandoffPublishRequestSchema,
+  externalHandoffPublishResultSchema,
+  externalHandoffReportableDispatchPhaseSchema,
+  externalHandoffResolveDeliveryRequestSchema,
+  externalHandoffSnapshotSchema,
+  externalHandoffStatusRequestSchema,
+  externalHandoffStatusResultSchema,
+  externalHandoffSummarySchema,
   formatSourceMarker,
   getAgentJobEndpoint,
+  isErrorCode,
   isSensitiveName,
   limitDataFlowReportCollections,
+  managedCheckSummarySchema,
+  managedFileSummarySchema,
+  managedTaskStatusSchema,
+  managedTimingSummarySchema,
   networkObservationSchema,
   openEditorRequestSchema,
   pageDataFlowReportSchema,