@vercel/factory 0.0.13 → 0.0.14

package/dist/eve/index.mjs

@@ -1,6 +1,8 @@
-import { i as repositoryIdSchema, o as signalIdSchema, p as vocabularySchema, s as taskIdSchema, t as changeIdSchema } from "../id-DwCihQr4.mjs";
-import { b as taskQuestionSchema, c as findingSchema, i as requiresApproval, o as findingFingerprint, r as defaultApprovalPolicy } from "../approval-CwhTP1XB.mjs";
-import { b as createCoordination, c as dispatchTask, i as levelSchema, t as changeEvidenceSchema } from "../change-CzEAoFVE.mjs";
+import { c as signalIdSchema, h as vocabularySchema, l as taskIdSchema, n as changeIdSchema, o as repositoryIdSchema } from "../id-BLIkCVue.mjs";
+import { l as taskQuestionSchema } from "../task-CcOyOJ3k.mjs";
+import { c as findingSchema, i as requiresApproval, o as findingFingerprint, r as defaultApprovalPolicy } from "../approval-JX2Px9IC.mjs";
+import { c as dispatchTask, i as levelSchema, t as changeEvidenceSchema } from "../change-D2U6v7Ek.mjs";
+import { t as createCoordination } from "../coordination-Cq08hb1l.mjs";
 import { answerReviewComment, readPullRequestHead, readReviewComment, submitPullRequestReview } from "../github.mjs";
 import { z } from "zod";
 import { createHash } from "node:crypto";
@@ -371,8 +373,20 @@ function fetchPullRequestTool(stores, options) {
 	const depth = options.depth ?? 50;
 	return defineTool({
 		description: "Fetch the pull request and the repository's current default branch, then check out the pull request as local branch `pr`. Call this after get_task, before inspecting or testing the change. Returns an exact diff command based on their merge base; use it instead of origin/HEAD.",
-		inputSchema: z.object({ changeId: changeIdSchema.describe("The change under review, from your starting message.") }),
+		inputSchema: z.object({ changeId: changeIdSchema.describe("The Change linked to your Task, returned by get_task.") }),
 		async execute({ changeId }, ctx) {
+			const boundTaskId = taskIdSchema.safeParse(ctx.session?.auth.initiator?.attributes.factoryTaskId);
+			if (boundTaskId.success) {
+				const task = await stores.tasks.get(boundTaskId.data);
+				if (task === null) return {
+					fetched: false,
+					reason: `task ${boundTaskId.data} does not exist`
+				};
+				if (task.changeId !== void 0 && task.changeId !== changeId) return {
+					fetched: false,
+					reason: `change ${changeId} is not linked to task ${boundTaskId.data}`
+				};
+			}
 			const change = await stores.changes.get(changeId);
 			if (change === null) return {
 				fetched: false,
@@ -524,6 +538,15 @@ function delegateAgentTool(stores, options) {
 				const repository = await stores.repositories.get(repositoryId);
 				if (repository === null || !repository.enabled) throw new Error(`Repository ${repositoryId} is not enabled in this factory.`);
 			}
+			const boundChange = changeIdSchema.safeParse(attributes?.factoryChangeId);
+			if (attributes?.factoryChangeId !== void 0 && !boundChange.success) throw new Error("Connector-authenticated change context is invalid.");
+			if (input.changeId !== void 0 && boundChange.success && input.changeId !== boundChange.data) throw new Error("Delegated change does not match the connector-authenticated context.");
+			const changeId = input.changeId ?? (boundChange.success ? boundChange.data : void 0);
+			if (changeId !== void 0) {
+				if (input.repositoryIds.length !== 1) throw new Error("Delegating work on an existing Change requires exactly one repository.");
+				const change = await stores.changes.get(changeId);
+				if (change === null || change.repositoryId !== input.repositoryIds[0] || change.state !== "verifying" && change.state !== "ready") throw new Error(`Change ${changeId} is not an open pull request in the selected repository.`);
+			}
 			if (input.signalId !== void 0) {
 				const signal = await stores.signals.get(input.signalId);
 				if (signal === null) throw new Error(`Signal ${input.signalId} does not exist.`);
@@ -545,7 +568,7 @@ function delegateAgentTool(stores, options) {
 					...input.signalId === void 0 ? {} : { dedupeKey: `route:${input.signalId}:${route.id}` },
 					...input.signalId === void 0 ? { operator } : { signalId: input.signalId }
 				});
-				await Promise.all(coordination.children.filter((child) => child.state === "queued").map((child) => dispatchRouteTask(stores, options, doFetch, route, child, input.changeId, input.brief)));
+				await Promise.all(coordination.children.filter((child) => child.state === "queued").map((child) => dispatchRouteTask(stores, options, doFetch, route, child, changeId, input.brief)));
 				return {
 					taskId: coordination.parent.id,
 					childTaskIds: coordination.children.map(({ id }) => id),
@@ -559,10 +582,10 @@ function delegateAgentTool(stores, options) {
 				kind: route.taskKind,
 				origin: input.signalId !== void 0 ? { signalId: input.signalId } : input.parentTaskId !== void 0 ? { parentTaskId: input.parentTaskId } : { operator },
 				replyTo,
-				changeId: input.changeId,
+				changeId,
 				...input.signalId === void 0 ? {} : { dedupeKey: `route:${input.signalId}:${route.id}` }
 			});
-			const running = task.state === "queued" ? await dispatchRouteTask(stores, options, doFetch, route, task, input.changeId, input.brief) : task;
+			const running = task.state === "queued" ? await dispatchRouteTask(stores, options, doFetch, route, task, changeId, input.brief) : task;
 			return {
 				taskId: running.id,
 				routeId: route.id,
@@ -876,9 +899,9 @@ function recordVerificationTool(stores, options = {}) {
 				recorded: false,
 				reason: `change ${changeId} does not exist`
 			};
-			if (change.state !== "verifying") return {
+			if (change.state !== "verifying" && change.state !== "ready") return {
 				recorded: false,
-				reason: `change is ${change.state}, not verifying; nothing to record`
+				reason: `change is ${change.state}, not open for verification; nothing to record`
 			};
 			const task = await stores.tasks.get(taskId);
 			if (task === null || task.kind !== "verification") return {
@@ -886,20 +909,22 @@ function recordVerificationTool(stores, options = {}) {
 				reason: `${taskId} is not a verification task`
 			};
 			let updatedChange = change;
-			if (verdict === "pass") updatedChange = await stores.changes.transition(changeId, "ready", {
+			if (verdict === "pass" && change.state === "verifying") updatedChange = await stores.changes.transition(changeId, "ready", {
 				patch: {
 					evidence,
 					confidence
 				},
 				reason: summary
 			});
+			else if (verdict === "fail" && change.state === "ready") updatedChange = await stores.changes.transition(changeId, "verifying", { reason: summary });
 			let finished;
 			if (verdict === "pass") {
 				await stores.tasks.transition(taskId, "verifying", { reason: summary });
 				finished = await stores.tasks.transition(taskId, "succeeded");
 			} else finished = await stores.tasks.transition(taskId, "failed", { reason: summary });
-			if (change.taskId !== void 0) {
-				if ((await stores.tasks.get(change.taskId))?.state === "verifying") await stores.tasks.transition(change.taskId, verdict === "pass" ? "succeeded" : "failed", verdict === "pass" ? {} : { reason: `verification failed: ${summary}` }).catch(() => void 0);
+			const sourceTaskId = task.origin.parentTaskId ?? change.taskId;
+			if (sourceTaskId !== void 0) {
+				if ((await stores.tasks.get(sourceTaskId))?.state === "verifying") await stores.tasks.transition(sourceTaskId, verdict === "pass" ? "succeeded" : "failed", verdict === "pass" ? {} : { reason: `verification failed: ${summary}` }).catch(() => void 0);
 			}
 			await options.presentResult?.({
 				taskId,
@@ -944,7 +969,10 @@ async function createAndPresentQuestion(stores, parent, question, presentQuestio
 	});
 	const waiting = await stores.tasks.transition(task.id, "needs_human");
 	try {
-		if (parent.state === "running") await stores.tasks.transition(parent.id, "needs_human", { reason: `waiting for answer to question ${waiting.id}` });
+		if (parent.state === "running") await stores.tasks.transition(parent.id, "needs_human", {
+			reason: `waiting for answer to question ${waiting.id}`,
+			questionTaskId: waiting.id
+		});
 		await presentQuestion(waiting);
 	} catch (error) {
 		if ((await stores.tasks.get(parent.id))?.state === "needs_human") await stores.tasks.transition(parent.id, "queued", { reason: `delivery of question ${waiting.id} failed` });
@@ -1097,39 +1125,24 @@ function factoryTools(stores, options = {}) {
 			}
 		}),
 		answer_question: defineTool({
-			description: "Record the authenticated user's answer to a waiting question and requeue the parent specialist task.",
+			description: "Record the authenticated user's answer to a waiting question and requeue the parent specialist task. A blocked parent task id is also accepted and resolves its persisted QuestionTask id.",
 			inputSchema: z.object({
 				questionTaskId: taskIdSchema,
 				answer: z.string().min(1).max(4e3)
 			}),
 			async execute({ questionTaskId, answer }, ctx) {
-				const questionTask = await stores.tasks.get(questionTaskId);
-				if (questionTask === null || questionTask.kind !== "question" || questionTask.state !== "needs_human" || questionTask.question === void 0) throw new Error(`Question task ${questionTaskId} is not waiting for an answer.`);
+				const requestedTask = await stores.tasks.get(questionTaskId);
+				const resolvedQuestionTaskId = requestedTask?.kind === "question" ? requestedTask.id : requestedTask?.questionTaskId;
+				const questionTask = resolvedQuestionTaskId === void 0 ? null : await stores.tasks.get(resolvedQuestionTaskId);
+				if (questionTask === null || questionTask.kind !== "question" || questionTask.question === void 0) throw new Error(`Question task ${questionTaskId} does not exist.`);
 				const attributes = ctx.session.auth.initiator?.attributes;
 				if (attributes?.factoryReplyChannel !== questionTask.replyTo.channel || attributes.factoryReplyAddress !== questionTask.replyTo.address) throw new Error("Question reply does not match the authenticated conversation.");
-				const repositoryAttribute = attributes.factoryRepositoryIds;
-				const boundRepositoryIds = typeof repositoryAttribute === "string" ? repositoryAttribute.split(",").filter(Boolean) : repositoryAttribute;
-				if (boundRepositoryIds === void 0 || boundRepositoryIds.length !== questionTask.repositoryIds.length || boundRepositoryIds.some((id) => !questionTask.repositoryIds.includes(id))) throw new Error("Question repositories do not match the authenticated conversation.");
 				const answeredBy = ctx.session.auth.initiator?.principalId ?? "operator";
-				const answered = await stores.tasks.transition(questionTask.id, "succeeded", {
-					patch: { question: {
-						...questionTask.question,
-						answer,
-						answeredBy
-					} },
-					reason: "question answered through Foreman"
+				return stores.tasks.answerQuestion({
+					questionTaskId: questionTask.id,
+					answer,
+					answeredBy
 				});
-				const parentTaskId = questionTask.origin.parentTaskId;
-				if (parentTaskId === void 0) return {
-					questionTask: answered,
-					parentTask: null
-				};
-				const parent = await stores.tasks.get(parentTaskId);
-				if (parent === null) throw new Error(`Parent task ${parentTaskId} does not exist.`);
-				return {
-					questionTask: answered,
-					parentTask: parent.state === "needs_human" ? await stores.tasks.transition(parent.id, "queued", { reason: `question ${questionTask.id} answered by ${answeredBy}` }) : parent
-				};
 			}
 		}),
 		append_receipt: defineTool({
@@ -1196,7 +1209,7 @@ function factoryHooks(stores, options) {
 			if (taskId !== void 0) await settleIfTerminal(taskId).catch(() => void 0);
 			const address = ctx.channel.continuationToken;
 			if (address === void 0) return;
-			const abandoned = (await stores.tasks.list()).filter((task) => task.state === "running" && task.replyTo.address === address);
+			const abandoned = (await stores.tasks.list().catch(() => [])).filter((task) => task.state === "running" && task.replyTo.address === address);
 			for (const task of abandoned) await createAndPresentQuestion(stores, task, {
 				text: "The worker stopped without recording an outcome. Please review the task and reply when Factory should retry it.",
 				options: ["Retry the task"]