@vercel/factory 0.0.13 → 0.0.15

package/dist/task-graph-view.d.mts

@@ -0,0 +1,264 @@
+import { JsonValue } from "./schema/work.mjs";
+import { Task, TaskKind } from "./schema/task.mjs";
+import "./workflows.mjs";
+import "./tasks.mjs";
+import { z } from "zod";
+//#region src/task-graph-view.d.ts
+declare const taskGraphViewSchema: z.ZodObject<{
+  rootTaskId: z.ZodNullable<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>;
+  currentTaskId: z.ZodOptional<z.ZodNullable<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>>;
+  nodes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    task: Omit<z.ZodObject<{
+      schemaVersion: z.ZodLiteral<1>;
+      id: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+      repositoryIds: z.ZodReadonly<z.ZodTuple<[z.ZodType<`repo_${string}`, string, z.core.$ZodTypeInternals<`repo_${string}`, string>>], z.ZodType<`repo_${string}`, string, z.core.$ZodTypeInternals<`repo_${string}`, string>>>>;
+      kind: z.ZodType<TaskKind, unknown, z.core.$ZodTypeInternals<TaskKind, unknown>>;
+      area: z.ZodOptional<z.ZodString>;
+      state: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        stalled: "stalled";
+        verifying: "verifying";
+        succeeded: "succeeded";
+        failed: "failed";
+        needs_human: "needs_human";
+        cancelled: "cancelled";
+      }>;
+      approval: z.ZodOptional<z.ZodEnum<{
+        required: "required";
+        granted: "granted";
+        denied: "denied";
+      }>>;
+      origin: z.ZodObject<{
+        signalId: z.ZodOptional<z.ZodType<`sig_${string}`, string, z.core.$ZodTypeInternals<`sig_${string}`, string>>>;
+        operator: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>;
+      work: z.ZodObject<{
+        title: z.ZodString;
+        input: z.ZodCustom<JsonValue, JsonValue>;
+        completionCriteria: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        workflow: z.core.$ZodBranded<z.ZodObject<{
+          id: z.ZodString;
+          version: z.ZodNumber;
+        }, z.core.$strict>, "WorkflowBinding", "out">;
+        route: z.ZodOptional<z.core.$ZodBranded<z.ZodObject<{
+          id: z.ZodString;
+          version: z.ZodNumber;
+        }, z.core.$strict>, "AgentRouteBinding", "out">>;
+      }, z.core.$strict>;
+      workResult: z.ZodOptional<z.ZodObject<{
+        output: z.ZodCustom<JsonValue, JsonValue>;
+        completedAt: z.ZodISODateTime;
+      }, z.core.$strict>>;
+      waitingForMessages: z.ZodOptional<z.ZodBoolean>;
+      workflowPhase: z.ZodOptional<z.ZodString>;
+      rootTaskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+      parentTaskId: z.ZodOptional<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>;
+      parentTaskAttempt: z.ZodOptional<z.ZodNumber>;
+      replyTo: z.ZodObject<{
+        channel: z.ZodString;
+        address: z.ZodString;
+      }, z.core.$strict>;
+      pendingCommunicationReceiptIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<`rcpt_${string}`, string, z.core.$ZodTypeInternals<`rcpt_${string}`, string>>>>>;
+      failureReceiptId: z.ZodOptional<z.ZodType<`rcpt_${string}`, string, z.core.$ZodTypeInternals<`rcpt_${string}`, string>>>;
+      attempt: z.ZodNumber;
+      execution: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        sessionId: z.ZodString;
+        environmentId: z.ZodOptional<z.ZodString>;
+        harness: z.ZodOptional<z.ZodString>;
+        traceId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>;
+      lastProgressAt: z.ZodOptional<z.ZodISODateTime>;
+      stalledAt: z.ZodOptional<z.ZodISODateTime>;
+      stalledReason: z.ZodOptional<z.ZodString>;
+      needsHumanAction: z.ZodOptional<z.ZodString>;
+      needsHumanNotifiedAt: z.ZodOptional<z.ZodISODateTime>;
+      reservedUsd: z.ZodOptional<z.ZodNumber>;
+      reservedAt: z.ZodOptional<z.ZodISODateTime>;
+      usage: z.ZodOptional<z.ZodObject<{
+        costUsd: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+        steps: z.ZodRecord<z.ZodString, z.ZodNumber>;
+      }, z.core.$strict>>;
+      settledUsd: z.ZodOptional<z.ZodNumber>;
+      question: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        options: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        closingOptions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        answer: z.ZodOptional<z.ZodString>;
+        answeredBy: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>;
+      questionTaskId: z.ZodOptional<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>;
+      answerEventIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<`ans_${string}`, string, z.core.$ZodTypeInternals<`ans_${string}`, string>>>>>;
+      changeId: z.ZodOptional<z.ZodType<`chg_${string}`, string, z.core.$ZodTypeInternals<`chg_${string}`, string>>>;
+      reportRef: z.ZodOptional<z.ZodString>;
+      createdAt: z.ZodISODateTime;
+      updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>, keyof z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> & z.ZodType<Task, {
+      schemaVersion: 1;
+      id: string;
+      repositoryIds: readonly [string, ...string[]];
+      kind: unknown;
+      state: "queued" | "running" | "stalled" | "verifying" | "succeeded" | "failed" | "needs_human" | "cancelled";
+      origin: {
+        signalId?: string | undefined;
+        operator?: string | undefined;
+      };
+      work: {
+        title: string;
+        input: JsonValue;
+        completionCriteria: readonly string[];
+        workflow: {
+          id: string;
+          version: number;
+        };
+        route?: {
+          id: string;
+          version: number;
+        } | undefined;
+      };
+      rootTaskId: string;
+      replyTo: {
+        channel: string;
+        address: string;
+      };
+      attempt: number;
+      createdAt: string;
+      updatedAt: string;
+      area?: string | undefined;
+      approval?: "required" | "granted" | "denied" | undefined;
+      workResult?: {
+        output: JsonValue;
+        completedAt: string;
+      } | undefined;
+      waitingForMessages?: boolean | undefined;
+      workflowPhase?: string | undefined;
+      parentTaskId?: string | undefined;
+      parentTaskAttempt?: number | undefined;
+      pendingCommunicationReceiptIds?: readonly string[] | undefined;
+      failureReceiptId?: string | undefined;
+      execution?: {
+        provider: string;
+        sessionId: string;
+        environmentId?: string | undefined;
+        harness?: string | undefined;
+        traceId?: string | undefined;
+      } | undefined;
+      lastProgressAt?: string | undefined;
+      stalledAt?: string | undefined;
+      stalledReason?: string | undefined;
+      needsHumanAction?: string | undefined;
+      needsHumanNotifiedAt?: string | undefined;
+      reservedUsd?: number | undefined;
+      reservedAt?: string | undefined;
+      usage?: {
+        costUsd: number;
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+        steps: Record<string, number>;
+      } | undefined;
+      settledUsd?: number | undefined;
+      question?: {
+        text: string;
+        options: readonly string[];
+        closingOptions?: readonly string[] | undefined;
+        answer?: string | undefined;
+        answeredBy?: string | undefined;
+      } | undefined;
+      questionTaskId?: string | undefined;
+      answerEventIds?: readonly string[] | undefined;
+      changeId?: string | undefined;
+      reportRef?: string | undefined;
+    }, z.core.$ZodTypeInternals<Task, {
+      schemaVersion: 1;
+      id: string;
+      repositoryIds: readonly [string, ...string[]];
+      kind: unknown;
+      state: "queued" | "running" | "stalled" | "verifying" | "succeeded" | "failed" | "needs_human" | "cancelled";
+      origin: {
+        signalId?: string | undefined;
+        operator?: string | undefined;
+      };
+      work: {
+        title: string;
+        input: JsonValue;
+        completionCriteria: readonly string[];
+        workflow: {
+          id: string;
+          version: number;
+        };
+        route?: {
+          id: string;
+          version: number;
+        } | undefined;
+      };
+      rootTaskId: string;
+      replyTo: {
+        channel: string;
+        address: string;
+      };
+      attempt: number;
+      createdAt: string;
+      updatedAt: string;
+      area?: string | undefined;
+      approval?: "required" | "granted" | "denied" | undefined;
+      workResult?: {
+        output: JsonValue;
+        completedAt: string;
+      } | undefined;
+      waitingForMessages?: boolean | undefined;
+      workflowPhase?: string | undefined;
+      parentTaskId?: string | undefined;
+      parentTaskAttempt?: number | undefined;
+      pendingCommunicationReceiptIds?: readonly string[] | undefined;
+      failureReceiptId?: string | undefined;
+      execution?: {
+        provider: string;
+        sessionId: string;
+        environmentId?: string | undefined;
+        harness?: string | undefined;
+        traceId?: string | undefined;
+      } | undefined;
+      lastProgressAt?: string | undefined;
+      stalledAt?: string | undefined;
+      stalledReason?: string | undefined;
+      needsHumanAction?: string | undefined;
+      needsHumanNotifiedAt?: string | undefined;
+      reservedUsd?: number | undefined;
+      reservedAt?: string | undefined;
+      usage?: {
+        costUsd: number;
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+        steps: Record<string, number>;
+      } | undefined;
+      settledUsd?: number | undefined;
+      question?: {
+        text: string;
+        options: readonly string[];
+        closingOptions?: readonly string[] | undefined;
+        answer?: string | undefined;
+        answeredBy?: string | undefined;
+      } | undefined;
+      questionTaskId?: string | undefined;
+      answerEventIds?: readonly string[] | undefined;
+      changeId?: string | undefined;
+      reportRef?: string | undefined;
+    }>>;
+    dependencyTaskIds: z.ZodReadonly<z.ZodArray<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>>;
+    agent: z.ZodNullable<z.ZodString>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+/** An authorized, read-only operator projection of one canonical Task graph. */
+type TaskGraphView = z.infer<typeof taskGraphViewSchema>;
+//#endregion
+export { TaskGraphView, taskGraphViewSchema };
+//# sourceMappingURL=task-graph-view.d.mts.map

package/dist/task-graph-view.mjs

@@ -0,0 +1,17 @@
+import { taskIdSchema } from "./schema/id.mjs";
+import { taskSchema } from "./schema/task.mjs";
+import { z } from "zod";
+//#region src/task-graph-view.ts
+const taskGraphViewSchema = z.strictObject({
+	rootTaskId: taskIdSchema.nullable().describe("Canonical root, or null for a taskless conversation."),
+	currentTaskId: taskIdSchema.nullable().optional().describe("Task currently shown by the entrypoint conversation, or null when it is not in this graph."),
+	nodes: z.array(z.strictObject({
+		task: taskSchema.describe("Current persisted Task snapshot."),
+		dependencyTaskIds: z.array(taskIdSchema).max(255).readonly().describe("Canonical prerequisites, distinct from parent ownership."),
+		agent: z.string().nullable().describe("Exact exposed route agent, or null for workflow-owned or unavailable execution.")
+	})).max(256).readonly().describe("Authorized canonical graph membership, independent of session pagination.")
+}).describe("Read-only operator view of one root Task graph.");
+//#endregion
+export { taskGraphViewSchema };
+
+//# sourceMappingURL=task-graph-view.mjs.map

package/dist/task-graph-view.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-view.mjs","names":[],"sources":["../src/task-graph-view.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { taskIdSchema } from \"./schema/id\";\nimport { taskSchema } from \"./schema/task\";\n\nexport const taskGraphViewSchema = z\n  .strictObject({\n    rootTaskId: taskIdSchema\n      .nullable()\n      .describe(\"Canonical root, or null for a taskless conversation.\"),\n    currentTaskId: taskIdSchema\n      .nullable()\n      .optional()\n      .describe(\n        \"Task currently shown by the entrypoint conversation, or null when it is not in this graph.\",\n      ),\n    nodes: z\n      .array(\n        z.strictObject({\n          task: taskSchema.describe(\"Current persisted Task snapshot.\"),\n          dependencyTaskIds: z\n            .array(taskIdSchema)\n            .max(255)\n            .readonly()\n            .describe(\"Canonical prerequisites, distinct from parent ownership.\"),\n          agent: z\n            .string()\n            .nullable()\n            .describe(\n              \"Exact exposed route agent, or null for workflow-owned or unavailable execution.\",\n            ),\n        }),\n      )\n      .max(256)\n      .readonly()\n      .describe(\"Authorized canonical graph membership, independent of session pagination.\"),\n  })\n  .describe(\"Read-only operator view of one root Task graph.\");\n/** An authorized, read-only operator projection of one canonical Task graph. */\nexport type TaskGraphView = z.infer<typeof taskGraphViewSchema>;\n"],"mappings":";;;;AAIA,MAAa,sBAAsB,EAChC,aAAa;CACZ,YAAY,aACT,SAAS,CAAC,CACV,SAAS,sDAAsD;CAClE,eAAe,aACZ,SAAS,CAAC,CACV,SAAS,CAAC,CACV,SACC,4FACF;CACF,OAAO,EACJ,MACC,EAAE,aAAa;EACb,MAAM,WAAW,SAAS,kCAAkC;EAC5D,mBAAmB,EAChB,MAAM,YAAY,CAAC,CACnB,IAAI,GAAG,CAAC,CACR,SAAS,CAAC,CACV,SAAS,0DAA0D;EACtE,OAAO,EACJ,OAAO,CAAC,CACR,SAAS,CAAC,CACV,SACC,iFACF;CACJ,CAAC,CACH,CAAC,CACA,IAAI,GAAG,CAAC,CACR,SAAS,CAAC,CACV,SAAS,2EAA2E;AACzF,CAAC,CAAC,CACD,SAAS,iDAAiD"}

package/dist/task-message-processing.d.mts

@@ -0,0 +1,60 @@
+import { WorkflowBinding } from "./schema/work.mjs";
+import { Task } from "./schema/task.mjs";
+import { TaskMessageForProtocol, TaskMessageId, TaskMessagePrincipal, TaskMessageProtocol } from "./schema/task-message.mjs";
+import { IsoDateTimeClock } from "./schema/common.mjs";
+import { TaskAttemptRef } from "./schema/execution.mjs";
+import { FactoryStores } from "./store/engine.mjs";
+import { z } from "zod";
+//#region src/task-message-processing.d.ts
+/** Minimal persistence capabilities required to decide and apply one Task message. */
+type TaskMessageProcessingStores = Pick<FactoryStores, "messages" | "tasks" | "workflowRecords">;
+/** Trusted dependencies and pure/effectful callbacks for processing one Task inbox head. */
+interface ProcessTaskMessageOptions<Schema extends z.ZodType, Protocol extends TaskMessageProtocol = TaskMessageProtocol> {
+  readonly stores: TaskMessageProcessingStores;
+  /** Authenticated externally; the message store enforces its configured claim policy. */
+  readonly principal: TaskMessagePrincipal;
+  /** Exact recipient Task attempt authorized to process the inbox head. */
+  readonly task: TaskAttemptRef;
+  /** Refuse a different inbox head before deciding or replaying effects. */
+  readonly expectMessageId?: TaskMessageId;
+  readonly leaseMs: number;
+  readonly workflow: WorkflowBinding;
+  /** Exact protocol required for the claimed message and exposed to typed callbacks. */
+  readonly protocol: Protocol;
+  /** Trusted UTC clock for decision timestamps; defaults to the system clock. */
+  readonly now?: IsoDateTimeClock;
+  /** Must accept its canonical JSON output unchanged. Exclude secrets from the decision contract. */
+  readonly decisionSchema: Schema;
+  /** Pure computation: may run concurrently or repeat until a decision is durably inserted. */
+  decide(context: Readonly<{
+    task: Task;
+    message: TaskMessageForProtocol<Protocol>;
+  }>): Promise<z.input<Schema>>;
+  /**
+   * Honor effectKey for every external write (derive stable subkeys for multiple effects).
+   * Lease checks cannot fence external systems: apply may repeat, overlap, or outlive its claim.
+   * Resolve only after all effects commit; never mutate the decision to select different effects.
+   */
+  apply(context: Readonly<{
+    task: Task;
+    message: TaskMessageForProtocol<Protocol>;
+    decision: z.output<Schema>;
+    effectKey: string;
+  }>): Promise<void>;
+}
+/** Result of finding no claimable work or durably processing one Task message. */
+type ProcessTaskMessageResult<Decision> = {
+  status: "idle";
+} | {
+  status: "processed";
+  messageId: TaskMessageId;
+  decision: Decision;
+  effectKey: string;
+};
+/** Authorized typed inspection; null means no committed decision, not permission to decide for a terminal Task. */
+declare function readTaskMessageDecision<Schema extends z.ZodType>(options: Pick<ProcessTaskMessageOptions<Schema>, "stores" | "principal" | "task" | "workflow" | "decisionSchema">, messageId: TaskMessageId): Promise<z.output<Schema> | null>;
+/** Process one authorized inbox head. Idle means empty or already leased, not necessarily drained. */
+declare function processTaskMessage<Schema extends z.ZodType, Protocol extends TaskMessageProtocol = TaskMessageProtocol>(options: ProcessTaskMessageOptions<Schema, Protocol>): Promise<ProcessTaskMessageResult<z.output<Schema>>>;
+//#endregion
+export { ProcessTaskMessageOptions, ProcessTaskMessageResult, TaskMessageProcessingStores, processTaskMessage, readTaskMessageDecision };
+//# sourceMappingURL=task-message-processing.d.mts.map

package/dist/task-message-processing.mjs

@@ -0,0 +1,200 @@
+import { taskIdSchema } from "./schema/id.mjs";
+import { isoDateTimeSchema, schemaVersionSchema } from "./schema/common.mjs";
+import { jsonValueSchema, workflowBindingSchema } from "./schema/work.mjs";
+import { taskAttemptRefSchema } from "./schema/execution.mjs";
+import { RecordExistsError } from "./store/driver.mjs";
+import { defineTaskMessageProtocol, taskMessageIdSchema, taskMessagePrincipalSchema } from "./schema/task-message.mjs";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { isDeepStrictEqual } from "node:util";
+//#region src/task-message-processing.ts
+const decisionRecordSchema = z.strictObject({
+	schemaVersion: schemaVersionSchema,
+	id: z.string().regex(/^decision_[a-f0-9]{64}$/).describe("Immutable workflow and message decision identity."),
+	toTaskId: taskIdSchema.describe("Authorized recipient Task of the decided message."),
+	messageId: taskMessageIdSchema,
+	workflow: workflowBindingSchema.describe("Exact workflow contract that produced this decision."),
+	decision: jsonValueSchema.describe("Schema-validated bounded decision; never credentials or execution context."),
+	createdAt: isoDateTimeSchema.describe("Timestamp of the first committed decision.")
+});
+function snapshotProtocol(protocol) {
+	const snapshot = defineTaskMessageProtocol(protocol);
+	if (!isDeepStrictEqual(snapshot.binding, protocol.binding)) throw new Error("Task-message protocol binding must match its definition");
+	return snapshot;
+}
+function validateProtocolMessage(protocol, message) {
+	if (message.type.id !== protocol.id || message.type.version !== protocol.version) throw new Error(`Task message ${message.id} requires exact protocol ${protocol.id}@${protocol.version}`);
+	const json = structuredClone(jsonValueSchema.parse(message.payload));
+	const payload = jsonValueSchema.parse((protocol.storedPayload ?? protocol.payload).parse(structuredClone(json)));
+	if (!isDeepStrictEqual(json, payload)) throw new Error("Stored message protocol validation must preserve canonical JSON; provide storedPayload for transforming protocols");
+	return structuredClone({
+		...message,
+		type: protocol.binding,
+		payload
+	});
+}
+function validateStoredDecision(schema, value) {
+	const json = structuredClone(jsonValueSchema.parse(value));
+	const parsed = schema.parse(structuredClone(json));
+	const validated = jsonValueSchema.parse(parsed);
+	if (!isDeepStrictEqual(json, validated)) throw new Error("Decision schema must preserve canonical JSON; non-idempotent transforms are not permitted");
+	return structuredClone(parsed);
+}
+function decisionIdentity(workflow, messageId) {
+	return `decision_${createHash("sha256").update(JSON.stringify([
+		workflow.id,
+		workflow.version,
+		messageId
+	])).digest("hex")}`;
+}
+/** Authorized typed inspection; null means no committed decision, not permission to decide for a terminal Task. */
+async function readTaskMessageDecision(options, messageId) {
+	const workflow = workflowBindingSchema.parse(options.workflow);
+	const task = await options.stores.tasks.get(options.task.taskId);
+	if (!task || !isDeepStrictEqual(task.work.workflow, workflow)) throw new Error("Exact recipient workflow required");
+	if (!await options.stores.messages.get({
+		principal: options.principal,
+		toTaskId: task.id,
+		messageId
+	})) return null;
+	const id = decisionIdentity(workflow, messageId);
+	const stored = await options.stores.workflowRecords.get("taskMessageDecisions", id);
+	if (!stored) return null;
+	const record = decisionRecordSchema.parse(stored.value);
+	if (record.id !== id || record.toTaskId !== task.id || record.messageId !== messageId || !isDeepStrictEqual(record.workflow, workflow)) throw new Error("Stored Task message decision identity mismatch");
+	return validateStoredDecision(options.decisionSchema, record.decision);
+}
+/** Process one authorized inbox head. Idle means empty or already leased, not necessarily drained. */
+async function processTaskMessage(options) {
+	const { stores, decisionSchema, decide, apply } = options;
+	const protocol = snapshotProtocol(options.protocol);
+	const driver = stores.workflowRecords;
+	const workflow = workflowBindingSchema.parse(options.workflow);
+	const principal = taskMessagePrincipalSchema.parse(options.principal);
+	const { taskId, attempt } = taskAttemptRefSchema.parse(options.task);
+	const loadTask = async () => {
+		const task = await stores.tasks.get(taskId);
+		if (!task || task.id !== taskId || !isDeepStrictEqual(task.work.workflow, workflow)) throw new Error(`Task ${taskId} requires exact workflow ${workflow.id}@${workflow.version}`);
+		if (task.state === "cancelled") throw new Error(`Cancelled Task ${taskId} cannot replay message effects`);
+		return task;
+	};
+	const completed = (task) => task.state === "succeeded" || task.state === "failed";
+	const decisionId = (messageId) => decisionIdentity(workflow, messageId);
+	const readDecision = (value, messageId) => {
+		const record = decisionRecordSchema.parse(value);
+		if (record.id !== decisionId(messageId) || record.toTaskId !== taskId || record.messageId !== messageId || !isDeepStrictEqual(record.workflow, workflow)) throw new Error("Stored Task message decision identity does not match its recipient, message, and workflow");
+		return validateStoredDecision(decisionSchema, record.decision);
+	};
+	let task = await loadTask();
+	if (options.expectMessageId !== void 0) {
+		const head = (await stores.messages.pending({
+			principal,
+			toTaskId: taskId
+		}))[0];
+		if (head?.id !== options.expectMessageId) throw new Error("Inbox head differs from expected message");
+		if (head) validateProtocolMessage(protocol, head);
+	}
+	let recoveryMessageId;
+	if (completed(task)) {
+		const head = (await stores.messages.pending({
+			principal,
+			toTaskId: taskId
+		}))[0];
+		if (!head) return { status: "idle" };
+		validateProtocolMessage(protocol, head);
+		const stored = await driver.get("taskMessageDecisions", decisionId(head.id));
+		if (!stored) throw new Error(`Completed Task ${taskId} requires an existing decision for message recovery`);
+		readDecision(stored.value, head.id);
+		recoveryMessageId = head.id;
+	}
+	const claimed = await stores.messages.claim({
+		principal,
+		task: {
+			taskId,
+			attempt
+		},
+		leaseMs: options.leaseMs,
+		...recoveryMessageId === void 0 ? {} : { recoverCompleted: true }
+	});
+	if (!claimed) return { status: "idle" };
+	const { claim, message: claimedMessage } = claimed;
+	const message = validateProtocolMessage(protocol, claimedMessage);
+	if (options.expectMessageId !== void 0 && message.id !== options.expectMessageId) throw new Error("Claimed message differs from expected message");
+	if (recoveryMessageId !== void 0 && message.id !== recoveryMessageId) throw new Error("Claimed message differs from the validated terminal recovery head");
+	task = await loadTask();
+	const id = decisionId(message.id);
+	const effectKey = stores.messages.effectKey({
+		messageId: message.id,
+		operation: `workflow:${workflow.id}@${workflow.version}`
+	});
+	await stores.messages.assertClaim({
+		principal,
+		claim
+	});
+	const existing = await driver.get("taskMessageDecisions", id);
+	let decision;
+	if (existing) decision = readDecision(existing.value, message.id);
+	else {
+		if (recoveryMessageId !== void 0 || completed(task)) throw new Error(`Completed Task ${taskId} requires an existing decision for message recovery`);
+		const raw = jsonValueSchema.parse(await decide({
+			task: structuredClone(task),
+			message: structuredClone(message)
+		}));
+		decision = validateStoredDecision(decisionSchema, jsonValueSchema.parse(decisionSchema.parse(structuredClone(raw))));
+		const record = decisionRecordSchema.parse({
+			schemaVersion: 1,
+			id,
+			toTaskId: taskId,
+			messageId: message.id,
+			workflow,
+			decision,
+			createdAt: (options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))()
+		});
+		await stores.messages.assertClaim({
+			principal,
+			claim
+		});
+		try {
+			await driver.insert({
+				collection: "taskMessageDecisions",
+				id,
+				value: record
+			});
+		} catch (error) {
+			if (!(error instanceof RecordExistsError)) throw error;
+			const winner = await driver.get("taskMessageDecisions", id);
+			if (!winner) throw new Error("Winning Task message decision is missing", { cause: error });
+			decision = readDecision(winner.value, message.id);
+		}
+	}
+	task = await loadTask();
+	await stores.messages.assertClaim({
+		principal,
+		claim
+	});
+	await apply({
+		task: structuredClone(task),
+		message: structuredClone(message),
+		decision: structuredClone(decision),
+		effectKey
+	});
+	await stores.messages.assertClaim({
+		principal,
+		claim
+	});
+	await stores.messages.complete({
+		principal,
+		claim,
+		effectsCommitted: true
+	});
+	return {
+		status: "processed",
+		messageId: message.id,
+		decision,
+		effectKey
+	};
+}
+//#endregion
+export { processTaskMessage, readTaskMessageDecision };
+
+//# sourceMappingURL=task-message-processing.mjs.map

package/dist/task-message-processing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-message-processing.mjs","names":[],"sources":["../src/task-message-processing.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { isDeepStrictEqual } from \"node:util\";\nimport { z } from \"zod\";\nimport {\n  isoDateTimeSchema,\n  schemaVersionSchema,\n  SCHEMA_VERSION,\n  type IsoDateTimeClock,\n} from \"./schema/common\";\nimport { taskAttemptRefSchema, type TaskAttemptRef } from \"./schema/execution\";\nimport { taskIdSchema } from \"./schema/id\";\nimport type { Task } from \"./schema/task\";\nimport {\n  defineTaskMessageProtocol,\n  taskMessageIdSchema,\n  taskMessagePrincipalSchema,\n  type TaskMessage,\n  type TaskMessageForProtocol,\n  type TaskMessageId,\n  type TaskMessagePrincipal,\n  type TaskMessageProtocol,\n} from \"./schema/task-message\";\nimport { jsonValueSchema, workflowBindingSchema, type WorkflowBinding } from \"./schema/work\";\nimport { RecordExistsError } from \"./store/driver\";\nimport type { FactoryStores } from \"./store/engine\";\n\n/** Minimal persistence capabilities required to decide and apply one Task message. */\nexport type TaskMessageProcessingStores = Pick<\n  FactoryStores,\n  \"messages\" | \"tasks\" | \"workflowRecords\"\n>;\n\nconst decisionRecordSchema = z.strictObject({\n  schemaVersion: schemaVersionSchema,\n  id: z\n    .string()\n    .regex(/^decision_[a-f0-9]{64}$/)\n    .describe(\"Immutable workflow and message decision identity.\"),\n  toTaskId: taskIdSchema.describe(\"Authorized recipient Task of the decided message.\"),\n  messageId: taskMessageIdSchema,\n  workflow: workflowBindingSchema.describe(\"Exact workflow contract that produced this decision.\"),\n  decision: jsonValueSchema.describe(\n    \"Schema-validated bounded decision; never credentials or execution context.\",\n  ),\n  createdAt: isoDateTimeSchema.describe(\"Timestamp of the first committed decision.\"),\n});\n\n/** Trusted dependencies and pure/effectful callbacks for processing one Task inbox head. */\nexport interface ProcessTaskMessageOptions<\n  Schema extends z.ZodType,\n  Protocol extends TaskMessageProtocol = TaskMessageProtocol,\n> {\n  readonly stores: TaskMessageProcessingStores;\n  /** Authenticated externally; the message store enforces its configured claim policy. */\n  readonly principal: TaskMessagePrincipal;\n  /** Exact recipient Task attempt authorized to process the inbox head. */\n  readonly task: TaskAttemptRef;\n  /** Refuse a different inbox head before deciding or replaying effects. */\n  readonly expectMessageId?: TaskMessageId;\n  readonly leaseMs: number;\n  readonly workflow: WorkflowBinding;\n  /** Exact protocol required for the claimed message and exposed to typed callbacks. */\n  readonly protocol: Protocol;\n  /** Trusted UTC clock for decision timestamps; defaults to the system clock. */\n  readonly now?: IsoDateTimeClock;\n  /** Must accept its canonical JSON output unchanged. Exclude secrets from the decision contract. */\n  readonly decisionSchema: Schema;\n  /** Pure computation: may run concurrently or repeat until a decision is durably inserted. */\n  decide(\n    context: Readonly<{ task: Task; message: TaskMessageForProtocol<Protocol> }>,\n  ): Promise<z.input<Schema>>;\n  /**\n   * Honor effectKey for every external write (derive stable subkeys for multiple effects).\n   * Lease checks cannot fence external systems: apply may repeat, overlap, or outlive its claim.\n   * Resolve only after all effects commit; never mutate the decision to select different effects.\n   */\n  apply(\n    context: Readonly<{\n      task: Task;\n      message: TaskMessageForProtocol<Protocol>;\n      decision: z.output<Schema>;\n      effectKey: string;\n    }>,\n  ): Promise<void>;\n}\n\n/** Result of finding no claimable work or durably processing one Task message. */\nexport type ProcessTaskMessageResult<Decision> =\n  | { status: \"idle\" }\n  | { status: \"processed\"; messageId: TaskMessageId; decision: Decision; effectKey: string };\n\nfunction snapshotProtocol<Protocol extends TaskMessageProtocol>(\n  protocol: Protocol,\n): Readonly<Protocol> {\n  const snapshot = defineTaskMessageProtocol(protocol);\n  if (!isDeepStrictEqual(snapshot.binding, protocol.binding))\n    throw new Error(\"Task-message protocol binding must match its definition\");\n  return snapshot as Readonly<Protocol>;\n}\n\nfunction validateProtocolMessage<Protocol extends TaskMessageProtocol>(\n  protocol: Protocol,\n  message: TaskMessage,\n): TaskMessageForProtocol<Protocol> {\n  if (message.type.id !== protocol.id || message.type.version !== protocol.version) {\n    throw new Error(\n      `Task message ${message.id} requires exact protocol ${protocol.id}@${protocol.version}`,\n    );\n  }\n  const json = structuredClone(jsonValueSchema.parse(message.payload));\n  const payload = jsonValueSchema.parse(\n    (protocol.storedPayload ?? protocol.payload).parse(structuredClone(json)),\n  );\n  if (!isDeepStrictEqual(json, payload)) {\n    throw new Error(\n      \"Stored message protocol validation must preserve canonical JSON; provide storedPayload for transforming protocols\",\n    );\n  }\n  return structuredClone({\n    ...message,\n    type: protocol.binding,\n    payload,\n  }) as TaskMessageForProtocol<Protocol>;\n}\n\nfunction validateStoredDecision<Schema extends z.ZodType>(\n  schema: Schema,\n  value: unknown,\n): z.output<Schema> {\n  const json = structuredClone(jsonValueSchema.parse(value));\n  const parsed = schema.parse(structuredClone(json));\n  const validated = jsonValueSchema.parse(parsed);\n  if (!isDeepStrictEqual(json, validated)) {\n    throw new Error(\n      \"Decision schema must preserve canonical JSON; non-idempotent transforms are not permitted\",\n    );\n  }\n  return structuredClone(parsed);\n}\n\nfunction decisionIdentity(workflow: WorkflowBinding, messageId: TaskMessageId): string {\n  return `decision_${createHash(\"sha256\")\n    .update(JSON.stringify([workflow.id, workflow.version, messageId]))\n    .digest(\"hex\")}`;\n}\n\n/** Authorized typed inspection; null means no committed decision, not permission to decide for a terminal Task. */\nexport async function readTaskMessageDecision<Schema extends z.ZodType>(\n  options: Pick<\n    ProcessTaskMessageOptions<Schema>,\n    \"stores\" | \"principal\" | \"task\" | \"workflow\" | \"decisionSchema\"\n  >,\n  messageId: TaskMessageId,\n): Promise<z.output<Schema> | null> {\n  const workflow = workflowBindingSchema.parse(options.workflow);\n  const task = await options.stores.tasks.get(options.task.taskId);\n  if (!task || !isDeepStrictEqual(task.work.workflow, workflow))\n    throw new Error(\"Exact recipient workflow required\");\n  if (\n    !(await options.stores.messages.get({\n      principal: options.principal,\n      toTaskId: task.id,\n      messageId,\n    }))\n  )\n    return null;\n  const id = decisionIdentity(workflow, messageId);\n  const stored = await options.stores.workflowRecords.get(\"taskMessageDecisions\", id);\n  if (!stored) return null;\n  const record = decisionRecordSchema.parse(stored.value);\n  if (\n    record.id !== id ||\n    record.toTaskId !== task.id ||\n    record.messageId !== messageId ||\n    !isDeepStrictEqual(record.workflow, workflow)\n  )\n    throw new Error(\"Stored Task message decision identity mismatch\");\n  return validateStoredDecision(options.decisionSchema, record.decision);\n}\n\n/** Process one authorized inbox head. Idle means empty or already leased, not necessarily drained. */\nexport async function processTaskMessage<\n  Schema extends z.ZodType,\n  Protocol extends TaskMessageProtocol = TaskMessageProtocol,\n>(\n  options: ProcessTaskMessageOptions<Schema, Protocol>,\n): Promise<ProcessTaskMessageResult<z.output<Schema>>> {\n  const { stores, decisionSchema, decide, apply } = options;\n  const protocol = snapshotProtocol(options.protocol);\n  const driver = stores.workflowRecords;\n  const workflow = workflowBindingSchema.parse(options.workflow);\n  const principal = taskMessagePrincipalSchema.parse(options.principal);\n  const { taskId, attempt } = taskAttemptRefSchema.parse(options.task);\n  const loadTask = async (): Promise<Task> => {\n    const task = await stores.tasks.get(taskId);\n    if (!task || task.id !== taskId || !isDeepStrictEqual(task.work.workflow, workflow)) {\n      throw new Error(`Task ${taskId} requires exact workflow ${workflow.id}@${workflow.version}`);\n    }\n    if (task.state === \"cancelled\")\n      throw new Error(`Cancelled Task ${taskId} cannot replay message effects`);\n    return task;\n  };\n  const completed = (task: Task): boolean => task.state === \"succeeded\" || task.state === \"failed\";\n  const decisionId = (messageId: TaskMessageId): string => decisionIdentity(workflow, messageId);\n  const readDecision = (value: unknown, messageId: TaskMessageId): z.output<Schema> => {\n    const record = decisionRecordSchema.parse(value);\n    if (\n      record.id !== decisionId(messageId) ||\n      record.toTaskId !== taskId ||\n      record.messageId !== messageId ||\n      !isDeepStrictEqual(record.workflow, workflow)\n    ) {\n      throw new Error(\n        \"Stored Task message decision identity does not match its recipient, message, and workflow\",\n      );\n    }\n    return validateStoredDecision(decisionSchema, record.decision);\n  };\n\n  let task = await loadTask();\n  if (options.expectMessageId !== undefined) {\n    const head = (await stores.messages.pending({ principal, toTaskId: taskId }))[0];\n    if (head?.id !== options.expectMessageId)\n      throw new Error(\"Inbox head differs from expected message\");\n    if (head) validateProtocolMessage(protocol, head);\n  }\n  let recoveryMessageId: TaskMessageId | undefined;\n  if (completed(task)) {\n    const head = (await stores.messages.pending({ principal, toTaskId: taskId }))[0];\n    if (!head) return { status: \"idle\" };\n    validateProtocolMessage(protocol, head);\n    const stored = await driver.get(\"taskMessageDecisions\", decisionId(head.id));\n    if (!stored)\n      throw new Error(\n        `Completed Task ${taskId} requires an existing decision for message recovery`,\n      );\n    readDecision(stored.value, head.id);\n    recoveryMessageId = head.id;\n  }\n  const claimed = await stores.messages.claim({\n    principal,\n    task: { taskId, attempt },\n    leaseMs: options.leaseMs,\n    ...(recoveryMessageId === undefined ? {} : { recoverCompleted: true }),\n  });\n  if (!claimed) return { status: \"idle\" };\n  const { claim, message: claimedMessage } = claimed;\n  const message = validateProtocolMessage(protocol, claimedMessage);\n  if (options.expectMessageId !== undefined && message.id !== options.expectMessageId) {\n    throw new Error(\"Claimed message differs from expected message\");\n  }\n  if (recoveryMessageId !== undefined && message.id !== recoveryMessageId) {\n    throw new Error(\"Claimed message differs from the validated terminal recovery head\");\n  }\n  task = await loadTask();\n  const id = decisionId(message.id);\n  const effectKey = stores.messages.effectKey({\n    messageId: message.id,\n    operation: `workflow:${workflow.id}@${workflow.version}`,\n  });\n  await stores.messages.assertClaim({ principal, claim });\n  const existing = await driver.get(\"taskMessageDecisions\", id);\n  let decision: z.output<Schema>;\n  if (existing) {\n    decision = readDecision(existing.value, message.id);\n  } else {\n    if (recoveryMessageId !== undefined || completed(task)) {\n      throw new Error(\n        `Completed Task ${taskId} requires an existing decision for message recovery`,\n      );\n    }\n    const raw = jsonValueSchema.parse(\n      await decide({ task: structuredClone(task), message: structuredClone(message) }),\n    );\n    const canonical = jsonValueSchema.parse(decisionSchema.parse(structuredClone(raw)));\n    decision = validateStoredDecision(decisionSchema, canonical);\n    const record = decisionRecordSchema.parse({\n      schemaVersion: SCHEMA_VERSION,\n      id,\n      toTaskId: taskId,\n      messageId: message.id,\n      workflow,\n      decision,\n      createdAt: (options.now ?? (() => new Date().toISOString()))(),\n    });\n    await stores.messages.assertClaim({ principal, claim });\n    try {\n      await driver.insert({ collection: \"taskMessageDecisions\", id, value: record });\n    } catch (error) {\n      if (!(error instanceof RecordExistsError)) throw error;\n      const winner = await driver.get(\"taskMessageDecisions\", id);\n      if (!winner) throw new Error(\"Winning Task message decision is missing\", { cause: error });\n      decision = readDecision(winner.value, message.id);\n    }\n  }\n\n  task = await loadTask();\n  await stores.messages.assertClaim({ principal, claim });\n  await apply({\n    task: structuredClone(task),\n    message: structuredClone(message),\n    decision: structuredClone(decision),\n    effectKey,\n  });\n  await stores.messages.assertClaim({ principal, claim });\n  await stores.messages.complete({ principal, claim, effectsCommitted: true });\n  return { status: \"processed\", messageId: message.id, decision, effectKey };\n}\n"],"mappings":"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"}