@spotpatch/shared 1.12.0 → 1.13.0

package/dist/contextual-ask-node.cjs

@@ -0,0 +1,968 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/contextual-ask-node.ts
+var contextual_ask_node_exports = {};
+__export(contextual_ask_node_exports, {
+  ASK_ANSWER_WARNING_CODES: () => ASK_ANSWER_WARNING_CODES,
+  ASK_EXECUTOR_ANSWER_WARNING_CODES: () => ASK_EXECUTOR_ANSWER_WARNING_CODES,
+  ASK_FILE_COUNT_BUCKETS: () => ASK_FILE_COUNT_BUCKETS,
+  ASK_JOB_STATUSES: () => ASK_JOB_STATUSES,
+  ASK_READ_ACTIVITY_STATES: () => ASK_READ_ACTIVITY_STATES,
+  ASK_SOURCE_CONFIDENCES: () => ASK_SOURCE_CONFIDENCES,
+  CONTEXTUAL_ASK_ERROR_CODES: () => CONTEXTUAL_ASK_ERROR_CODES,
+  CONTEXTUAL_ASK_EXECUTOR_KINDS: () => CONTEXTUAL_ASK_EXECUTOR_KINDS,
+  CONTEXTUAL_ASK_EXECUTOR_STATES: () => CONTEXTUAL_ASK_EXECUTOR_STATES,
+  CONTEXTUAL_ASK_LIMITS: () => CONTEXTUAL_ASK_LIMITS,
+  CONTEXTUAL_ASK_PERMISSION_PROFILE: () => CONTEXTUAL_ASK_PERMISSION_PROFILE,
+  CONTEXTUAL_ASK_SCHEMA_VERSION: () => CONTEXTUAL_ASK_SCHEMA_VERSION,
+  SPOTPATCH_ENDPOINTS: () => SPOTPATCH_ENDPOINTS,
+  SPOTPATCH_TOKEN_HEADER: () => SPOTPATCH_TOKEN_HEADER,
+  adaptChangeEnvelopeToSpotAnnotationV3: () => adaptChangeEnvelopeToSpotAnnotationV3,
+  askAnswerBlockSchema: () => askAnswerBlockSchema,
+  askAnswerDraftBlockSchema: () => askAnswerDraftBlockSchema,
+  askAnswerDraftSchema: () => askAnswerDraftSchema,
+  askAnswerResultSchema: () => askAnswerResultSchema,
+  askAnswerWarningSchema: () => askAnswerWarningSchema,
+  askDraftCitationSchema: () => askDraftCitationSchema,
+  askDraftOriginSchema: () => askDraftOriginSchema,
+  askJobActionRequestSchema: () => askJobActionRequestSchema,
+  askJobCreateRequestSchema: () => askJobCreateRequestSchema,
+  askJobEventSchema: () => askJobEventSchema,
+  askJobEventsRequestSchema: () => askJobEventsRequestSchema,
+  askJobResultResponseSchema: () => askJobResultResponseSchema,
+  askJobSnapshotSchema: () => askJobSnapshotSchema,
+  askSourceReferenceSchema: () => askSourceReferenceSchema,
+  contextualAskCapabilityRequestSchema: () => contextualAskCapabilityRequestSchema,
+  contextualAskCapabilitySchema: () => contextualAskCapabilitySchema,
+  contextualAskExecutorCapabilitySchema: () => contextualAskExecutorCapabilitySchema,
+  contextualAskExecutorPreferenceSchema: () => contextualAskExecutorPreferenceSchema,
+  contextualAskOptionsSchema: () => contextualAskOptionsSchema,
+  getAskJobEndpoint: () => getAskJobEndpoint,
+  spotAskTaskEnvelopeSchema: () => spotAskTaskEnvelopeSchema,
+  spotChangeTaskEnvelopeSchema: () => spotChangeTaskEnvelopeSchema,
+  spotSelectionContextSchema: () => spotSelectionContextSchema,
+  spotSelectionTargetSchema: () => spotSelectionTargetSchema,
+  spotTaskEnvelopeSchema: () => spotTaskEnvelopeSchema
+});
+module.exports = __toCommonJS(contextual_ask_node_exports);
+
+// src/model/context-schema.ts
+var import_zod = require("zod");
+
+// 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/context-schema.ts
+var boundedString = (maximum) => import_zod.z.string().max(maximum);
+var sourceRefSchema = import_zod.z.strictObject({
+  fileId: boundedString(128).optional(),
+  relativePath: boundedString(1024).optional(),
+  line: import_zod.z.number().int().positive().optional(),
+  column: import_zod.z.number().int().positive().optional(),
+  origin: import_zod.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  confidence: import_zod.z.enum(["exact", "probable", "approximate", "unknown"])
+});
+var matchedStyleRuleSchema = import_zod.z.strictObject({
+  selector: boundedString(2048),
+  declarations: boundedString(8192),
+  source: boundedString(1024).optional(),
+  media: boundedString(1024).optional()
+});
+var codeContextSchema = import_zod.z.strictObject({
+  relativePath: boundedString(1024),
+  language: import_zod.z.enum(["tsx", "jsx"]),
+  startLine: import_zod.z.number().int().positive(),
+  endLine: import_zod.z.number().int().positive(),
+  excerpt: boundedString(16e3),
+  boundary: import_zod.z.enum(["component", "nearby-lines"])
+});
+var pageContextSchema = import_zod.z.strictObject({
+  url: boundedString(2048),
+  pathname: boundedString(2048),
+  title: boundedString(1024),
+  viewportWidth: import_zod.z.number().nonnegative(),
+  viewportHeight: import_zod.z.number().nonnegative(),
+  devicePixelRatio: import_zod.z.number().positive()
+});
+var spotTargetContextSchema = import_zod.z.strictObject({
+  instruction: import_zod.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+  page: pageContextSchema.optional(),
+  source: sourceRefSchema,
+  react: import_zod.z.strictObject({
+    supported: import_zod.z.boolean(),
+    version: boundedString(64).optional(),
+    componentName: boundedString(256).optional(),
+    componentSourceId: boundedString(128).optional(),
+    sourceVersion: boundedString(128).optional(),
+    componentStack: import_zod.z.array(boundedString(256)).max(64),
+    source: sourceRefSchema.optional()
+  }),
+  element: import_zod.z.strictObject({
+    tagName: boundedString(128),
+    selector: boundedString(2048),
+    sanitizedHtml: boundedString(8192),
+    textPreview: boundedString(2048).optional(),
+    role: boundedString(256).optional(),
+    rect: import_zod.z.strictObject({
+      x: import_zod.z.number(),
+      y: import_zod.z.number(),
+      width: import_zod.z.number().nonnegative(),
+      height: import_zod.z.number().nonnegative()
+    })
+  }),
+  styles: import_zod.z.strictObject({
+    classNames: import_zod.z.array(boundedString(512)).max(256),
+    inlineStyle: boundedString(8192).optional(),
+    matchedRules: import_zod.z.array(matchedStyleRuleSchema).max(256),
+    computed: import_zod.z.record(boundedString(256), boundedString(2048)),
+    warnings: import_zod.z.array(boundedString(1024)).max(64)
+  }),
+  code: codeContextSchema.optional(),
+  warnings: import_zod.z.array(boundedString(1024)).max(64)
+});
+var spotAnnotationSchema = import_zod.z.strictObject({
+  schemaVersion: import_zod.z.literal(3),
+  id: boundedString(128),
+  locale: import_zod.z.enum(SPOTPATCH_LOCALES),
+  page: pageContextSchema,
+  targets: import_zod.z.array(spotTargetContextSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  createdAt: import_zod.z.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"]
+    });
+  }
+});
+
+// src/model/contextual-ask.ts
+var import_zod2 = require("zod");
+
+// 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",
+  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",
+  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"
+};
+var CONTEXTUAL_ASK_ERROR_CODES = Object.freeze([
+  "ASK_DISABLED",
+  "ASK_SELECTION_REQUIRED",
+  "ASK_SELECTION_STALE",
+  "ASK_QUESTION_INVALID",
+  "ASK_EXECUTOR_UNAVAILABLE",
+  "ASK_TIMEOUT",
+  "ASK_CONSENT_REQUIRED",
+  "ASK_BUSY",
+  "ASK_IDEMPOTENCY_CONFLICT",
+  "ASK_SOURCE_SCOPE_DENIED",
+  "ASK_LIMIT_EXCEEDED",
+  "ASK_ANSWER_INVALID",
+  "ASK_WRITE_ATTEMPTED",
+  "ASK_CANCELLED",
+  "ASK_RESULT_EXPIRED",
+  "ASK_PROTOCOL_INCOMPATIBLE"
+]);
+var ERROR_CODE_VALUES = Object.freeze(Object.values(ERROR_CODES));
+
+// src/protocol/contextual-ask-constants.ts
+var CONTEXTUAL_ASK_SCHEMA_VERSION = 1;
+var CONTEXTUAL_ASK_LIMITS = Object.freeze({
+  maximumTargets: 20,
+  maximumQuestionCharacters: 4e3,
+  maximumAnswerCharacters: 4e4,
+  maximumAnswerBlocks: 40,
+  maximumSources: 64,
+  maximumReadFiles: 32,
+  maximumReadBytesPerFile: 64 * 1024,
+  maximumReadBytesTotal: 512 * 1024,
+  maximumToolCalls: 48,
+  maximumModelTurns: 12,
+  jobTimeoutMs: 3e5,
+  resultTtlMs: 9e5,
+  maximumActiveJobsPerSession: 1,
+  maximumRetainedResultsPerSession: 1,
+  maximumRetainedEvents: 256,
+  maximumEventSubscribers: 4,
+  eventHeartbeatMs: 15e3,
+  maximumRequestBodyBytes: 256 * 1024,
+  maximumSearchQueryCharacters: 256,
+  maximumSearchResults: 64,
+  maximumSearchPreviewCharacters: 500,
+  capabilityTimeoutMs: 3e4,
+  maximumIdCharacters: 128,
+  maximumProfileIdCharacters: 64,
+  maximumLabelCharacters: 256,
+  maximumRelativePathCharacters: 1024,
+  maximumLanguageCharacters: 64,
+  maximumPhaseMessageCharacters: 1024,
+  maximumExecutors: 32,
+  contentHashHexCharacters: 64
+});
+var CONTEXTUAL_ASK_EXECUTOR_KINDS = Object.freeze([
+  "configured-key",
+  "managed-codex"
+]);
+var CONTEXTUAL_ASK_EXECUTOR_STATES = Object.freeze([
+  "ready",
+  "degraded",
+  "unavailable"
+]);
+var ASK_JOB_STATUSES = Object.freeze([
+  "queued",
+  "authorizing",
+  "running",
+  "cancelling",
+  "answered",
+  "cancelled",
+  "failed"
+]);
+var ASK_ANSWER_WARNING_CODES = Object.freeze([
+  "insufficient-evidence",
+  "partial-context",
+  "source-truncated",
+  "source-stale"
+]);
+var ASK_EXECUTOR_ANSWER_WARNING_CODES = Object.freeze([
+  "insufficient-evidence",
+  "partial-context"
+]);
+var ASK_READ_ACTIVITY_STATES = Object.freeze([
+  "started",
+  "succeeded",
+  "failed"
+]);
+var ASK_FILE_COUNT_BUCKETS = Object.freeze(["one", "few", "many"]);
+var ASK_SOURCE_CONFIDENCES = Object.freeze([
+  "exact",
+  "probable",
+  "approximate"
+]);
+var CONTEXTUAL_ASK_PERMISSION_PROFILE = "spotpatch-ask-readonly";
+
+// src/model/contextual-ask.ts
+var limits = CONTEXTUAL_ASK_LIMITS;
+var contextualAskBoundedText = (maximum) => import_zod2.z.string().trim().min(1).max(maximum);
+var contextualAskOpaqueIdSchema = import_zod2.z.string().min(1).max(limits.maximumIdCharacters).regex(/^[A-Za-z0-9_-]+$/u);
+var profileIdSchema = import_zod2.z.string().min(1).max(limits.maximumProfileIdCharacters).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+var contentHashSchema = import_zod2.z.string().length(limits.contentHashHexCharacters).regex(/^[a-f0-9]+$/u);
+var contextualAskRelativePathSchema = import_zod2.z.string().min(1).max(limits.maximumRelativePathCharacters).refine(
+  (value) => !value.startsWith("/") && !value.includes("\\") && !Array.from(value).some((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== void 0 && (codePoint <= 31 || codePoint === 127);
+  }) && !/^[A-Za-z]:/u.test(value) && value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".."),
+  { message: "Expected a safe project-relative POSIX path." }
+);
+var contextualAskExecutorPreferenceSchema = import_zod2.z.discriminatedUnion("kind", [
+  import_zod2.z.strictObject({
+    kind: import_zod2.z.literal("configured-key"),
+    providerProfileId: profileIdSchema,
+    modelProfileId: profileIdSchema
+  }),
+  import_zod2.z.strictObject({ kind: import_zod2.z.literal("managed-codex") })
+]);
+var contextualAskOptionsSchema = import_zod2.z.union([
+  import_zod2.z.boolean(),
+  import_zod2.z.strictObject({
+    defaultExecutor: contextualAskExecutorPreferenceSchema.optional()
+  })
+]);
+var spotSelectionTargetSchema = spotTargetContextSchema.omit({ instruction: true, page: true }).extend({
+  targetId: contextualAskOpaqueIdSchema,
+  page: pageContextSchema
+}).strict();
+var spotSelectionContextSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  selectionId: contextualAskOpaqueIdSchema,
+  locale: import_zod2.z.enum(SPOTPATCH_LOCALES),
+  targets: import_zod2.z.array(spotSelectionTargetSchema).min(1).max(limits.maximumTargets),
+  createdAt: import_zod2.z.iso.datetime()
+}).superRefine((selection, context) => {
+  const targetIds = selection.targets.map((target) => target.targetId);
+  if (new Set(targetIds).size !== targetIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Selection target IDs must be unique.",
+      path: ["targets"]
+    });
+  }
+});
+var askDraftOriginSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("contextual-ask"),
+  askJobId: contextualAskOpaqueIdSchema,
+  question: contextualAskBoundedText(limits.maximumQuestionCharacters),
+  answerDigest: contextualAskBoundedText(limits.maximumQuestionCharacters),
+  sourceIds: import_zod2.z.array(contextualAskOpaqueIdSchema).max(limits.maximumSources)
+}).superRefine((origin, context) => {
+  if (new Set(origin.sourceIds).size !== origin.sourceIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Ask origin source IDs must be unique.",
+      path: ["sourceIds"]
+    });
+  }
+});
+var askTaskSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("ask"),
+  question: contextualAskBoundedText(limits.maximumQuestionCharacters)
+});
+var changeInstructionSchema = import_zod2.z.strictObject({
+  targetId: contextualAskOpaqueIdSchema,
+  instruction: contextualAskBoundedText(MAX_TARGET_INSTRUCTION_CHARACTERS)
+});
+var changeTaskSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("change"),
+  instructions: import_zod2.z.array(changeInstructionSchema).min(1).max(limits.maximumTargets),
+  origin: askDraftOriginSchema.optional()
+});
+var envelopeBaseShape = {
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  taskId: contextualAskOpaqueIdSchema,
+  selection: spotSelectionContextSchema,
+  createdAt: import_zod2.z.iso.datetime()
+};
+var spotAskTaskEnvelopeSchema = import_zod2.z.strictObject({
+  ...envelopeBaseShape,
+  task: askTaskSchema
+});
+var spotChangeTaskEnvelopeSchema = import_zod2.z.strictObject({
+  ...envelopeBaseShape,
+  task: changeTaskSchema
+}).superRefine((envelope, context) => {
+  const targetIds = envelope.selection.targets.map((target) => target.targetId);
+  const instructionIds = envelope.task.instructions.map(
+    (instruction) => instruction.targetId
+  );
+  if (new Set(instructionIds).size !== instructionIds.length || instructionIds.length !== targetIds.length || targetIds.some((targetId) => !instructionIds.includes(targetId))) {
+    context.addIssue({
+      code: "custom",
+      message: "Change instructions must map one-to-one to selection targets.",
+      path: ["task", "instructions"]
+    });
+  }
+  const total = envelope.task.instructions.reduce(
+    (characters, instruction) => characters + instruction.instruction.length,
+    0
+  );
+  if (total > MAX_ANNOTATION_INSTRUCTION_CHARACTERS) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined change instructions exceed the task limit.",
+      path: ["task", "instructions"]
+    });
+  }
+});
+var spotTaskEnvelopeSchema = import_zod2.z.union([
+  spotAskTaskEnvelopeSchema,
+  spotChangeTaskEnvelopeSchema
+]);
+var askAnswerWarningSchema = import_zod2.z.strictObject({
+  code: import_zod2.z.enum(ASK_ANSWER_WARNING_CODES)
+});
+var askExecutorAnswerWarningSchema = import_zod2.z.strictObject({
+  code: import_zod2.z.enum(ASK_EXECUTOR_ANSWER_WARNING_CODES)
+});
+var askDraftCitationSchema = import_zod2.z.strictObject({
+  handleId: contextualAskOpaqueIdSchema,
+  startLine: import_zod2.z.number().int().positive(),
+  endLine: import_zod2.z.number().int().positive()
+}).refine((citation) => citation.endLine >= citation.startLine, {
+  message: "Citation endLine must not precede startLine."
+});
+var draftCitationListSchema = import_zod2.z.array(askDraftCitationSchema).max(limits.maximumSources);
+var draftParagraphBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("paragraph"),
+  text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+  citations: draftCitationListSchema
+});
+var draftListBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("list"),
+  items: import_zod2.z.array(
+    import_zod2.z.strictObject({
+      text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+      citations: draftCitationListSchema
+    })
+  ).min(1).max(limits.maximumAnswerBlocks)
+});
+var draftCodeBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("code"),
+  code: import_zod2.z.string().min(1).max(limits.maximumAnswerCharacters),
+  language: contextualAskBoundedText(limits.maximumLanguageCharacters).optional(),
+  citations: draftCitationListSchema
+});
+var askAnswerDraftBlockSchema = import_zod2.z.discriminatedUnion("kind", [
+  draftParagraphBlockSchema,
+  draftListBlockSchema,
+  draftCodeBlockSchema
+]);
+function draftCharacters(blocks) {
+  return blocks.reduce((total, block) => {
+    if (block.kind === "paragraph") return total + block.text.length;
+    if (block.kind === "code") return total + block.code.length;
+    return total + block.items.reduce((itemTotal, item) => itemTotal + item.text.length, 0);
+  }, 0);
+}
+var askAnswerDraftSchema = import_zod2.z.strictObject({
+  blocks: import_zod2.z.array(askAnswerDraftBlockSchema).min(1).max(limits.maximumAnswerBlocks),
+  warnings: import_zod2.z.array(askExecutorAnswerWarningSchema).max(limits.maximumAnswerBlocks)
+}).superRefine((answer, context) => {
+  if (draftCharacters(answer.blocks) > limits.maximumAnswerCharacters) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined answer text exceeds the answer limit.",
+      path: ["blocks"]
+    });
+  }
+  const citations = answer.blocks.flatMap(
+    (block) => block.kind === "list" ? block.items.flatMap((item) => item.citations) : block.citations
+  );
+  if (citations.length === 0 && !answer.warnings.some((warning) => warning.code === "insufficient-evidence")) {
+    context.addIssue({
+      code: "custom",
+      message: "An uncited answer draft must declare insufficient evidence.",
+      path: ["warnings"]
+    });
+  }
+  const distinct = new Set(
+    citations.map(
+      (citation) => `${citation.handleId}:${String(citation.startLine)}:${String(citation.endLine)}`
+    )
+  );
+  if (distinct.size > limits.maximumSources) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer references exceed the source limit.",
+      path: ["blocks"]
+    });
+  }
+});
+var sourceIdListSchema = import_zod2.z.array(contextualAskOpaqueIdSchema).max(limits.maximumSources);
+var paragraphBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("paragraph"),
+  text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+  sourceIds: sourceIdListSchema
+});
+var listBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("list"),
+  items: import_zod2.z.array(
+    import_zod2.z.strictObject({
+      text: contextualAskBoundedText(limits.maximumAnswerCharacters),
+      sourceIds: sourceIdListSchema
+    })
+  ).min(1).max(limits.maximumAnswerBlocks)
+});
+var codeBlockSchema = import_zod2.z.strictObject({
+  kind: import_zod2.z.literal("code"),
+  code: import_zod2.z.string().min(1).max(limits.maximumAnswerCharacters),
+  language: contextualAskBoundedText(limits.maximumLanguageCharacters).optional(),
+  sourceIds: sourceIdListSchema
+});
+var askAnswerBlockSchema = import_zod2.z.discriminatedUnion("kind", [
+  paragraphBlockSchema,
+  listBlockSchema,
+  codeBlockSchema
+]);
+var askSourceReferenceSchema = import_zod2.z.strictObject({
+  sourceId: contextualAskOpaqueIdSchema,
+  label: contextualAskBoundedText(limits.maximumLabelCharacters),
+  relativePath: contextualAskRelativePathSchema,
+  fileId: contextualAskOpaqueIdSchema,
+  startLine: import_zod2.z.number().int().positive(),
+  endLine: import_zod2.z.number().int().positive(),
+  confidence: import_zod2.z.enum(ASK_SOURCE_CONFIDENCES),
+  targetIds: import_zod2.z.array(contextualAskOpaqueIdSchema).min(1).max(limits.maximumTargets),
+  sourceVersion: contextualAskBoundedText(limits.maximumIdCharacters).optional(),
+  contentHash: contentHashSchema
+}).superRefine((source, context) => {
+  if (source.endLine < source.startLine) {
+    context.addIssue({
+      code: "custom",
+      message: "Source endLine must not precede startLine.",
+      path: ["endLine"]
+    });
+  }
+  if (new Set(source.targetIds).size !== source.targetIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Source target IDs must be unique.",
+      path: ["targetIds"]
+    });
+  }
+});
+function resultBlockCharacters(blocks) {
+  return blocks.reduce((total, block) => {
+    if (block.kind === "paragraph") return total + block.text.length;
+    if (block.kind === "code") return total + block.code.length;
+    return total + block.items.reduce((itemTotal, item) => itemTotal + item.text.length, 0);
+  }, 0);
+}
+var askAnswerResultSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  jobId: contextualAskOpaqueIdSchema,
+  selectionId: contextualAskOpaqueIdSchema,
+  contextHash: contentHashSchema,
+  executor: import_zod2.z.strictObject({
+    executorId: contextualAskOpaqueIdSchema,
+    kind: import_zod2.z.enum(CONTEXTUAL_ASK_EXECUTOR_KINDS),
+    label: contextualAskBoundedText(limits.maximumLabelCharacters),
+    modelLabel: contextualAskBoundedText(limits.maximumLabelCharacters)
+  }),
+  blocks: import_zod2.z.array(askAnswerBlockSchema).min(1).max(limits.maximumAnswerBlocks),
+  sources: import_zod2.z.array(askSourceReferenceSchema).max(limits.maximumSources),
+  warnings: import_zod2.z.array(askAnswerWarningSchema).max(limits.maximumAnswerBlocks),
+  createdAt: import_zod2.z.iso.datetime(),
+  expiresAt: import_zod2.z.iso.datetime()
+}).superRefine((answer, context) => {
+  if (Date.parse(answer.expiresAt) <= Date.parse(answer.createdAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer expiry must follow creation.",
+      path: ["expiresAt"]
+    });
+  }
+  if (resultBlockCharacters(answer.blocks) > limits.maximumAnswerCharacters) {
+    context.addIssue({
+      code: "custom",
+      message: "Combined answer text exceeds the answer limit.",
+      path: ["blocks"]
+    });
+  }
+  const sourceIds = answer.sources.map((source) => source.sourceId);
+  if (new Set(sourceIds).size !== sourceIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer source IDs must be unique.",
+      path: ["sources"]
+    });
+  }
+  const available = new Set(sourceIds);
+  const references = answer.blocks.flatMap(
+    (block) => block.kind === "list" ? block.items.flatMap((item) => item.sourceIds) : block.sourceIds
+  );
+  if (references.length === 0 && !answer.warnings.some((warning) => warning.code === "insufficient-evidence")) {
+    context.addIssue({
+      code: "custom",
+      message: "An uncited answer must declare insufficient evidence.",
+      path: ["warnings"]
+    });
+  }
+  if (references.some((sourceId) => !available.has(sourceId))) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer blocks reference an unknown source ID.",
+      path: ["blocks"]
+    });
+  }
+  if (sourceIds.some((sourceId) => !references.includes(sourceId))) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer sources must be referenced by at least one block.",
+      path: ["sources"]
+    });
+  }
+});
+var contextualAskExecutorCapabilitySchema = import_zod2.z.strictObject({
+  executorId: contextualAskOpaqueIdSchema,
+  kind: import_zod2.z.enum(CONTEXTUAL_ASK_EXECUTOR_KINDS),
+  label: contextualAskBoundedText(limits.maximumLabelCharacters),
+  requestedModelLabel: contextualAskBoundedText(limits.maximumLabelCharacters),
+  effectiveModelLabel: contextualAskBoundedText(limits.maximumLabelCharacters),
+  state: import_zod2.z.enum(CONTEXTUAL_ASK_EXECUTOR_STATES),
+  providerDataConsentRequired: import_zod2.z.boolean(),
+  readOnlyProven: import_zod2.z.boolean(),
+  errorCode: import_zod2.z.enum(CONTEXTUAL_ASK_ERROR_CODES).optional()
+}).superRefine((executor, context) => {
+  if (executor.state === "ready" && (!executor.readOnlyProven || executor.errorCode !== void 0) || executor.state !== "ready" && executor.errorCode === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Executor capability fields are inconsistent."
+    });
+  }
+});
+var contextualAskCapabilitySchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  enabled: import_zod2.z.boolean(),
+  executors: import_zod2.z.array(contextualAskExecutorCapabilitySchema).max(limits.maximumExecutors),
+  safety: import_zod2.z.strictObject({
+    selectionRequired: import_zod2.z.literal(true),
+    singleTurn: import_zod2.z.literal(true),
+    writesAllowed: import_zod2.z.literal(false),
+    historyStored: import_zod2.z.literal(false)
+  }),
+  checkedAt: import_zod2.z.iso.datetime()
+}).superRefine((capability, context) => {
+  if (!capability.enabled && capability.executors.length > 0 || new Set(capability.executors.map((executor) => executor.executorId)).size !== capability.executors.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Contextual Ask capability fields are inconsistent.",
+      path: ["executors"]
+    });
+  }
+});
+
+// src/protocol/contextual-ask.ts
+var import_zod3 = require("zod");
+var limits2 = CONTEXTUAL_ASK_LIMITS;
+var timestampSchema = import_zod3.z.iso.datetime();
+var contextualAskCapabilityRequestSchema = import_zod3.z.strictObject({});
+var askJobCreateRequestSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  requestId: contextualAskOpaqueIdSchema,
+  envelope: spotAskTaskEnvelopeSchema,
+  executorId: contextualAskOpaqueIdSchema,
+  providerDataConsent: import_zod3.z.literal(true)
+});
+var askJobActionRequestSchema = import_zod3.z.strictObject({});
+var askJobEventsRequestSchema = import_zod3.z.strictObject({
+  afterSequence: import_zod3.z.number().int().nonnegative().optional()
+});
+var askJobExecutorSnapshotSchema = import_zod3.z.strictObject({
+  executorId: contextualAskOpaqueIdSchema,
+  kind: import_zod3.z.enum(CONTEXTUAL_ASK_EXECUTOR_KINDS),
+  label: contextualAskBoundedText(limits2.maximumLabelCharacters),
+  modelLabel: contextualAskBoundedText(limits2.maximumLabelCharacters)
+});
+var askJobSnapshotSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  jobId: contextualAskOpaqueIdSchema,
+  selectionId: contextualAskOpaqueIdSchema,
+  status: import_zod3.z.enum(ASK_JOB_STATUSES),
+  executor: askJobExecutorSnapshotSchema,
+  phaseMessage: contextualAskBoundedText(
+    limits2.maximumPhaseMessageCharacters
+  ).optional(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  canCancel: import_zod3.z.boolean(),
+  errorCode: import_zod3.z.enum(CONTEXTUAL_ASK_ERROR_CODES).optional()
+}).superRefine((snapshot, context) => {
+  if (Date.parse(snapshot.updatedAt) < Date.parse(snapshot.createdAt)) {
+    context.addIssue({
+      code: "custom",
+      message: "Job updatedAt must not precede createdAt.",
+      path: ["updatedAt"]
+    });
+  }
+  const cancellable = ["queued", "authorizing", "running"].includes(snapshot.status);
+  if (snapshot.canCancel !== cancellable) {
+    context.addIssue({
+      code: "custom",
+      message: "Job canCancel does not match its status.",
+      path: ["canCancel"]
+    });
+  }
+  if (snapshot.status === "failed" && snapshot.errorCode === void 0 || snapshot.status === "failed" && snapshot.errorCode === "ASK_CANCELLED" || snapshot.status === "cancelled" && snapshot.errorCode !== "ASK_CANCELLED" || snapshot.status !== "failed" && snapshot.status !== "cancelled" && snapshot.errorCode !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Job errorCode does not match its terminal status.",
+      path: ["errorCode"]
+    });
+  }
+});
+var askJobResultResponseSchema = import_zod3.z.strictObject({
+  snapshot: askJobSnapshotSchema,
+  result: askAnswerResultSchema.optional()
+}).superRefine((response, context) => {
+  const answered = response.snapshot.status === "answered";
+  if (answered !== (response.result !== void 0)) {
+    context.addIssue({
+      code: "custom",
+      message: "Only an answered job must contain an answer result.",
+      path: ["result"]
+    });
+    return;
+  }
+  if (response.result !== void 0 && (response.result.jobId !== response.snapshot.jobId || response.result.selectionId !== response.snapshot.selectionId || response.result.executor.executorId !== response.snapshot.executor.executorId)) {
+    context.addIssue({
+      code: "custom",
+      message: "Answer result identity does not match the job snapshot.",
+      path: ["result"]
+    });
+  }
+});
+var askJobEventBaseShape = {
+  schemaVersion: import_zod3.z.literal(CONTEXTUAL_ASK_SCHEMA_VERSION),
+  sequence: import_zod3.z.number().int().positive(),
+  jobId: contextualAskOpaqueIdSchema,
+  status: import_zod3.z.enum(ASK_JOB_STATUSES),
+  timestamp: timestampSchema
+};
+var askJobSnapshotEventSchema = import_zod3.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod3.z.literal("snapshot"),
+  snapshot: askJobSnapshotSchema
+});
+var askJobPhaseEventSchema = import_zod3.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod3.z.literal("phase"),
+  message: contextualAskBoundedText(limits2.maximumPhaseMessageCharacters)
+});
+var askReadSourceActivitySchema = import_zod3.z.strictObject({
+  kind: import_zod3.z.literal("source"),
+  sourceId: contextualAskOpaqueIdSchema,
+  relativePath: contextualAskRelativePathSchema
+});
+var askReadFileCountActivitySchema = import_zod3.z.strictObject({
+  kind: import_zod3.z.literal("file-count"),
+  bucket: import_zod3.z.enum(ASK_FILE_COUNT_BUCKETS)
+});
+var askJobReadActivityEventSchema = import_zod3.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod3.z.literal("read-activity"),
+  activity: import_zod3.z.discriminatedUnion("kind", [
+    askReadSourceActivitySchema,
+    askReadFileCountActivitySchema
+  ]),
+  state: import_zod3.z.enum(ASK_READ_ACTIVITY_STATES)
+});
+var askJobAnswerReadyEventSchema = import_zod3.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod3.z.literal("answer-ready")
+});
+var askJobErrorEventSchema = import_zod3.z.strictObject({
+  ...askJobEventBaseShape,
+  type: import_zod3.z.literal("error"),
+  errorCode: import_zod3.z.enum(CONTEXTUAL_ASK_ERROR_CODES)
+});
+var askJobEventSchema = import_zod3.z.discriminatedUnion("type", [
+  askJobSnapshotEventSchema,
+  askJobPhaseEventSchema,
+  askJobReadActivityEventSchema,
+  askJobAnswerReadyEventSchema,
+  askJobErrorEventSchema
+]).superRefine((event, context) => {
+  if (event.type === "snapshot" && (event.snapshot.jobId !== event.jobId || event.snapshot.status !== event.status)) {
+    context.addIssue({
+      code: "custom",
+      message: "Snapshot event identity does not match its envelope.",
+      path: ["snapshot"]
+    });
+  }
+  if (event.type === "read-activity" && event.status !== "running") {
+    context.addIssue({
+      code: "custom",
+      message: "Read activity is only valid while a job is running.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "phase" && ["answered", "cancelled", "failed"].includes(event.status)) {
+    context.addIssue({
+      code: "custom",
+      message: "Phase events cannot report a terminal state.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "answer-ready" && event.status !== "answered") {
+    context.addIssue({
+      code: "custom",
+      message: "Answer-ready must report the answered state.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "error" && !["failed", "cancelled"].includes(event.status)) {
+    context.addIssue({
+      code: "custom",
+      message: "Error events must report a terminal error state.",
+      path: ["status"]
+    });
+  }
+  if (event.type === "error" && (event.status === "cancelled" && event.errorCode !== "ASK_CANCELLED" || event.status === "failed" && event.errorCode === "ASK_CANCELLED")) {
+    context.addIssue({
+      code: "custom",
+      message: "Error event code does not match its status.",
+      path: ["errorCode"]
+    });
+  }
+});
+
+// src/protocol/endpoints.ts
+var SPOTPATCH_API_BASE = "/__spotpatch/v1";
+var SPOTPATCH_TOKEN_HEADER = "X-SpotPatch-Token";
+var SPOTPATCH_ENDPOINTS = Object.freeze({
+  bootstrap: `${SPOTPATCH_API_BASE}/bootstrap`,
+  sourceContext: `${SPOTPATCH_API_BASE}/source-context`,
+  openEditor: `${SPOTPATCH_API_BASE}/open-editor`,
+  dataFlowComponentReport: `${SPOTPATCH_API_BASE}/data-flow/component-report`,
+  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`,
+  askCapability: `${SPOTPATCH_API_BASE}/ask/capability`,
+  askJobs: `${SPOTPATCH_API_BASE}/ask/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`,
+  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 getAskJobEndpoint(jobId, action, options = {}) {
+  const endpoint = `${SPOTPATCH_ENDPOINTS.askJobs}/${encodeURIComponent(jobId)}/${action}`;
+  if (action !== "events" && options.afterSequence !== void 0) {
+    throw new RangeError("afterSequence is only valid for the events endpoint.");
+  }
+  if (options.afterSequence === void 0) return endpoint;
+  if (!Number.isSafeInteger(options.afterSequence) || options.afterSequence < 0) {
+    throw new RangeError("afterSequence must be a non-negative safe integer.");
+  }
+  return `${endpoint}?afterSequence=${String(options.afterSequence)}`;
+}
+
+// src/contextual-ask-node.ts
+function adaptChangeEnvelopeToSpotAnnotationV3(envelope) {
+  const change = spotChangeTaskEnvelopeSchema.parse(envelope);
+  const instructions = new Map(
+    change.task.instructions.map((instruction) => [
+      instruction.targetId,
+      instruction.instruction
+    ])
+  );
+  const firstTarget = change.selection.targets[0];
+  if (firstTarget === void 0) {
+    throw new TypeError("A Change envelope must contain at least one target.");
+  }
+  const targets = change.selection.targets.map(({ targetId, page, ...target }) => {
+    const instruction = instructions.get(targetId);
+    if (instruction === void 0) {
+      throw new TypeError("A Change target must have an instruction.");
+    }
+    return { ...target, page, instruction };
+  });
+  const annotation = spotAnnotationSchema.parse({
+    schemaVersion: 3,
+    id: change.taskId,
+    locale: change.selection.locale,
+    page: firstTarget.page,
+    targets,
+    createdAt: change.createdAt
+  });
+  return annotation;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASK_ANSWER_WARNING_CODES,
+  ASK_EXECUTOR_ANSWER_WARNING_CODES,
+  ASK_FILE_COUNT_BUCKETS,
+  ASK_JOB_STATUSES,
+  ASK_READ_ACTIVITY_STATES,
+  ASK_SOURCE_CONFIDENCES,
+  CONTEXTUAL_ASK_ERROR_CODES,
+  CONTEXTUAL_ASK_EXECUTOR_KINDS,
+  CONTEXTUAL_ASK_EXECUTOR_STATES,
+  CONTEXTUAL_ASK_LIMITS,
+  CONTEXTUAL_ASK_PERMISSION_PROFILE,
+  CONTEXTUAL_ASK_SCHEMA_VERSION,
+  SPOTPATCH_ENDPOINTS,
+  SPOTPATCH_TOKEN_HEADER,
+  adaptChangeEnvelopeToSpotAnnotationV3,
+  askAnswerBlockSchema,
+  askAnswerDraftBlockSchema,
+  askAnswerDraftSchema,
+  askAnswerResultSchema,
+  askAnswerWarningSchema,
+  askDraftCitationSchema,
+  askDraftOriginSchema,
+  askJobActionRequestSchema,
+  askJobCreateRequestSchema,
+  askJobEventSchema,
+  askJobEventsRequestSchema,
+  askJobResultResponseSchema,
+  askJobSnapshotSchema,
+  askSourceReferenceSchema,
+  contextualAskCapabilityRequestSchema,
+  contextualAskCapabilitySchema,
+  contextualAskExecutorCapabilitySchema,
+  contextualAskExecutorPreferenceSchema,
+  contextualAskOptionsSchema,
+  getAskJobEndpoint,
+  spotAskTaskEnvelopeSchema,
+  spotChangeTaskEnvelopeSchema,
+  spotSelectionContextSchema,
+  spotSelectionTargetSchema,
+  spotTaskEnvelopeSchema
+});
+//# sourceMappingURL=contextual-ask-node.cjs.map