@vercel/factory 0.0.14 → 0.0.16

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":";;;;;;;;;;AAgCA,MAAM,uBAAuB,EAAE,aAAa;CAC1C,eAAe;CACf,IAAI,EACD,OAAO,CAAC,CACR,MAAM,yBAAyB,CAAC,CAChC,SAAS,mDAAmD;CAC/D,UAAU,aAAa,SAAS,mDAAmD;CACnF,WAAW;CACX,UAAU,sBAAsB,SAAS,sDAAsD;CAC/F,UAAU,gBAAgB,SACxB,4EACF;CACA,WAAW,kBAAkB,SAAS,4CAA4C;AACpF,CAAC;AA8CD,SAAS,iBACP,UACoB;CACpB,MAAM,WAAW,0BAA0B,QAAQ;CACnD,IAAI,CAAC,kBAAkB,SAAS,SAAS,SAAS,OAAO,GACvD,MAAM,IAAI,MAAM,yDAAyD;CAC3E,OAAO;AACT;AAEA,SAAS,wBACP,UACA,SACkC;CAClC,IAAI,QAAQ,KAAK,OAAO,SAAS,MAAM,QAAQ,KAAK,YAAY,SAAS,SACvE,MAAM,IAAI,MACR,gBAAgB,QAAQ,GAAG,2BAA2B,SAAS,GAAG,GAAG,SAAS,SAChF;CAEF,MAAM,OAAO,gBAAgB,gBAAgB,MAAM,QAAQ,OAAO,CAAC;CACnE,MAAM,UAAU,gBAAgB,OAC7B,SAAS,iBAAiB,SAAS,QAAA,CAAS,MAAM,gBAAgB,IAAI,CAAC,CAC1E;CACA,IAAI,CAAC,kBAAkB,MAAM,OAAO,GAClC,MAAM,IAAI,MACR,mHACF;CAEF,OAAO,gBAAgB;EACrB,GAAG;EACH,MAAM,SAAS;EACf;CACF,CAAC;AACH;AAEA,SAAS,uBACP,QACA,OACkB;CAClB,MAAM,OAAO,gBAAgB,gBAAgB,MAAM,KAAK,CAAC;CACzD,MAAM,SAAS,OAAO,MAAM,gBAAgB,IAAI,CAAC;CACjD,MAAM,YAAY,gBAAgB,MAAM,MAAM;CAC9C,IAAI,CAAC,kBAAkB,MAAM,SAAS,GACpC,MAAM,IAAI,MACR,2FACF;CAEF,OAAO,gBAAgB,MAAM;AAC/B;AAEA,SAAS,iBAAiB,UAA2B,WAAkC;CACrF,OAAO,YAAY,WAAW,QAAQ,CAAC,CACpC,OAAO,KAAK,UAAU;EAAC,SAAS;EAAI,SAAS;EAAS;CAAS,CAAC,CAAC,CAAC,CAClE,OAAO,KAAK;AACjB;;AAGA,eAAsB,wBACpB,SAIA,WACkC;CAClC,MAAM,WAAW,sBAAsB,MAAM,QAAQ,QAAQ;CAC7D,MAAM,OAAO,MAAM,QAAQ,OAAO,MAAM,IAAI,QAAQ,KAAK,MAAM;CAC/D,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,KAAK,UAAU,QAAQ,GAC1D,MAAM,IAAI,MAAM,mCAAmC;CACrD,IACE,CAAE,MAAM,QAAQ,OAAO,SAAS,IAAI;EAClC,WAAW,QAAQ;EACnB,UAAU,KAAK;EACf;CACF,CAAC,GAED,OAAO;CACT,MAAM,KAAK,iBAAiB,UAAU,SAAS;CAC/C,MAAM,SAAS,MAAM,QAAQ,OAAO,gBAAgB,IAAI,wBAAwB,EAAE;CAClF,IAAI,CAAC,QAAQ,OAAO;CACpB,MAAM,SAAS,qBAAqB,MAAM,OAAO,KAAK;CACtD,IACE,OAAO,OAAO,MACd,OAAO,aAAa,KAAK,MACzB,OAAO,cAAc,aACrB,CAAC,kBAAkB,OAAO,UAAU,QAAQ,GAE5C,MAAM,IAAI,MAAM,gDAAgD;CAClE,OAAO,uBAAuB,QAAQ,gBAAgB,OAAO,QAAQ;AACvE;;AAGA,eAAsB,mBAIpB,SACqD;CACrD,MAAM,EAAE,QAAQ,gBAAgB,QAAQ,UAAU;CAClD,MAAM,WAAW,iBAAiB,QAAQ,QAAQ;CAClD,MAAM,SAAS,OAAO;CACtB,MAAM,WAAW,sBAAsB,MAAM,QAAQ,QAAQ;CAC7D,MAAM,YAAY,2BAA2B,MAAM,QAAQ,SAAS;CACpE,MAAM,EAAE,QAAQ,YAAY,qBAAqB,MAAM,QAAQ,IAAI;CACnE,MAAM,WAAW,YAA2B;EAC1C,MAAM,OAAO,MAAM,OAAO,MAAM,IAAI,MAAM;EAC1C,IAAI,CAAC,QAAQ,KAAK,OAAO,UAAU,CAAC,kBAAkB,KAAK,KAAK,UAAU,QAAQ,GAChF,MAAM,IAAI,MAAM,QAAQ,OAAO,2BAA2B,SAAS,GAAG,GAAG,SAAS,SAAS;EAE7F,IAAI,KAAK,UAAU,aACjB,MAAM,IAAI,MAAM,kBAAkB,OAAO,+BAA+B;EAC1E,OAAO;CACT;CACA,MAAM,aAAa,SAAwB,KAAK,UAAU,eAAe,KAAK,UAAU;CACxF,MAAM,cAAc,cAAqC,iBAAiB,UAAU,SAAS;CAC7F,MAAM,gBAAgB,OAAgB,cAA+C;EACnF,MAAM,SAAS,qBAAqB,MAAM,KAAK;EAC/C,IACE,OAAO,OAAO,WAAW,SAAS,KAClC,OAAO,aAAa,UACpB,OAAO,cAAc,aACrB,CAAC,kBAAkB,OAAO,UAAU,QAAQ,GAE5C,MAAM,IAAI,MACR,2FACF;EAEF,OAAO,uBAAuB,gBAAgB,OAAO,QAAQ;CAC/D;CAEA,IAAI,OAAO,MAAM,SAAS;CAC1B,IAAI,QAAQ,oBAAoB,KAAA,GAAW;EACzC,MAAM,QAAQ,MAAM,OAAO,SAAS,QAAQ;GAAE;GAAW,UAAU;EAAO,CAAC,EAAA,CAAG;EAC9E,IAAI,MAAM,OAAO,QAAQ,iBACvB,MAAM,IAAI,MAAM,0CAA0C;EAC5D,IAAI,MAAM,wBAAwB,UAAU,IAAI;CAClD;CACA,IAAI;CACJ,IAAI,UAAU,IAAI,GAAG;EACnB,MAAM,QAAQ,MAAM,OAAO,SAAS,QAAQ;GAAE;GAAW,UAAU;EAAO,CAAC,EAAA,CAAG;EAC9E,IAAI,CAAC,MAAM,OAAO,EAAE,QAAQ,OAAO;EACnC,wBAAwB,UAAU,IAAI;EACtC,MAAM,SAAS,MAAM,OAAO,IAAI,wBAAwB,WAAW,KAAK,EAAE,CAAC;EAC3E,IAAI,CAAC,QACH,MAAM,IAAI,MACR,kBAAkB,OAAO,oDAC3B;EACF,aAAa,OAAO,OAAO,KAAK,EAAE;EAClC,oBAAoB,KAAK;CAC3B;CACA,MAAM,UAAU,MAAM,OAAO,SAAS,MAAM;EAC1C;EACA,MAAM;GAAE;GAAQ;EAAQ;EACxB,SAAS,QAAQ;EACjB,GAAI,sBAAsB,KAAA,IAAY,CAAC,IAAI,EAAE,kBAAkB,KAAK;CACtE,CAAC;CACD,IAAI,CAAC,SAAS,OAAO,EAAE,QAAQ,OAAO;CACtC,MAAM,EAAE,OAAO,SAAS,mBAAmB;CAC3C,MAAM,UAAU,wBAAwB,UAAU,cAAc;CAChE,IAAI,QAAQ,oBAAoB,KAAA,KAAa,QAAQ,OAAO,QAAQ,iBAClE,MAAM,IAAI,MAAM,+CAA+C;CAEjE,IAAI,sBAAsB,KAAA,KAAa,QAAQ,OAAO,mBACpD,MAAM,IAAI,MAAM,mEAAmE;CAErF,OAAO,MAAM,SAAS;CACtB,MAAM,KAAK,WAAW,QAAQ,EAAE;CAChC,MAAM,YAAY,OAAO,SAAS,UAAU;EAC1C,WAAW,QAAQ;EACnB,WAAW,YAAY,SAAS,GAAG,GAAG,SAAS;CACjD,CAAC;CACD,MAAM,OAAO,SAAS,YAAY;EAAE;EAAW;CAAM,CAAC;CACtD,MAAM,WAAW,MAAM,OAAO,IAAI,wBAAwB,EAAE;CAC5D,IAAI;CACJ,IAAI,UACF,WAAW,aAAa,SAAS,OAAO,QAAQ,EAAE;MAC7C;EACL,IAAI,sBAAsB,KAAA,KAAa,UAAU,IAAI,GACnD,MAAM,IAAI,MACR,kBAAkB,OAAO,oDAC3B;EAEF,MAAM,MAAM,gBAAgB,MAC1B,MAAM,OAAO;GAAE,MAAM,gBAAgB,IAAI;GAAG,SAAS,gBAAgB,OAAO;EAAE,CAAC,CACjF;EAEA,WAAW,uBAAuB,gBADhB,gBAAgB,MAAM,eAAe,MAAM,gBAAgB,GAAG,CAAC,CACvB,CAAC;EAC3D,MAAM,SAAS,qBAAqB,MAAM;GACxC,eAAA;GACA;GACA,UAAU;GACV,WAAW,QAAQ;GACnB;GACA;GACA,YAAY,QAAQ,+BAAc,IAAI,KAAK,EAAA,CAAE,YAAY,GAAA,CAAI;EAC/D,CAAC;EACD,MAAM,OAAO,SAAS,YAAY;GAAE;GAAW;EAAM,CAAC;EACtD,IAAI;GACF,MAAM,OAAO,OAAO;IAAE,YAAY;IAAwB;IAAI,OAAO;GAAO,CAAC;EAC/E,SAAS,OAAO;GACd,IAAI,EAAE,iBAAiB,oBAAoB,MAAM;GACjD,MAAM,SAAS,MAAM,OAAO,IAAI,wBAAwB,EAAE;GAC1D,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,4CAA4C,EAAE,OAAO,MAAM,CAAC;GACzF,WAAW,aAAa,OAAO,OAAO,QAAQ,EAAE;EAClD;CACF;CAEA,OAAO,MAAM,SAAS;CACtB,MAAM,OAAO,SAAS,YAAY;EAAE;EAAW;CAAM,CAAC;CACtD,MAAM,MAAM;EACV,MAAM,gBAAgB,IAAI;EAC1B,SAAS,gBAAgB,OAAO;EAChC,UAAU,gBAAgB,QAAQ;EAClC;CACF,CAAC;CACD,MAAM,OAAO,SAAS,YAAY;EAAE;EAAW;CAAM,CAAC;CACtD,MAAM,OAAO,SAAS,SAAS;EAAE;EAAW;EAAO,kBAAkB;CAAK,CAAC;CAC3E,OAAO;EAAE,QAAQ;EAAa,WAAW,QAAQ;EAAI;EAAU;CAAU;AAC3E"}

package/dist/task-protocols.d.mts

@@ -0,0 +1,80 @@
+import { JsonValue } from "./schema/work.mjs";
+import "./workflows.mjs";
+import { TaskMessageProtocol, TaskMessageProtocols } from "./schema/task-message.mjs";
+import "./tasks.mjs";
+import { z } from "zod";
+//#region src/task-protocols.d.ts
+/** Validates bounded instructions and explicit context for the supplied assignment protocol. */
+declare const assignmentPayloadSchema: z.ZodObject<{
+  instructions: z.ZodString;
+  context: z.ZodOptional<z.ZodCustom<JsonValue, JsonValue>>;
+}, z.core.$strict>;
+/** Validates a bounded outcome, evidence, and concerns for the supplied handoff protocol. */
+declare const handoffPayloadSchema: z.ZodObject<{
+  outcome: z.ZodEnum<{
+    failed: "failed";
+    completed: "completed";
+    needs_input: "needs_input";
+  }>;
+  summary: z.ZodString;
+  output: z.ZodOptional<z.ZodCustom<JsonValue, JsonValue>>;
+  artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    kind: z.ZodString;
+    ref: z.ZodString;
+  }, z.core.$strict>>>;
+  concerns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  deviations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/** Validated assignment instructions and optional bounded context. */
+type AssignmentPayload = z.infer<typeof assignmentPayloadSchema>;
+/** Validated handoff outcome, evidence, concerns, and deviations. */
+type HandoffPayload = z.infer<typeof handoffPayloadSchema>;
+/** Standard exact `assignment@1` protocol definition. */
+declare const assignmentTaskMessageProtocol: Readonly<TaskMessageProtocol<z.ZodObject<{
+  instructions: z.ZodString;
+  context: z.ZodOptional<z.ZodCustom<JsonValue, JsonValue>>;
+}, z.core.$strict>, "assignment", 1>>;
+/** Standard exact `handoff@1` protocol definition. */
+declare const handoffTaskMessageProtocol: Readonly<TaskMessageProtocol<z.ZodObject<{
+  outcome: z.ZodEnum<{
+    failed: "failed";
+    completed: "completed";
+    needs_input: "needs_input";
+  }>;
+  summary: z.ZodString;
+  output: z.ZodOptional<z.ZodCustom<JsonValue, JsonValue>>;
+  artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    kind: z.ZodString;
+    ref: z.ZodString;
+  }, z.core.$strict>>>;
+  concerns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  deviations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, "handoff", 1>>;
+/** Replaceable protocol definitions, not mandatory message vocabulary. */
+declare const standardTaskMessageProtocols: readonly (Readonly<TaskMessageProtocol<z.ZodObject<{
+  instructions: z.ZodString;
+  context: z.ZodOptional<z.ZodCustom<JsonValue, JsonValue>>;
+}, z.core.$strict>, "assignment", 1>> | Readonly<TaskMessageProtocol<z.ZodObject<{
+  outcome: z.ZodEnum<{
+    failed: "failed";
+    completed: "completed";
+    needs_input: "needs_input";
+  }>;
+  summary: z.ZodString;
+  output: z.ZodOptional<z.ZodCustom<JsonValue, JsonValue>>;
+  artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    kind: z.ZodString;
+    ref: z.ZodString;
+  }, z.core.$strict>>>;
+  concerns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  deviations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, "handoff", 1>>)[];
+/** One of the supplied standard Task-message protocol definitions. */
+type StandardTaskMessageProtocol = (typeof standardTaskMessageProtocols)[number];
+/** Registry type containing the supplied standard Task-message protocols. */
+type DefaultTaskMessageProtocols = TaskMessageProtocols<StandardTaskMessageProtocol>;
+/** Creates a registry containing the supplied `assignment@1` and `handoff@1` protocols. */
+declare function createDefaultTaskMessageProtocols(): DefaultTaskMessageProtocols;
+//#endregion
+export { AssignmentPayload, DefaultTaskMessageProtocols, HandoffPayload, StandardTaskMessageProtocol, assignmentPayloadSchema, assignmentTaskMessageProtocol, createDefaultTaskMessageProtocols, handoffPayloadSchema, handoffTaskMessageProtocol, standardTaskMessageProtocols };
+//# sourceMappingURL=task-protocols.d.mts.map

package/dist/task-protocols.mjs

@@ -0,0 +1,47 @@
+import { jsonValueSchema } from "./schema/work.mjs";
+import { defineTaskMessageProtocol, defineTaskMessageProtocols } from "./schema/task-message.mjs";
+import { z } from "zod";
+//#region src/task-protocols.ts
+/** Validates bounded instructions and explicit context for the supplied assignment protocol. */
+const assignmentPayloadSchema = z.strictObject({
+	instructions: z.string().min(1).max(16e3).describe("Bounded instructions for the recipient's delegated scope."),
+	context: jsonValueSchema.optional().describe("Optional explicit context; not implicit access to another Task's data.")
+});
+/** Validates a bounded outcome, evidence, and concerns for the supplied handoff protocol. */
+const handoffPayloadSchema = z.strictObject({
+	outcome: z.enum([
+		"completed",
+		"failed",
+		"needs_input"
+	]).describe("Reported outcome; a message never changes Task lifecycle by itself."),
+	summary: z.string().min(1).max(8e3).describe("Summary of work and its result."),
+	output: jsonValueSchema.optional().describe("Bounded result; the receiving workflow validates the required output contract."),
+	artifacts: z.array(z.strictObject({
+		kind: z.string().min(1).max(64).describe("Application-defined artifact kind."),
+		ref: z.string().min(1).max(2048).describe("Opaque artifact reference; receiving this reference grants no read authority.")
+	})).max(32).readonly().describe("References to evidence and large outputs; not embedded artifact contents."),
+	concerns: z.array(z.string().min(1).max(2048)).max(32).readonly().describe("Findings or concerns requiring the scope owner's attention."),
+	deviations: z.array(z.string().min(1).max(2048)).max(32).readonly().describe("Departures from the assignment or expected approach.")
+});
+/** Standard exact `assignment@1` protocol definition. */
+const assignmentTaskMessageProtocol = defineTaskMessageProtocol({
+	id: "assignment",
+	version: 1,
+	payload: assignmentPayloadSchema
+});
+/** Standard exact `handoff@1` protocol definition. */
+const handoffTaskMessageProtocol = defineTaskMessageProtocol({
+	id: "handoff",
+	version: 1,
+	payload: handoffPayloadSchema
+});
+/** Replaceable protocol definitions, not mandatory message vocabulary. */
+const standardTaskMessageProtocols = Object.freeze([assignmentTaskMessageProtocol, handoffTaskMessageProtocol]);
+/** Creates a registry containing the supplied `assignment@1` and `handoff@1` protocols. */
+function createDefaultTaskMessageProtocols() {
+	return defineTaskMessageProtocols(standardTaskMessageProtocols);
+}
+//#endregion
+export { assignmentPayloadSchema, assignmentTaskMessageProtocol, createDefaultTaskMessageProtocols, handoffPayloadSchema, handoffTaskMessageProtocol, standardTaskMessageProtocols };
+
+//# sourceMappingURL=task-protocols.mjs.map

package/dist/task-protocols.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-protocols.mjs","names":[],"sources":["../src/task-protocols.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  defineTaskMessageProtocol,\n  defineTaskMessageProtocols,\n  type TaskMessageProtocols,\n} from \"./schema/task-message\";\nimport { jsonValueSchema } from \"./schema/work\";\n\n/** Validates bounded instructions and explicit context for the supplied assignment protocol. */\nexport const assignmentPayloadSchema = z.strictObject({\n  instructions: z\n    .string()\n    .min(1)\n    .max(16_000)\n    .describe(\"Bounded instructions for the recipient's delegated scope.\"),\n  context: jsonValueSchema\n    .optional()\n    .describe(\"Optional explicit context; not implicit access to another Task's data.\"),\n});\n\n/** Validates a bounded outcome, evidence, and concerns for the supplied handoff protocol. */\nexport const handoffPayloadSchema = z.strictObject({\n  outcome: z\n    .enum([\"completed\", \"failed\", \"needs_input\"])\n    .describe(\"Reported outcome; a message never changes Task lifecycle by itself.\"),\n  summary: z.string().min(1).max(8000).describe(\"Summary of work and its result.\"),\n  output: jsonValueSchema\n    .optional()\n    .describe(\"Bounded result; the receiving workflow validates the required output contract.\"),\n  artifacts: z\n    .array(\n      z.strictObject({\n        kind: z.string().min(1).max(64).describe(\"Application-defined artifact kind.\"),\n        ref: z\n          .string()\n          .min(1)\n          .max(2048)\n          .describe(\n            \"Opaque artifact reference; receiving this reference grants no read authority.\",\n          ),\n      }),\n    )\n    .max(32)\n    .readonly()\n    .describe(\"References to evidence and large outputs; not embedded artifact contents.\"),\n  concerns: z\n    .array(z.string().min(1).max(2048))\n    .max(32)\n    .readonly()\n    .describe(\"Findings or concerns requiring the scope owner's attention.\"),\n  deviations: z\n    .array(z.string().min(1).max(2048))\n    .max(32)\n    .readonly()\n    .describe(\"Departures from the assignment or expected approach.\"),\n});\n\n/** Validated assignment instructions and optional bounded context. */\nexport type AssignmentPayload = z.infer<typeof assignmentPayloadSchema>;\n/** Validated handoff outcome, evidence, concerns, and deviations. */\nexport type HandoffPayload = z.infer<typeof handoffPayloadSchema>;\n\n/** Standard exact `assignment@1` protocol definition. */\nexport const assignmentTaskMessageProtocol = defineTaskMessageProtocol({\n  id: \"assignment\",\n  version: 1,\n  payload: assignmentPayloadSchema,\n});\n\n/** Standard exact `handoff@1` protocol definition. */\nexport const handoffTaskMessageProtocol = defineTaskMessageProtocol({\n  id: \"handoff\",\n  version: 1,\n  payload: handoffPayloadSchema,\n});\n\n/** Replaceable protocol definitions, not mandatory message vocabulary. */\nexport const standardTaskMessageProtocols = Object.freeze([\n  assignmentTaskMessageProtocol,\n  handoffTaskMessageProtocol,\n]);\n\n/** One of the supplied standard Task-message protocol definitions. */\nexport type StandardTaskMessageProtocol = (typeof standardTaskMessageProtocols)[number];\n/** Registry type containing the supplied standard Task-message protocols. */\nexport type DefaultTaskMessageProtocols = TaskMessageProtocols<StandardTaskMessageProtocol>;\n\n/** Creates a registry containing the supplied `assignment@1` and `handoff@1` protocols. */\nexport function createDefaultTaskMessageProtocols(): DefaultTaskMessageProtocols {\n  return defineTaskMessageProtocols(standardTaskMessageProtocols);\n}\n"],"mappings":";;;;;AASA,MAAa,0BAA0B,EAAE,aAAa;CACpD,cAAc,EACX,OAAO,CAAC,CACR,IAAI,CAAC,CAAC,CACN,IAAI,IAAM,CAAC,CACX,SAAS,2DAA2D;CACvE,SAAS,gBACN,SAAS,CAAC,CACV,SAAS,wEAAwE;AACtF,CAAC;;AAGD,MAAa,uBAAuB,EAAE,aAAa;CACjD,SAAS,EACN,KAAK;EAAC;EAAa;EAAU;CAAa,CAAC,CAAC,CAC5C,SAAS,qEAAqE;CACjF,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAI,CAAC,CAAC,SAAS,iCAAiC;CAC/E,QAAQ,gBACL,SAAS,CAAC,CACV,SAAS,gFAAgF;CAC5F,WAAW,EACR,MACC,EAAE,aAAa;EACb,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,SAAS,oCAAoC;EAC7E,KAAK,EACF,OAAO,CAAC,CACR,IAAI,CAAC,CAAC,CACN,IAAI,IAAI,CAAC,CACT,SACC,+EACF;CACJ,CAAC,CACH,CAAC,CACA,IAAI,EAAE,CAAC,CACP,SAAS,CAAC,CACV,SAAS,2EAA2E;CACvF,UAAU,EACP,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAClC,IAAI,EAAE,CAAC,CACP,SAAS,CAAC,CACV,SAAS,6DAA6D;CACzE,YAAY,EACT,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAClC,IAAI,EAAE,CAAC,CACP,SAAS,CAAC,CACV,SAAS,sDAAsD;AACpE,CAAC;;AAQD,MAAa,gCAAgC,0BAA0B;CACrE,IAAI;CACJ,SAAS;CACT,SAAS;AACX,CAAC;;AAGD,MAAa,6BAA6B,0BAA0B;CAClE,IAAI;CACJ,SAAS;CACT,SAAS;AACX,CAAC;;AAGD,MAAa,+BAA+B,OAAO,OAAO,CACxD,+BACA,0BACF,CAAC;;AAQD,SAAgB,oCAAiE;CAC/E,OAAO,2BAA2B,4BAA4B;AAChE"}

package/dist/tasks.d.mts

@@ -0,0 +1,17 @@
+import { ApprovalPolicy, ApprovalPriority, ApprovalRule, ApprovalSubject, allowByDefaultApprovalPolicy, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, requiresApproval } from "./approval.mjs";
+import { AnswerId, TaskId, answerIdSchema, taskIdSchema } from "./schema/id.mjs";
+import { ExecutionReference, MessageWaitingTask, NeedsHumanTask, SucceededTask, Task, TaskApproval, TaskKind, TaskOrigin, TaskQuestion, TaskState, TaskUsage, executionReferenceSchema, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, standardTaskKinds, taskApprovalSchema, taskExecutionRepositoryIdsSchema, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskUsageSchema } from "./schema/task.mjs";
+import { MAX_TASK_INBOX_PENDING, SendTaskMessageInput, TaskInbox, TaskMessage, TaskMessageClaim, TaskMessageDiscard, TaskMessageForProtocol, TaskMessageId, TaskMessageOperationId, TaskMessagePrincipal, TaskMessageProcessing, TaskMessageProtocol, TaskMessageProtocolBinding, TaskMessageProtocolBindingInput, TaskMessageProtocolInput, TaskMessageProtocolInputPayload, TaskMessageProtocolStoredPayload, TaskMessageProtocols, defineTaskMessageProtocol, defineTaskMessageProtocols, parseTaskMessageProtocolBinding, sendTaskMessageInputSchema, taskInboxSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema } from "./schema/task-message.mjs";
+import { AssertTaskMessageClaimInput, ClaimTaskMessageInput, ClaimTaskMessageResult, CompleteTaskMessageInput, CreateTaskMessageStoreOptions, DiscardTaskMessageInput, TaskMessageAction, TaskMessageAuthorizationError, TaskMessageAuthorizationInput, TaskMessageAuthorize, TaskMessageConflictError, TaskMessageEffectKeyInput, TaskMessageError, TaskMessageLeaseError, TaskMessageLookupInput, TaskMessageRecipientInput, TaskMessageSendInput, TaskMessageSourceFenceError, TaskMessageStore, createTaskMessageStore, taskBoundMessagePolicy } from "./store/task-messages.mjs";
+import { MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, TaskGraph, TaskGraphNode, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema } from "./schema/task-graph.mjs";
+import { AdmitTaskGraphInput, AssertTaskAdmissionInput, CreateTaskGraphStoreOptions, SetTaskGraphDependenciesInput, TaskGraphConflictError, TaskGraphNodeRef, TaskGraphStore, assertTaskAdmission, createTaskGraphStore } from "./store/task-graphs.mjs";
+import { TaskEffect, TaskEffectKey, TaskEffectReference, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema } from "./schema/task-effect.mjs";
+import { CreateTaskEffectStoreOptions, RecordTaskEffectInput, ResolveTaskEffectInput, TaskEffectLookupInput, TaskEffectStore, createTaskEffectStore } from "./store/task-effects.mjs";
+import { CompleteTaskWorkInput, CompleteWorkflowTaskWorkInput, CreateTaskWorkStoreOptions, ResumeTaskWorkInput, TaskWorkCompletionFence, TaskWorkStore, TaskWorkStores, TaskWorkUsage, WaitForTaskMessagesInput, createTaskWorkStore } from "./store/task-work.mjs";
+import { AnswerEvent, answerEventSchema } from "./schema/answer.mjs";
+import { AgentSessionBinding, AnswerEventConflictError, AnswerQuestionInput, AnswerQuestionResult, ApprovalDecision, ApprovalError, CreateTaskInput, RejectionDecision, RootTaskOrigin, TaskAttemptConflictError, TaskPatch, TaskTransitionArguments, TaskTransitionOptions } from "./store/engine.mjs";
+import { ApprovalAccess, ApprovalAccessDecisionInput, ApprovalAccessError, ApprovalAccessOptions, ApprovalAccessStores, createApprovalAccess } from "./approval-access.mjs";
+import { taskInitialState, taskTransitions } from "./schema/transitions.mjs";
+import { ProcessTaskMessageOptions, ProcessTaskMessageResult, TaskMessageProcessingStores, processTaskMessage, readTaskMessageDecision } from "./task-message-processing.mjs";
+import { AssignmentPayload, DefaultTaskMessageProtocols, HandoffPayload, StandardTaskMessageProtocol, assignmentPayloadSchema, assignmentTaskMessageProtocol, createDefaultTaskMessageProtocols, handoffPayloadSchema, handoffTaskMessageProtocol, standardTaskMessageProtocols } from "./task-protocols.mjs";
+export { type AdmitTaskGraphInput, type AgentSessionBinding, type AnswerEvent, AnswerEventConflictError, type AnswerId, type AnswerQuestionInput, type AnswerQuestionResult, type ApprovalAccess, type ApprovalAccessDecisionInput, ApprovalAccessError, type ApprovalAccessOptions, type ApprovalAccessStores, type ApprovalDecision, ApprovalError, type ApprovalPolicy, type ApprovalPriority, type ApprovalRule, type ApprovalSubject, type AssertTaskAdmissionInput, type AssertTaskMessageClaimInput, type AssignmentPayload, type ClaimTaskMessageInput, type ClaimTaskMessageResult, type CompleteTaskMessageInput, type CompleteTaskWorkInput, type CompleteWorkflowTaskWorkInput, type CreateTaskEffectStoreOptions, type CreateTaskGraphStoreOptions, type CreateTaskInput, type CreateTaskMessageStoreOptions, type CreateTaskWorkStoreOptions, type DefaultTaskMessageProtocols, type DiscardTaskMessageInput, type ExecutionReference, type HandoffPayload, MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, MAX_TASK_INBOX_PENDING, type MessageWaitingTask, type NeedsHumanTask, type ProcessTaskMessageOptions, type ProcessTaskMessageResult, type RecordTaskEffectInput, type RejectionDecision, type ResolveTaskEffectInput, type ResumeTaskWorkInput, type RootTaskOrigin, type SendTaskMessageInput, type SetTaskGraphDependenciesInput, type StandardTaskMessageProtocol, type SucceededTask, type Task, type TaskApproval, TaskAttemptConflictError, type TaskEffect, type TaskEffectKey, type TaskEffectLookupInput, type TaskEffectReference, type TaskEffectStore, type TaskGraph, TaskGraphConflictError, type TaskGraphNode, type TaskGraphNodeRef, type TaskGraphStore, type TaskId, type TaskInbox, type TaskKind, type TaskMessage, type TaskMessageAction, TaskMessageAuthorizationError, type TaskMessageAuthorizationInput, type TaskMessageAuthorize, type TaskMessageClaim, TaskMessageConflictError, type TaskMessageDiscard, type TaskMessageEffectKeyInput, TaskMessageError, type TaskMessageForProtocol, type TaskMessageId, TaskMessageLeaseError, type TaskMessageLookupInput, type TaskMessageOperationId, type TaskMessagePrincipal, type TaskMessageProcessing, type TaskMessageProcessingStores, type TaskMessageProtocol, type TaskMessageProtocolBinding, type TaskMessageProtocolBindingInput, type TaskMessageProtocolInput, type TaskMessageProtocolInputPayload, type TaskMessageProtocolStoredPayload, type TaskMessageProtocols, type TaskMessageRecipientInput, type TaskMessageSendInput, TaskMessageSourceFenceError, type TaskMessageStore, type TaskOrigin, type TaskPatch, type TaskQuestion, type TaskState, type TaskTransitionArguments, type TaskTransitionOptions, type TaskUsage, type TaskWorkCompletionFence, type TaskWorkStore, type TaskWorkStores, type TaskWorkUsage, type WaitForTaskMessagesInput, allowByDefaultApprovalPolicy, answerEventSchema, answerIdSchema, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, assertTaskAdmission, assignmentPayloadSchema, assignmentTaskMessageProtocol, createApprovalAccess, createDefaultTaskMessageProtocols, createTaskEffectStore, createTaskGraphStore, createTaskMessageStore, createTaskWorkStore, defineTaskMessageProtocol, defineTaskMessageProtocols, executionReferenceSchema, handoffPayloadSchema, handoffTaskMessageProtocol, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, parseTaskMessageProtocolBinding, processTaskMessage, readTaskMessageDecision, requiresApproval, sendTaskMessageInputSchema, standardTaskKinds, standardTaskMessageProtocols, taskApprovalSchema, taskBoundMessagePolicy, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema, taskExecutionRepositoryIdsSchema, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema, taskIdSchema, taskInboxSchema, taskInitialState, taskKindSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, taskUsageSchema };

package/dist/tasks.mjs

@@ -0,0 +1,17 @@
+import { answerIdSchema, taskIdSchema } from "./schema/id.mjs";
+import { executionReferenceSchema, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, standardTaskKinds, taskApprovalSchema, taskExecutionRepositoryIdsSchema, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskUsageSchema } from "./schema/task.mjs";
+import { allowByDefaultApprovalPolicy, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, requiresApproval } from "./approval.mjs";
+import { taskInitialState, taskTransitions } from "./schema/transitions.mjs";
+import { ApprovalAccessError, createApprovalAccess } from "./approval-access.mjs";
+import { answerEventSchema } from "./schema/answer.mjs";
+import { MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema } from "./schema/task-graph.mjs";
+import { MAX_TASK_INBOX_PENDING, defineTaskMessageProtocol, defineTaskMessageProtocols, parseTaskMessageProtocolBinding, sendTaskMessageInputSchema, taskInboxSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema } from "./schema/task-message.mjs";
+import { taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema } from "./schema/task-effect.mjs";
+import { TaskGraphConflictError, assertTaskAdmission, createTaskGraphStore } from "./store/task-graphs.mjs";
+import { TaskMessageAuthorizationError, TaskMessageConflictError, TaskMessageError, TaskMessageLeaseError, TaskMessageSourceFenceError, createTaskMessageStore, taskBoundMessagePolicy } from "./store/task-messages.mjs";
+import { createTaskWorkStore } from "./store/task-work.mjs";
+import { createTaskEffectStore } from "./store/task-effects.mjs";
+import { processTaskMessage, readTaskMessageDecision } from "./task-message-processing.mjs";
+import { assignmentPayloadSchema, assignmentTaskMessageProtocol, createDefaultTaskMessageProtocols, handoffPayloadSchema, handoffTaskMessageProtocol, standardTaskMessageProtocols } from "./task-protocols.mjs";
+import { AnswerEventConflictError, ApprovalError, TaskAttemptConflictError } from "./store/engine.mjs";
+export { AnswerEventConflictError, ApprovalAccessError, ApprovalError, MAX_TASK_GRAPH_DEPENDENCIES, MAX_TASK_GRAPH_NODES, MAX_TASK_INBOX_PENDING, TaskAttemptConflictError, TaskGraphConflictError, TaskMessageAuthorizationError, TaskMessageConflictError, TaskMessageError, TaskMessageLeaseError, TaskMessageSourceFenceError, allowByDefaultApprovalPolicy, answerEventSchema, answerIdSchema, approvalPolicySchema, approvalPrioritySchema, approvalRuleSchema, assertTaskAdmission, assignmentPayloadSchema, assignmentTaskMessageProtocol, createApprovalAccess, createDefaultTaskMessageProtocols, createTaskEffectStore, createTaskGraphStore, createTaskMessageStore, createTaskWorkStore, defineTaskMessageProtocol, defineTaskMessageProtocols, executionReferenceSchema, handoffPayloadSchema, handoffTaskMessageProtocol, harnessSchema, isMessageWaitingTask, isNeedsHumanTask, isSucceededTask, parseTaskMessageProtocolBinding, processTaskMessage, readTaskMessageDecision, requiresApproval, sendTaskMessageInputSchema, standardTaskKinds, standardTaskMessageProtocols, taskApprovalSchema, taskBoundMessagePolicy, taskEffectKeySchema, taskEffectReferenceSchema, taskEffectSchema, taskExecutionRepositoryIdsSchema, taskGraphAdmissionSchema, taskGraphDependenciesSchema, taskGraphNodeSchema, taskGraphSchema, taskIdSchema, taskInboxSchema, taskInitialState, taskKindSchema, taskMessageClaimSchema, taskMessageDiscardSchema, taskMessageIdSchema, taskMessageInput, taskMessageOperationIdSchema, taskMessagePrincipalSchema, taskMessageProcessingSchema, taskMessageProtocolBindingSchema, taskMessageProtocolSchema, taskMessageReservationSchema, taskMessageSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, taskUsageSchema };

package/dist/vercel-git.d.mts

@@ -0,0 +1,53 @@
+import { RepositorySlug } from "./schema/repository.mjs";
+import { GitHubGitTransport } from "./github-transfer.mjs";
+import { NetworkPolicy, Sandbox } from "@vercel/sandbox";
+//#region src/vercel-git.d.ts
+type TrustedGitSandbox = Pick<Sandbox, "cwd" | "runCommand" | "writeFiles" | "readFile" | "updateNetworkPolicy" | "stop">;
+/** Exact creation request for a fresh Vercel-managed trusted Git publication Sandbox. */
+interface VercelManagedGitHubSandboxCreateInput {
+  source: {
+    type: "git";
+    url: string;
+  };
+  __source_credentials: true;
+  __commitAs: {
+    name: string;
+    email: string;
+  };
+  networkPolicy: NetworkPolicy;
+  persistent: false;
+  resources: {
+    vcpus: 6;
+  };
+  runtime: "node24";
+  timeout: number;
+}
+/** Repository and access level used to mint one trusted Git transport token. */
+interface VercelGitHubTokenInput {
+  repository: RepositorySlug;
+  access: "read" | "write";
+}
+/** Configures fresh trusted sandboxes and repository-scoped Git tokens. */
+interface VercelGitHubGitTransportOptions {
+  /** Reads must mint contents:read credentials; writes are confined to the supplied repository. */
+  token(input: VercelGitHubTokenInput): Promise<string>;
+  /** Creates a fresh sandbox, without a snapshot, repository, or running agent. */
+  createSandbox?: () => Promise<TrustedGitSandbox>;
+}
+/** Configures Vercel-managed Git reads and signed publication. */
+interface VercelManagedGitHubGitTransportOptions {
+  /** Attribution metadata supplied for managed signed commits. */
+  commitIdentity: {
+    name: string;
+    email: string;
+  };
+  /** Creates one unnamed Sandbox from the exact managed credential request. */
+  createSandbox?: (input: VercelManagedGitHubSandboxCreateInput) => Promise<TrustedGitSandbox>;
+}
+/** Transfer Git objects through fresh trusted sandboxes; credentials never reach an agent sandbox. */
+declare function createVercelGitHubGitTransport(options: VercelGitHubGitTransportOptions): GitHubGitTransport;
+/** Use fresh Vercel-managed trusted Sandboxes for Git reads and signed publication. */
+declare function createVercelManagedGitHubGitTransport(options: VercelManagedGitHubGitTransportOptions): GitHubGitTransport;
+//#endregion
+export { VercelGitHubGitTransportOptions, VercelGitHubTokenInput, VercelManagedGitHubGitTransportOptions, VercelManagedGitHubSandboxCreateInput, createVercelGitHubGitTransport, createVercelManagedGitHubGitTransport };
+//# sourceMappingURL=vercel-git.d.mts.map