@osolmaz/pi-workflows 0.16.5 → 0.16.6

package/dist/extension/index.js

@@ -86,33 +86,22 @@ export function parseWorkflowArgs(args) {
         return { kind: "status", runId };
     }
     if (trimmed === "answer" || trimmed.startsWith("answer ")) {
-        let rest = trimmed === "answer" ? "" : trimmed.slice("answer".length).trim();
-        if (rest.length === 0) {
-            throw new Error('answer requires a JSON value or text, e.g. /workflow answer {"approved":true}');
-        }
-        let runId;
+        const rest = trimmed === "answer" ? "" : trimmed.slice("answer".length).trim();
         const firstSpace = rest.search(/\s/);
-        if (firstSpace > 0) {
-            const candidate = rest.slice(0, firstSpace);
-            const remainder = rest.slice(firstSpace).trim();
-            if (validRunId(candidate) &&
-                remainder.length > 0 &&
-                (remainder.startsWith("{") || remainder.startsWith("["))) {
-                runId = candidate;
-                rest = remainder;
-            }
+        if (firstSpace <= 0 || rest.slice(firstSpace).trim().length === 0) {
+            throw new Error('answer requires an exact request id and a response: /workflow answer REQUEST_ID {"choice":"approve"}');
         }
+        const requestId = rest.slice(0, firstSpace);
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(requestId))
+            throw new Error("answer requires a valid request id");
+        const text = rest.slice(firstSpace).trim();
         try {
-            return {
-                kind: "answer",
-                input: JSON.parse(rest),
-                ...(runId === undefined ? {} : { runId }),
-            };
+            return { kind: "answer", requestId, input: JSON.parse(text) };
         }
         catch {
-            if (runId !== undefined)
-                throw new Error("answer with a run id requires a JSON value");
-            return { kind: "answer", input: { answer: rest } };
+            if (/^[{["]/.test(text))
+                throw new Error("answer contains invalid JSON");
+            return { kind: "answer", requestId, input: { answer: text } };
         }
     }
     const spaceIndex = trimmed.search(/\s/);
@@ -143,6 +132,7 @@ export default function piWorkflows(pi) {
     const sessionView = new SessionWorkflowView();
     const sessionRecorders = new Map();
     let agentRunning = false;
+    let lastStopReason = "completed";
     let activeRecorder = null;
     let activeRecorderMessageId = null;
     const ensureRecorder = async (message, ctx) => {
@@ -163,7 +153,7 @@ export default function piWorkflows(pi) {
         if (message === undefined || activeRecorderMessageId === message.workflowMessageId)
             return;
         const contract = agentContractForWorkflowMessage(message);
-        if (contract === undefined && message.kind !== "terminal" && message.kind !== "followUp") {
+        if (contract === undefined && message.kind !== "followUp") {
             return;
         }
         const recorder = await ensureRecorder(message, ctx);
@@ -172,7 +162,7 @@ export default function piWorkflows(pi) {
             return;
         }
         if (contract === undefined) {
-            recorder.beginWorkflowMessage(message.workflowMessageId, message.kind);
+            recorder.beginFollowUp(message.workflowMessageId);
         }
         else {
             recorder.beginAttempt(contract);
@@ -188,7 +178,28 @@ export default function piWorkflows(pi) {
         });
         await prior;
         try {
-            await workflowMessages.synchronize(pi, client, ctx);
+            const finishRecording = async (message) => {
+                const recorder = sessionRecorders.get(message.runId);
+                if (recorder === undefined)
+                    return;
+                await recorder.record(ctx).catch((error) => {
+                    ctx.ui.notify(`Workflow conversation recording failed: ${errorMessage(error)}`, "warning");
+                });
+                await recorder.finish();
+                sessionRecorders.delete(message.runId);
+                if (activeRecorder === recorder)
+                    activeRecorder = null;
+            };
+            await workflowMessages.synchronize(pi, client, ctx, {
+                beforeTurnEnd: async (message, end) => {
+                    if (end.stopReason === "completed") {
+                        await submitVisibleAssistantResponse(client, ctx, message, end.responseSessionEntryId);
+                    }
+                    if (message.kind === "followUp")
+                        await finishRecording(message);
+                },
+                terminalDelivered: finishRecording,
+            });
             await activateRecorder(ctx);
         }
         finally {
@@ -412,7 +423,7 @@ export default function piWorkflows(pi) {
             "List, start, restart, inspect, change settings, queue or remove follow-ups, pause, resume, cancel, answer ordinary checkpoints, update, or complete hosted workflow runs.",
             "Protected human decisions cannot be answered with this model-facing tool.",
             "When the user asks to continue or resume the active workflow, call workflow resume immediately.",
-            "Use update or submit only when a workflow step contract asks for it, and pass the exact step and attempt ids.",
+            "Use update or submit only when a workflow step contract asks for it, and pass its exact requestId.",
             "Do not start repeated work without the user's request.",
         ].join(" "),
         parameters: WorkflowToolParameters,
@@ -420,28 +431,16 @@ export default function piWorkflows(pi) {
             return await runToolInOrder(async () => {
                 const params = parseWorkflowToolInput(rawParams);
                 if (params.action === "update" || params.action === "submit") {
-                    const interaction = pendingInteractionForSession(ctx.sessionManager.getSessionId());
-                    if (interaction === undefined)
-                        throw new Error("No workflow step is waiting for output");
-                    const contract = agentContract(interaction);
-                    if (contract === undefined)
-                        throw new Error("The pending interaction is not an agent step");
-                    if (contract.nodeId !== params.step || contract.attemptId !== params.attempt) {
-                        throw new Error("Workflow step or attempt does not match the durable request");
-                    }
                     let response;
                     try {
                         response = await requestAccepted(client, {
                             operation: params.action === "update" ? "interaction.update" : "interaction.submit",
                             requestId: `${params.action}-${toolCallId}-${randomUUID()}`,
                             idempotencyKey: toolCallId,
-                            runId: interaction.runId,
-                            expectedRevision: interaction.revision,
                             payload: jsonValue({
-                                requestId: interaction.requestId,
+                                ...sessionCommandPayload(ctx),
+                                requestId: params.requestId,
                                 submissionId: toolCallId,
-                                step: params.step,
-                                attempt: params.attempt,
                                 value: params.action === "update"
                                     ? { update: params.update }
                                     : { output: params.output },
@@ -592,35 +591,16 @@ export default function piWorkflows(pi) {
     });
     pi.on("agent_start", async (_event, ctx) => {
         agentRunning = true;
+        lastStopReason = "completed";
         activeRecorder = null;
         activeRecorderMessageId = null;
         workflowMessages.startTurn();
         await presentInOrder(ctx).catch(() => undefined);
     });
-    pi.on("agent_end", async (event, ctx) => {
-        try {
-            await submitVisibleAssistantResponse(client, ctx);
-        }
-        catch (error) {
-            ctx.ui.notify(`Workflow response was rejected: ${errorMessage(error)}`, "error");
-        }
-        const finishedMessage = workflowMessages.activeTurnMessage();
+    pi.on("agent_end", (event, ctx) => {
         agentRunning = false;
-        activeRecorderMessageId = null;
-        workflowMessages.endTurn(workflowTurnStopReason(event.messages, ctx.signal?.aborted === true), responseEntryId(ctx.sessionManager.getBranch()));
-        if (activeRecorder !== null &&
-            finishedMessage !== undefined &&
-            (finishedMessage.kind === "terminal" || finishedMessage.kind === "followUp")) {
-            const finishedRecorder = activeRecorder;
-            activeRecorder = null;
-            await finishedRecorder.finish();
-            if (sessionRecorders.get(finishedMessage.runId) === finishedRecorder) {
-                sessionRecorders.delete(finishedMessage.runId);
-            }
-        }
-        await presentInOrder(ctx).catch((error) => {
-            ctx.ui.notify(`Could not record workflow model activity: ${errorMessage(error)}`, "warning");
-        });
+        lastStopReason = workflowTurnStopReason(event.messages, ctx.signal?.aborted === true);
+        // Pi can retry after agent_end. Only agent_settled completes the owned turn.
     });
     pi.on("turn_start", (event) => {
         activeRecorder?.handleTurnStart(event);
@@ -648,13 +628,11 @@ export default function piWorkflows(pi) {
     });
     pi.on("agent_settled", async (_event, ctx) => {
         activeRecorder?.settleAttempt();
-        try {
-            await submitVisibleAssistantResponse(client, ctx);
-        }
-        catch (error) {
-            ctx.ui.notify(`Workflow response was rejected: ${errorMessage(error)}`, "error");
-        }
-        await presentInOrder(ctx).catch(() => undefined);
+        workflowMessages.endTurn(lastStopReason, responseEntryId(ctx.sessionManager.getBranch()));
+        activeRecorderMessageId = null;
+        await presentInOrder(ctx).catch((error) => {
+            ctx.ui.notify(`Could not record workflow model activity: ${errorMessage(error)}`, "warning");
+        });
     });
     pi.on("session_shutdown", async (_event, ctx) => {
         sessionGeneration += 1;
@@ -788,17 +766,16 @@ async function executeCommand(client, ctx, command, idempotencyKey = randomUUID(
             if (runId === undefined)
                 throw new Error("No workflow terminal result is available to restart");
             const session = sessionCommandPayload(ctx);
-            const marker = terminalMessageForSession(ctx, runId);
+            const expectedRevision = command.expectedRevision ?? (await client.getRun(runId))?.runRevision;
+            if (expectedRevision === undefined)
+                throw new Error("Workflow run revision is unavailable");
             const response = await requestAccepted(client, {
                 operation: "run.restart",
                 requestId: `restart-${idempotencyKey}`,
                 idempotencyKey,
                 runId,
-                payload: {
-                    ...session,
-                    workflowMessageId: marker.workflowMessageId,
-                    ...(marker.workflowTurnId === undefined ? {} : { workflowTurnId: marker.workflowTurnId }),
-                },
+                expectedRevision,
+                payload: session,
             });
             return {
                 message: `Restarted workflow ${runId}.`,
@@ -906,11 +883,30 @@ async function executeCommand(client, ctx, command, idempotencyKey = randomUUID(
             };
         }
         case "answer": {
-            const interaction = pendingDecision(ctx.sessionManager.getSessionId(), command.runId);
-            if (interaction !== undefined) {
-                if (authority !== "human") {
-                    throw new Error("Protected human decisions cannot be answered by the workflow tool");
-                }
+            if (authority === "model") {
+                const response = await requestAccepted(client, {
+                    operation: "checkpoint.answer",
+                    requestId: `checkpoint-${idempotencyKey}`,
+                    idempotencyKey,
+                    payload: {
+                        ...sessionCommandPayload(ctx),
+                        requestId: command.requestId,
+                        submissionId: idempotencyKey,
+                        input: jsonValue(command.input),
+                    },
+                });
+                return {
+                    message: `Answered checkpoint ${command.requestId}.`,
+                    details: { action: "answer", response: response.receipt ?? null },
+                };
+            }
+            const interaction = sessionSnapshots
+                .get(ctx.sessionManager.getSessionId())
+                ?.pendingInteractions.map(parseInteractiveRequest)
+                .find((request) => request?.requestId === command.requestId);
+            if (interaction === undefined)
+                throw new Error("No matching checkpoint request is waiting in this session");
+            if (interaction.kind === "decision") {
                 const response = await requestAccepted(client, {
                     operation: "decision.answer",
                     requestId: `answer-${idempotencyKey}`,
@@ -918,6 +914,7 @@ async function executeCommand(client, ctx, command, idempotencyKey = randomUUID(
                     runId: interaction.runId,
                     expectedRevision: interaction.revision,
                     payload: {
+                        ...sessionCommandPayload(ctx),
                         requestId: interaction.requestId,
                         submissionId: idempotencyKey,
                         response: decisionResponse(command.input),
@@ -932,32 +929,26 @@ async function executeCommand(client, ctx, command, idempotencyKey = randomUUID(
                     },
                 };
             }
-            const parent = sessionRun(ctx, command.runId);
-            if (parent === undefined)
-                throw new Error("No checkpoint is waiting in this session");
-            const continuationRunId = createRunId(parent.workflowName);
+            if (interaction.kind !== "checkpoint")
+                throw new Error("Only an ordinary checkpoint accepts an answer");
             const response = await requestAccepted(client, {
                 operation: "checkpoint.answer",
                 requestId: `checkpoint-${idempotencyKey}`,
                 idempotencyKey,
-                runId: parent.runId,
+                runId: interaction.runId,
+                expectedRevision: interaction.revision,
                 payload: {
-                    continuationRunId,
+                    ...sessionCommandPayload(ctx),
+                    requestId: interaction.requestId,
+                    submissionId: idempotencyKey,
                     input: jsonValue(command.input),
                 },
             });
-            const receipt = isRecord(response.receipt) ? response.receipt : undefined;
-            const actualRunId = receipt !== undefined && typeof receipt.runId === "string"
-                ? receipt.runId
-                : continuationRunId;
             return {
-                message: receipt?.alreadyAnswered === true
-                    ? `Checkpoint ${parent.runId} was already answered; continuation ${actualRunId} exists.`
-                    : `Answered checkpoint ${parent.runId}; continuation ${actualRunId} started.`,
+                message: `Answered checkpoint ${interaction.requestId}; run ${interaction.runId} can continue.`,
                 details: {
                     action: "answer",
-                    parentRunId: parent.runId,
-                    runId: actualRunId,
+                    runId: interaction.runId,
                     response: response.receipt ?? null,
                 },
             };
@@ -1023,50 +1014,36 @@ async function executeResourceManagerCommand(client, ctx, command) {
         details: { action: command.kind, resource: response.receipt ?? null },
     };
 }
-async function submitVisibleAssistantResponse(client, ctx) {
-    const interaction = pendingInteractionForSession(ctx.sessionManager.getSessionId());
-    if (interaction === undefined ||
-        interaction.kind !== "assistant" ||
-        workflowRunPaused(interaction.runId)) {
+async function submitVisibleAssistantResponse(client, ctx, message, settledResponseEntryId) {
+    const contract = agentContractForWorkflowMessage(message);
+    if (contract?.completion !== "assistant" || workflowRunPaused(message.runId))
         return;
-    }
-    const contract = agentContract(interaction);
-    if (contract === undefined)
+    if (settledResponseEntryId === null)
         return;
-    const submission = recoverAssistantStep(ctx.sessionManager.getBranch(), contract);
+    const branch = ctx.sessionManager.getBranch();
+    const responseIndex = branch.findIndex((entry) => entry.id === settledResponseEntryId);
+    if (responseIndex < 0)
+        return;
+    const submission = recoverAssistantStep(branch.slice(0, responseIndex + 1), contract);
     if (submission === undefined)
         return;
     const responseId = submission.conversation?.lastEntryId ?? submission.assistantMessage?.entryId;
-    if (responseId === undefined)
+    if (responseId !== settledResponseEntryId)
         return;
-    await requestAccepted(client, {
-        operation: "interaction.submit",
-        requestId: `assistant-${interaction.requestId}-${responseId}`,
-        idempotencyKey: `assistant-${interaction.requestId}-${responseId}`,
-        runId: interaction.runId,
-        expectedRevision: interaction.revision,
+    const response = await client.request({
+        operation: "interaction.assistant",
+        requestId: `assistant-${message.sourceId}-${responseId}`,
+        idempotencyKey: `assistant-${message.sourceId}-${responseId}`,
         payload: {
-            requestId: interaction.requestId,
+            ...sessionCommandPayload(ctx),
+            requestId: message.sourceId,
             submissionId: `assistant-${responseId}`,
-            step: contract.nodeId,
-            attempt: contract.attemptId,
             value: submission,
         },
     });
-}
-function pendingInteractionForSession(sessionId) {
-    return sessionSnapshots
-        .get(sessionId)
-        ?.pendingInteractions.map(parseInteractiveRequest)
-        .find((request) => request !== undefined);
-}
-function pendingDecision(sessionId, runId) {
-    return sessionSnapshots
-        .get(sessionId)
-        ?.pendingInteractions.map(parseInteractiveRequest)
-        .find((request) => request !== undefined &&
-        request.kind === "decision" &&
-        (runId === undefined || request.runId === runId));
+    if (response.outcome !== "accepted" && response.outcome !== "adopted") {
+        ctx.ui.notify(`Workflow response was rejected: ${response.error ?? response.outcome}`, "error");
+    }
 }
 function workflowRunPaused(runId) {
     for (const session of sessionSnapshots.values()) {
@@ -1089,21 +1066,6 @@ function sessionCommandPayload(ctx) {
     }
     return { targetSessionId, coordinatorEpoch: session.coordinatorEpoch };
 }
-function terminalMessageForSession(ctx, runId) {
-    const session = sessionSnapshots.get(ctx.sessionManager.getSessionId());
-    const message = session?.workflowMessages
-        .filter((item) => item.kind === "terminal" && item.runId === runId && item.status === "sent")
-        .sort((left, right) => right.order - left.order)[0];
-    if (message === undefined)
-        throw new Error(`Workflow run ${runId} has no current terminal result`);
-    const turn = session?.openWorkflowTurn;
-    return {
-        workflowMessageId: message.workflowMessageId,
-        ...(turn?.workflowMessageId === message.workflowMessageId
-            ? { workflowTurnId: turn.workflowTurnId }
-            : {}),
-    };
-}
 function sessionRun(ctx, runId) {
     const session = sessionSnapshots.get(ctx.sessionManager.getSessionId());
     if (session?.run === null || session?.run === undefined || !isRecord(session.run.queue)) {
@@ -1132,7 +1094,7 @@ function toolInputToCommand(params) {
         case "start":
             return { kind: "run", ref: params.workflow, input: params.input ?? {} };
         case "restart":
-            return { kind: "restart", runId: params.runId };
+            return { kind: "restart", runId: params.runId, expectedRevision: params.expectedRevision };
         case "change-settings":
             return {
                 kind: "change-settings",
@@ -1168,8 +1130,8 @@ function toolInputToCommand(params) {
         case "answer":
             return {
                 kind: "answer",
-                input: params.input ?? {},
-                ...(params.runId === undefined ? {} : { runId: params.runId }),
+                requestId: params.requestId,
+                input: params.input,
             };
         case "update":
         case "submit":
@@ -1186,28 +1148,13 @@ async function requestAccepted(client, options) {
     }
     return response;
 }
-function interactionContract(interaction) {
-    if (!isRecord(interaction.contract))
-        throw new Error("Stored interaction contract is invalid");
-    return interaction.contract;
-}
-function agentContract(interaction) {
-    const value = interactionContract(interaction).contract;
-    if (!isRecord(value) ||
-        typeof value.runId !== "string" ||
-        typeof value.workflowName !== "string" ||
-        typeof value.nodeId !== "string" ||
-        typeof value.attemptId !== "string" ||
-        (value.completion !== "submit" && value.completion !== "assistant")) {
-        return undefined;
-    }
-    return value;
-}
 function agentContractForWorkflowMessage(message) {
     if (message.kind !== "step" || !isRecord(message.content.details))
         return undefined;
     const value = message.content.details.contract;
     if (!isRecord(value) ||
+        value.requestId !== message.sourceId ||
+        value.runId !== message.runId ||
         typeof value.runId !== "string" ||
         typeof value.workflowName !== "string" ||
         typeof value.nodeId !== "string" ||
@@ -1303,7 +1250,10 @@ function parseInteractiveRequest(value) {
         typeof value.runId !== "string" ||
         typeof value.targetSessionId !== "string" ||
         typeof value.revision !== "number" ||
-        (value.kind !== "agent" && value.kind !== "assistant" && value.kind !== "decision")) {
+        (value.kind !== "agent" &&
+            value.kind !== "assistant" &&
+            value.kind !== "checkpoint" &&
+            value.kind !== "decision")) {
         return undefined;
     }
     return value;