stageflow 0.9.0 → 0.13.0

package/dist/runtime/verifiedStageExecution.js

@@ -0,0 +1,127 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { listQaExchanges } from "../hitl/qaTrail.js";
+import { attemptArtifactsDir, attemptWorkspaceDir, } from "../runstore/workspaceLayout.js";
+import { COMPLETION_VERIFICATION_FAILURE_PREFIX, } from "../types/completion.js";
+import { runCompletionContract, } from "./completionCheckRunner.js";
+import { readCompletionCheckoutBaseline, writeCompletionCheckoutBaseline, } from "./completionCheckoutBaseline.js";
+import { createGitCheckoutCapability } from "./gitCheckoutCapability.js";
+/** Sidecar written before completion command checks so they can inspect fork_choice. */
+export const COMPLETION_CANDIDATE_ENVELOPE_FILENAME = "completion-candidate-envelope.json";
+export function completionVerificationFailureReason(failedCheckIds) {
+    return `${COMPLETION_VERIFICATION_FAILURE_PREFIX} ${failedCheckIds.join(", ")}`;
+}
+function gateDecisionsForAttempt(options) {
+    const { store, runId, stageId, attempt } = options;
+    return {
+        async listDecisions(kind) {
+            const events = await store.listStageEvents(runId, stageId, attempt);
+            return listQaExchanges(events)
+                .filter((exchange) => exchange.prompt.kind === kind && exchange.answer !== null)
+                .map((exchange) => {
+                const answer = exchange.answer;
+                if (answer.kind === "confirm" || answer.kind === "artifact_backed") {
+                    return {
+                        kind,
+                        prompt_id: exchange.prompt.id,
+                        status: answer.decision === "accept" ? "accepted" : "rejected",
+                    };
+                }
+                return { kind, prompt_id: exchange.prompt.id, status: "answered" };
+            });
+        },
+    };
+}
+/**
+ * Owns the verification lifecycle for one immutable stage attempt: establish
+ * observation before agent work, then persist evidence before accepting a
+ * candidate handoff. Agent lifecycle and final stage status stay outside this
+ * module in stageRunner.
+ */
+export function createVerifiedStageExecution(options) {
+    const { store, runId, stageId, attempt, stage, dag, roots } = options;
+    const contract = dag?.nodes.find((node) => node.id === stageId)?.completion;
+    let checkout;
+    let checkoutBefore;
+    let checkoutError;
+    return {
+        async prepare() {
+            if (!contract?.checks.some((check) => check.type === "checkout_changes")) {
+                return;
+            }
+            if (roots.checkoutRoot === undefined) {
+                checkoutError = "checkout check requires a bound checkout";
+                return;
+            }
+            checkout = createGitCheckoutCapability(roots.checkoutRoot);
+            try {
+                checkoutBefore = await readCompletionCheckoutBaseline(roots.runWorkspaceDir, stageId, attempt);
+                if (checkoutBefore === undefined) {
+                    checkoutBefore = await checkout.capture();
+                    await writeCompletionCheckoutBaseline(roots.runWorkspaceDir, stageId, attempt, checkoutBefore);
+                }
+            }
+            catch (error) {
+                checkoutError = `could not capture checkout baseline: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+        async verify(candidate) {
+            if (contract === undefined)
+                return candidate;
+            try {
+                const artifactsDir = attemptArtifactsDir(roots.runWorkspaceDir, stageId, attempt);
+                const attemptDir = attemptWorkspaceDir(roots.runWorkspaceDir, stageId, attempt);
+                await mkdir(attemptDir, { recursive: true });
+                await writeFile(path.join(attemptDir, COMPLETION_CANDIDATE_ENVELOPE_FILENAME), `${JSON.stringify(candidate.envelope, null, 2)}\n`, "utf8");
+                const verification = await runCompletionContract({
+                    contract,
+                    envelope: candidate.envelope,
+                    payloadSchema: stage.payload_schema,
+                    artifactsDir,
+                    commandWorkingDirectory: roots.cwd,
+                    gates: gateDecisionsForAttempt({ store, runId, stageId, attempt }),
+                    checkout,
+                    checkoutBefore,
+                    checkoutError,
+                    checklistAttestations: candidate.envelope.checklist_attestations,
+                    onCheckStart: async (check) => {
+                        await store.upsertVerificationCheckResult(runId, stageId, {
+                            check_id: check.id,
+                            check_type: check.type,
+                            status: "running",
+                            started_at: new Date().toISOString(),
+                        }, { attempt });
+                    },
+                    onCheckComplete: async (check) => {
+                        await store.upsertVerificationCheckResult(runId, stageId, {
+                            check_id: check.check_id,
+                            check_type: check.check_type,
+                            status: check.outcome === "passed" ? "passed" : "failed",
+                            finished_at: new Date().toISOString(),
+                            evidence: {
+                                ...check.evidence,
+                                ...(check.message !== undefined ? { message: check.message } : {}),
+                                ...(check.outcome === "error" ? { runner_outcome: "error" } : {}),
+                            },
+                        }, { attempt });
+                    },
+                });
+                await store.updateStageExecution(runId, stageId, attempt, {
+                    verification_outcome: verification.outcome,
+                });
+                if (verification.outcome === "passed")
+                    return candidate;
+                return {
+                    ok: false,
+                    reason: completionVerificationFailureReason(verification.failed_check_ids),
+                };
+            }
+            catch (error) {
+                await store.updateStageExecution(runId, stageId, attempt, {
+                    verification_outcome: "error",
+                });
+                throw error;
+            }
+        },
+    };
+}

package/dist/server/bootstrap.js

@@ -37,6 +37,7 @@ export async function bootstrapStageflowHost(options) {
     });
     await manager.attachWaitingStages();
     await manager.reconcileOrphanedStages();
+    await manager.resumeStalledSchedules();
     const mcpStateless = resolveMcpStateless({
         mcpStateless: options.mcpStateless,
     });

package/dist/server/http.js

@@ -3,12 +3,14 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { getCredentialSourceSettings, setCredentialSource, } from "../agent/providerAuth.js";
 import { handleProviderRoutes, providerAuthErrorBody, } from "./providerRoutes.js";
+import { handleProjectMcpRoutes } from "./projectMcpRoutes.js";
 import { createPipeline, parseCreatePipelineBody } from "../config/createPipeline.js";
 import { createStage, parseCreateStageBody } from "../config/createStage.js";
 import { browseCatalog } from "../config/browseCatalog.js";
 import { listExtensions } from "../config/listExtensions.js";
 import { listSkills } from "../config/listSkills.js";
-import { readRunArtifact } from "../mcp/readArtifact.js";
+import { artifactMediaType, readRunArtifact, readRunArtifactBytes, } from "../mcp/readArtifact.js";
+import { readStageVerificationHistory } from "../runstore/verificationHistory.js";
 import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
 import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, } from "../runtime/settingsFile.js";
 import { isTaskFile } from "../runtime/taskInput.js";
@@ -87,12 +89,16 @@ function isMutatingApi(method, pathname) {
         pathname === "/api/pipelines" ||
         /^\/api\/runs\/[^/]+\/rerun$/.test(pathname) ||
         /^\/api\/runs\/[^/]+\/stages\/[^/]+\/answer$/.test(pathname) ||
+        /^\/api\/runs\/[^/]+\/stages\/[^/]+\/feedback-decision$/.test(pathname) ||
         /^\/api\/runs\/[^/]+\/stages\/[^/]+\/retry$/.test(pathname) ||
+        /^\/api\/runs\/[^/]+\/stages\/[^/]+\/recovery$/.test(pathname) ||
+        /^\/api\/runs\/[^/]+\/stages\/[^/]+\/recovery\/stop$/.test(pathname) ||
         /^\/api\/runs\/[^/]+\/stages\/[^/]+\/abandon$/.test(pathname) ||
         /^\/api\/providers\/[^/]+\/login$/.test(pathname) ||
         /^\/api\/providers\/[^/]+\/login\/[^/]+\/answer$/.test(pathname) ||
         /^\/api\/providers\/[^/]+\/login\/[^/]+\/cancel$/.test(pathname) ||
-        /^\/api\/providers\/[^/]+\/logout$/.test(pathname));
+        /^\/api\/providers\/[^/]+\/logout$/.test(pathname) ||
+        /^\/api\/project-mcp\/[^/]+\/probe$/.test(pathname));
 }
 function isCredentialMutatingApi(method, pathname) {
     if (method !== "POST")
@@ -166,6 +172,9 @@ function assertLoopbackHttpAccess(req, res) {
 }
 export function defaultUiDistDir() {
     const here = path.dirname(fileURLToPath(import.meta.url));
+    if (path.basename(path.dirname(here)) === "src") {
+        return path.resolve(here, "../../dist/ui");
+    }
     return path.resolve(here, "../ui");
 }
 export async function startUiServer(options) {
@@ -203,8 +212,19 @@ export async function startUiServer(options) {
                         return true;
                     }
                     try {
-                        const content = await readRunArtifact(store, runId, artifactPath);
-                        textPlain(res, 200, content);
+                        const mediaType = artifactMediaType(artifactPath);
+                        if (mediaType !== undefined) {
+                            const bytes = await readRunArtifactBytes(store, runId, artifactPath);
+                            res.writeHead(200, {
+                                "Content-Type": mediaType,
+                                "Content-Length": bytes.length,
+                            });
+                            res.end(bytes);
+                        }
+                        else {
+                            const content = await readRunArtifact(store, runId, artifactPath);
+                            textPlain(res, 200, content);
+                        }
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
@@ -219,6 +239,20 @@ export async function startUiServer(options) {
                     }
                     return true;
                 }
+                const verificationMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/verification$/);
+                if (method === "GET" && verificationMatch) {
+                    const runId = decodeURIComponent(verificationMatch[1] ?? "");
+                    const stageId = decodeURIComponent(verificationMatch[2] ?? "");
+                    try {
+                        json(res, 200, await readStageVerificationHistory(store, runId, stageId));
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        const notFound = /not found|no such/i.test(message);
+                        json(res, notFound ? 404 : 500, { error: message });
+                    }
+                    return true;
+                }
                 if (method === "GET" && pathname.startsWith("/api/runs/")) {
                     const rest = pathname.slice("/api/runs/".length);
                     if (rest && !rest.includes("/")) {
@@ -290,6 +324,55 @@ export async function startUiServer(options) {
                     json(res, 202, { ok: true });
                     return true;
                 }
+                const feedbackDecisionMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/feedback-decision$/);
+                if (method === "POST" && feedbackDecisionMatch) {
+                    const runId = decodeURIComponent(feedbackDecisionMatch[1] ?? "");
+                    const stageId = decodeURIComponent(feedbackDecisionMatch[2] ?? "");
+                    let body;
+                    try {
+                        body = await readJsonBody(req);
+                    }
+                    catch {
+                        json(res, 400, { error: "Invalid JSON body" });
+                        return true;
+                    }
+                    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+                        json(res, 400, { error: "Body must be a JSON object" });
+                        return true;
+                    }
+                    const raw = body;
+                    if (raw.decision !== "extend" &&
+                        raw.decision !== "continue" &&
+                        raw.decision !== "abandon") {
+                        json(res, 400, {
+                            error: "decision must be extend, continue, or abandon",
+                        });
+                        return true;
+                    }
+                    if (raw.loopId !== undefined && typeof raw.loopId !== "string") {
+                        json(res, 400, { error: "loopId must be a string" });
+                        return true;
+                    }
+                    if (raw.reason !== undefined && typeof raw.reason !== "string") {
+                        json(res, 400, { error: "reason must be a string" });
+                        return true;
+                    }
+                    const result = await manager.decideFeedbackLoop(runId, stageId, {
+                        decision: raw.decision,
+                        ...(raw.loopId !== undefined ? { loopId: raw.loopId } : {}),
+                        ...(raw.reason !== undefined ? { reason: raw.reason } : {}),
+                    });
+                    if (!result.ok) {
+                        json(res, result.status ?? 500, { error: result.reason });
+                        return true;
+                    }
+                    json(res, 202, {
+                        ok: true,
+                        effect: result.effect,
+                        loopId: result.loopId,
+                    });
+                    return true;
+                }
                 const retryMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/retry$/);
                 if (method === "POST" && retryMatch) {
                     await readJsonBody(req);
@@ -307,6 +390,50 @@ export async function startUiServer(options) {
                     });
                     return true;
                 }
+                const recoverMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/recovery$/);
+                if (method === "POST" && recoverMatch) {
+                    let body;
+                    try {
+                        body = await readJsonBody(req);
+                    }
+                    catch {
+                        json(res, 400, { error: "Invalid JSON body" });
+                        return true;
+                    }
+                    const guidance = body !== null && typeof body === "object" && !Array.isArray(body)
+                        ? body.guidance
+                        : undefined;
+                    if (guidance !== undefined && typeof guidance !== "string") {
+                        json(res, 400, { error: "guidance must be a string" });
+                        return true;
+                    }
+                    const runId = decodeURIComponent(recoverMatch[1] ?? "");
+                    const stageId = decodeURIComponent(recoverMatch[2] ?? "");
+                    const result = await manager.recoverManualStage(runId, stageId, guidance);
+                    if (!result.ok) {
+                        json(res, result.status ?? 500, mapRetryStageFailure(result));
+                        return true;
+                    }
+                    json(res, 202, {
+                        runId: result.runId,
+                        stageId: result.stageId,
+                        attemptIndex: result.attemptIndex,
+                    });
+                    return true;
+                }
+                const stopRecoveryMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/recovery\/stop$/);
+                if (method === "POST" && stopRecoveryMatch) {
+                    await readJsonBody(req);
+                    const runId = decodeURIComponent(stopRecoveryMatch[1] ?? "");
+                    const stageId = decodeURIComponent(stopRecoveryMatch[2] ?? "");
+                    const result = await manager.stopManualRecovery(runId, stageId);
+                    if (!result.ok) {
+                        json(res, result.status ?? 500, { error: result.reason });
+                        return true;
+                    }
+                    json(res, 202, result);
+                    return true;
+                }
                 const abandonMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/abandon$/);
                 if (method === "POST" && abandonMatch) {
                     await readJsonBody(req);
@@ -413,6 +540,12 @@ export async function startUiServer(options) {
                 })) {
                     return true;
                 }
+                if (await handleProjectMcpRoutes(req, res, {
+                    projectRoot: boot.rootDir,
+                    json,
+                })) {
+                    return true;
+                }
                 if (method === "GET" && pathname === "/api/skills") {
                     json(res, 200, await listSkills({ cwd, agentDir }));
                     return true;

package/dist/server/operatorResults.js

@@ -9,6 +9,8 @@ export function inferRetryStageErrorCode(reason) {
         return "run_not_retryable";
     if (/stage is not failed/i.test(reason))
         return "stage_not_failed";
+    if (/manual recovery/i.test(reason))
+        return "manual_recovery_required";
     return undefined;
 }
 export function mapRetryStageFailure(result) {

package/dist/server/projectMcpRoutes.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export type ProjectMcpRoutesCtx = {
+    projectRoot: string;
+    json: (res: ServerResponse, status: number, body: unknown) => void;
+};
+export declare function handleProjectMcpRoutes(req: IncomingMessage, res: ServerResponse, ctx: ProjectMcpRoutesCtx): Promise<boolean>;

package/dist/server/projectMcpRoutes.js

@@ -0,0 +1,38 @@
+import { probeProjectMcpServer } from "../agent/piIsolatedMcpProbe.js";
+import { listProjectMcpCatalog } from "../config/resolveStageMcpServers.js";
+function requestAbortSignal(req) {
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted)
+            controller.abort();
+    };
+    if (req.aborted || req.destroyed) {
+        abort();
+        return controller.signal;
+    }
+    req.once("aborted", abort);
+    req.once("close", abort);
+    return controller.signal;
+}
+export async function handleProjectMcpRoutes(req, res, ctx) {
+    const { projectRoot, json } = ctx;
+    const method = req.method ?? "GET";
+    const rawUrl = req.url ?? "/";
+    const pathname = new URL(rawUrl, "http://localhost").pathname;
+    if (method === "GET" && pathname === "/api/project-mcp") {
+        json(res, 200, await listProjectMcpCatalog(projectRoot));
+        return true;
+    }
+    const probeMatch = pathname.match(/^\/api\/project-mcp\/([^/]+)\/probe$/);
+    if (method === "POST" && probeMatch) {
+        const name = decodeURIComponent(probeMatch[1] ?? "");
+        const result = await probeProjectMcpServer({
+            projectRoot,
+            name,
+            signal: requestAbortSignal(req),
+        });
+        json(res, 200, result);
+        return true;
+    }
+    return false;
+}

package/dist/tools/askOperator.d.ts

@@ -107,6 +107,96 @@ export declare const askOperatorParamsSchema: Type.TUnion<[Type.TObject<{
     artifacts: Type.TArray<Type.TString>;
     id: Type.TOptional<Type.TString>;
 }>]>;
+/**
+ * Narrows the ask_operator params schema to only the declared gate kinds
+ * (stage `gate_kinds` allowlist). Omitted/empty falls back to the full
+ * union so back-compat stages keep accepting every kind.
+ */
+export declare function askOperatorParamsSchemaFor(allowedKinds?: readonly AskOperatorKind[]): Type.TObject<{
+    kind: Type.TLiteral<"free_text">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"confirm">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"multi_question">;
+    questions: Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }>>;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"artifact_backed">;
+    message: Type.TString;
+    artifacts: Type.TArray<Type.TString>;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TUnion<[Type.TObject<{
+    kind: Type.TLiteral<"free_text">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"confirm">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"multi_question">;
+    questions: Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }>>;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"artifact_backed">;
+    message: Type.TString;
+    artifacts: Type.TArray<Type.TString>;
+    id: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    kind: Type.TLiteral<"free_text">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"confirm">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"multi_question">;
+    questions: Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }>>;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"artifact_backed">;
+    message: Type.TString;
+    artifacts: Type.TArray<Type.TString>;
+    id: Type.TOptional<Type.TString>;
+}>, ...(Type.TObject<{
+    kind: Type.TLiteral<"free_text">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"confirm">;
+    message: Type.TString;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"multi_question">;
+    questions: Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }>>;
+    id: Type.TOptional<Type.TString>;
+}> | Type.TObject<{
+    kind: Type.TLiteral<"artifact_backed">;
+    message: Type.TString;
+    artifacts: Type.TArray<Type.TString>;
+    id: Type.TOptional<Type.TString>;
+}>)[]]>;
 export declare const askOperatorAnswerSchema: Type.TUnion<[Type.TObject<{
     promptId: Type.TString;
     kind: Type.TLiteral<"free_text">;
@@ -142,25 +232,28 @@ export declare const parseAnswer: typeof parseAskOperatorAnswer;
 export type AskOperatorWaitBridge = {
     requestWait: (prompt: AskOperatorPrompt) => Promise<unknown>;
 };
-export type AskOperatorToolOptions = AskOperatorWaitBridge;
+export type AskOperatorToolOptions = AskOperatorWaitBridge & {
+    allowedKinds?: readonly AskOperatorKind[];
+};
 export type AskOperatorToolDetails = {
     prompt: AskOperatorPrompt | null;
     answer: AskOperatorAnswer | null;
     error: string;
 };
+export declare function summarizeAnswer(answer: AskOperatorAnswer): string;
 export declare function createAskOperatorTool(options: AskOperatorToolOptions): {
     name: string;
     label: string;
     description: string;
-    parameters: Type.TUnion<[Type.TObject<{
+    parameters: Type.TObject<{
         kind: Type.TLiteral<"free_text">;
         message: Type.TString;
         id: Type.TOptional<Type.TString>;
-    }>, Type.TObject<{
+    }> | Type.TObject<{
         kind: Type.TLiteral<"confirm">;
         message: Type.TString;
         id: Type.TOptional<Type.TString>;
-    }>, Type.TObject<{
+    }> | Type.TObject<{
         kind: Type.TLiteral<"multi_question">;
         questions: Type.TArray<Type.TObject<{
             kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
@@ -168,12 +261,75 @@ export declare function createAskOperatorTool(options: AskOperatorToolOptions):
             id: Type.TOptional<Type.TString>;
         }>>;
         id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"artifact_backed">;
+        message: Type.TString;
+        artifacts: Type.TArray<Type.TString>;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"free_text">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"confirm">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"multi_question">;
+        questions: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+            message: Type.TString;
+            id: Type.TOptional<Type.TString>;
+        }>>;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"artifact_backed">;
+        message: Type.TString;
+        artifacts: Type.TArray<Type.TString>;
+        id: Type.TOptional<Type.TString>;
     }>, Type.TObject<{
+        kind: Type.TLiteral<"free_text">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"confirm">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"multi_question">;
+        questions: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+            message: Type.TString;
+            id: Type.TOptional<Type.TString>;
+        }>>;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"artifact_backed">;
+        message: Type.TString;
+        artifacts: Type.TArray<Type.TString>;
+        id: Type.TOptional<Type.TString>;
+    }>, ...(Type.TObject<{
+        kind: Type.TLiteral<"free_text">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"confirm">;
+        message: Type.TString;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
+        kind: Type.TLiteral<"multi_question">;
+        questions: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"free_text">, Type.TLiteral<"confirm">]>;
+            message: Type.TString;
+            id: Type.TOptional<Type.TString>;
+        }>>;
+        id: Type.TOptional<Type.TString>;
+    }> | Type.TObject<{
         kind: Type.TLiteral<"artifact_backed">;
         message: Type.TString;
         artifacts: Type.TArray<Type.TString>;
         id: Type.TOptional<Type.TString>;
-    }>]>;
+    }>)[]]>;
     execute: (_toolCallId: string, params: unknown) => Promise<{
         content: {
             type: "text";