@xfey/tutti 0.1.93 → 0.1.95

package/dist/run-pipeline/task-run-invocation.js

@@ -1,67 +1,106 @@
 import { renderPromptTemplate } from "../prompt-templates/index.js";
-import { runCodexAppServerWorkspaceWriteRun, } from "../providers/openai/app-server/workspace-write-run.js";
+import { CODEX_APP_SERVER_VERSION } from "../providers/openai/codex-app-server.js";
+import { CodexAppServerWorkspaceWriteRunError, runCodexAppServerWorkspaceWriteRun, } from "../providers/openai/app-server/workspace-write-run.js";
+import { acquireCodexTaskSessionLock, createProviderFingerprint, markCodexTaskSessionArchived, openCodexTaskSession, readCodexSessionRecoveryEvidence, recordCodexSessionArchiveFailure, recordCodexTaskSessionThread, writeCodexSessionRecoveryEvidence, } from "../providers/openai/app-server/session-store.js";
 import { TASK_RUN_OUTPUT_SCHEMA, isInitialTaskRunOutput, normalizeTaskRunOutput, } from "./task-run-output.js";
 function taskContractRunInput(input) {
     return {
         title: input.task.title,
         goal: input.task_detail.detail.contract.goal,
         scope: input.task_detail.detail.contract.scope,
+        ...(input.source_messages === undefined || input.source_messages.length === 0
+            ? {}
+            : { source_messages: input.source_messages.map((message) => ({ ...message })) }),
+        ...(input.clarification_rounds === undefined || input.clarification_rounds.length === 0
+            ? {}
+            : {
+                clarification_rounds: input.clarification_rounds.map((round) => ({
+                    request: {
+                        ...(round.request_payload.title === undefined
+                            ? {}
+                            : { title: round.request_payload.title }),
+                        summary: round.request_payload.summary,
+                        request: round.request_payload.request,
+                    },
+                    answer_messages: round.answer_messages.map((message) => ({ ...message })),
+                })),
+            }),
         ...(input.recent_references === undefined || input.recent_references.length === 0
             ? {}
             : { recent_references: input.recent_references }),
     };
 }
-function initialTaskRunInput(input) {
-    return taskContractRunInput(input);
-}
-function continuationTaskRunInput(input) {
-    return {
-        ...taskContractRunInput(input),
-        ...(input.continuation_context === undefined
-            ? {}
-            : { continuation: input.continuation_context }),
-    };
+function renderResultContract(options) {
+    return renderPromptTemplate({
+        templateKey: "runs.task_result_contract",
+        ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+    });
 }
-function retryTaskRunInput(input) {
-    if (input.correction_context === undefined) {
-        throw new Error("Retry task run requires correction context.");
+function createExecutePrompt(options, input, session) {
+    let executionInput;
+    if (input.run_lineage.kind === "continuation") {
+        if (input.continuation_context === undefined) {
+            throw new CodexAppServerWorkspaceWriteRunError("session_unavailable", "Task continuation context is unavailable.");
+        }
+        executionInput = {
+            continuation: input.continuation_context,
+            ...(session === undefined ||
+                session.disposition !== "resumed" ||
+                session.metadata.thread_id === undefined
+                ? { task_context: taskContractRunInput(input) }
+                : {}),
+        };
     }
-    return {
-        ...taskContractRunInput(input),
-        correction: input.correction_context,
-    };
+    else {
+        executionInput = taskContractRunInput(input);
+    }
+    return renderPromptTemplate({
+        templateKey: "runs.task_execute",
+        ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+        variables: { execution_input_json: executionInput },
+    });
 }
-function createRunPrompt(options, input) {
-    const templateKey = input.run_lineage.kind === "continuation"
-        ? "runs.task_continuation"
-        : input.run_lineage.kind === "retry"
-            ? "runs.task_retry"
-            : "runs.task_run";
+function createFinalizePrompt(options) {
     return renderPromptTemplate({
-        templateKey,
+        templateKey: "runs.task_finalize",
         ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+        variables: { result_contract: renderResultContract(options) },
+    });
+}
+function createRecoveryPrompt(input) {
+    const needsCanonicalContext = input.session === undefined || input.session.metadata.thread_id === undefined;
+    return renderPromptTemplate({
+        templateKey: "runs.task_recovery",
+        ...(input.options.promptsRoot === undefined
+            ? {}
+            : { promptsRoot: input.options.promptsRoot }),
         variables: {
-            run_input_json: input.run_lineage.kind === "initial"
-                ? initialTaskRunInput(input)
-                : input.run_lineage.kind === "continuation"
-                    ? continuationTaskRunInput(input)
-                    : retryTaskRunInput(input),
+            recovery_input_json: {
+                ...(needsCanonicalContext
+                    ? { task_context: taskContractRunInput(input.pipelineInput) }
+                    : {}),
+                recovery: input.recovery,
+            },
+            result_contract: renderResultContract(input.options),
         },
     });
 }
-function usageSource(input) {
-    switch (input.run_lineage.kind) {
-        case "continuation":
-            return "follow_up_run";
-        case "retry":
-            return "pipeline_self_correction";
-        case "initial":
-            return "workspace_write_run";
+function usageSource(input, phase) {
+    if (phase === "finalize") {
+        return "task_result_finalize";
+    }
+    if (phase === "recovery") {
+        return "task_result_recovery";
     }
+    return input.run_lineage.kind === "continuation"
+        ? "follow_up_execute"
+        : input.run_lineage.kind === "retry"
+            ? "manual_retry_execute"
+            : "workspace_write_execute";
 }
-export async function runWorkspaceWriteTask(options, input) {
+function createApprovalHandler(options, input) {
     const manager = options.approvalManager;
-    const approvalHandler = manager === undefined
+    return manager === undefined
         ? undefined
         : (approvalInput) => manager.awaitApproval({
             request: approvalInput.request,
@@ -80,69 +119,308 @@ export async function runWorkspaceWriteTask(options, input) {
             },
             timeoutMs: approvalInput.context.turnTimeoutMs,
         });
-    let result;
+}
+function openTaskSession(options, input) {
+    if (options.tuttiHome === undefined || options.projectId === undefined) {
+        return undefined;
+    }
     try {
-        result = await runCodexAppServerWorkspaceWriteRun({
-            apiKey: options.apiKey,
-            workspaceRoot: options.workspaceRoot,
-            prompt: createRunPrompt(options, input),
-            outputSchema: TASK_RUN_OUTPUT_SCHEMA,
-            validateOutput: (value) => isInitialTaskRunOutput(value),
-            skillSelectionName: input.run_lineage.kind === "continuation" ? "follow_up_run" : "workspace_write_run",
-            defaultModel: options.config.default_model,
-            approvalContext: {
-                workspaceRoot: options.workspaceRoot,
-                taskId: input.task.id,
-                activityRef: input.activity_ref,
-            },
-            ...(approvalHandler === undefined ? {} : { approvalHandler }),
-            ...(options.config.api_base_url === undefined
-                ? {}
-                : { apiBaseUrl: options.config.api_base_url }),
-            ...(options.tuttiHome === undefined ? {} : { tuttiHome: options.tuttiHome }),
-            ...(options.userSkillsRoot === undefined ? {} : { userSkillsRoot: options.userSkillsRoot }),
-            ...(options.builtInSkillsRoot === undefined
-                ? {}
-                : { builtInSkillsRoot: options.builtInSkillsRoot }),
-            ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
-            ...(options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }),
-            ...(options.requestTimeoutMs === undefined
-                ? {}
-                : { requestTimeoutMs: options.requestTimeoutMs }),
-            ...(options.turnTimeoutMs === undefined ? {} : { turnTimeoutMs: options.turnTimeoutMs }),
-            ...(options.baseEnv === undefined ? {} : { baseEnv: options.baseEnv }),
-            ...(options.invocationCoordinator === undefined
-                ? {}
-                : { invocationCoordinator: options.invocationCoordinator }),
-            ...(options.onLifecycleIncident === undefined
-                ? {}
-                : { onLifecycleIncident: options.onLifecycleIncident }),
-            runtimeTelemetry: {
-                activityRef: input.activity_ref,
-                stageId: "provider_task_run",
-                workspaceRoot: options.workspaceRoot,
-                onSnapshot: (snapshot) => input.on_stage?.({
-                    stage: "provider_task_run",
-                    summary: "running Codex task implementation.",
-                    runtime: snapshot,
+        return openCodexTaskSession({
+            tuttiHome: options.tuttiHome,
+            projectId: options.projectId,
+            taskId: input.task.id,
+            compatibility: {
+                codexVersion: CODEX_APP_SERVER_VERSION,
+                model: options.config.default_model,
+                providerFingerprint: createProviderFingerprint({
+                    providerKind: "openai",
+                    ...(options.config.api_base_url === undefined
+                        ? {}
+                        : { apiBaseUrl: options.config.api_base_url }),
                 }),
             },
         });
     }
-    finally {
-        options.approvalManager?.clearPending();
+    catch {
+        throw new CodexAppServerWorkspaceWriteRunError("session_unavailable", "The durable Codex task session is unavailable.");
+    }
+}
+async function runTaskTurn(input) {
+    let activeSession = input.session;
+    const invoke = () => runCodexAppServerWorkspaceWriteRun({
+        apiKey: input.options.apiKey,
+        workspaceRoot: input.options.workspaceRoot,
+        prompt: input.prompt,
+        sandboxMode: input.sandboxMode,
+        networkAccess: input.networkAccess,
+        defaultModel: input.options.config.default_model,
+        approvalContext: {
+            workspaceRoot: input.options.workspaceRoot,
+            taskId: input.pipelineInput.task.id,
+            activityRef: input.pipelineInput.activity_ref,
+        },
+        ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
+        ...(input.validateOutput === undefined ? {} : { validateOutput: input.validateOutput }),
+        ...(input.skillSelectionName === undefined
+            ? {}
+            : { skillSelectionName: input.skillSelectionName }),
+        ...(input.approvalHandler === undefined
+            ? {}
+            : { approvalHandler: input.approvalHandler }),
+        ...(input.options.config.api_base_url === undefined
+            ? {}
+            : { apiBaseUrl: input.options.config.api_base_url }),
+        ...(input.options.tuttiHome === undefined ? {} : { tuttiHome: input.options.tuttiHome }),
+        ...(input.options.userSkillsRoot === undefined
+            ? {}
+            : { userSkillsRoot: input.options.userSkillsRoot }),
+        ...(input.options.builtInSkillsRoot === undefined
+            ? {}
+            : { builtInSkillsRoot: input.options.builtInSkillsRoot }),
+        ...(input.options.agentContext === undefined
+            ? {}
+            : { agentContext: input.options.agentContext }),
+        ...(input.options.codexCommand === undefined
+            ? {}
+            : { codexCommand: input.options.codexCommand }),
+        ...(input.options.requestTimeoutMs === undefined
+            ? {}
+            : { requestTimeoutMs: input.options.requestTimeoutMs }),
+        ...(input.options.turnTimeoutMs === undefined
+            ? {}
+            : { turnTimeoutMs: input.options.turnTimeoutMs }),
+        ...(input.options.baseEnv === undefined ? {} : { baseEnv: input.options.baseEnv }),
+        ...(input.options.invocationCoordinator === undefined
+            ? {}
+            : { invocationCoordinator: input.options.invocationCoordinator }),
+        ...(input.options.onLifecycleIncident === undefined
+            ? {}
+            : { onLifecycleIncident: input.options.onLifecycleIncident }),
+        ...(activeSession === undefined
+            ? {}
+            : {
+                session: {
+                    codexHome: activeSession.codexHome,
+                    ...(activeSession.metadata.thread_id === undefined
+                        ? {}
+                        : { threadId: activeSession.metadata.thread_id }),
+                    ...(activeSession.metadata.lifecycle === "archived" ? { unarchive: true } : {}),
+                    onThreadReady: (threadId) => {
+                        const updated = recordCodexTaskSessionThread(activeSession, threadId);
+                        activeSession = updated;
+                        input.setSession(updated);
+                    },
+                    ...(input.archiveAfterTurn === undefined
+                        ? {}
+                        : {
+                            archiveAfterTurn: input.archiveAfterTurn,
+                            onThreadArchived: () => {
+                                const updated = markCodexTaskSessionArchived(activeSession);
+                                activeSession = updated;
+                                input.setSession(updated);
+                            },
+                            onThreadArchiveFailure: () => {
+                                recordCodexSessionArchiveFailure(activeSession);
+                            },
+                        }),
+                },
+            }),
+        runtimeTelemetry: {
+            activityRef: input.pipelineInput.activity_ref,
+            stageId: `provider_task_${input.phase}`,
+            workspaceRoot: input.options.workspaceRoot,
+            onSnapshot: (snapshot) => input.pipelineInput.on_stage?.({
+                stage: `provider_task_${input.phase}`,
+                summary: input.phase === "execute"
+                    ? "running Codex task implementation."
+                    : input.phase === "finalize"
+                        ? "preparing the task result."
+                        : "recovering the task result.",
+                runtime: snapshot,
+            }),
+        },
+    });
+    let result;
+    try {
+        result = await invoke();
     }
-    if (options.recordUsage !== undefined && result.usage !== undefined) {
-        options.recordUsage({
+    catch (error) {
+        const canRetryBeforeTurn = error instanceof CodexAppServerWorkspaceWriteRunError &&
+            error.details.turn_start_state === "not_started" &&
+            (error.code === "app_server_protocol_error" || error.code === "thread_start_failed");
+        if (!canRetryBeforeTurn) {
+            throw error;
+        }
+        input.pipelineInput.on_stage?.({
+            stage: "provider_retry",
+            summary: "retrying the Codex connection before the task turn started.",
+        });
+        result = await invoke();
+    }
+    if (input.options.recordUsage !== undefined && result.usage !== undefined) {
+        input.options.recordUsage({
             provider: "openai",
-            source: usageSource(input),
+            source: usageSource(input.pipelineInput, input.phase),
             model: result.model,
             usage: result.usage,
-            activity_ref: input.activity_ref,
-            task_id: input.task.id,
-            run_lineage_kind: input.run_lineage.kind,
+            activity_ref: input.pipelineInput.activity_ref,
+            task_id: input.pipelineInput.task.id,
+            run_lineage_kind: input.pipelineInput.run_lineage.kind,
         });
     }
-    return normalizeTaskRunOutput(result.output);
+    return result;
+}
+function outputRecoveryEvidence(error) {
+    return {
+        previous_agent_output: error.details.agent_output ?? "",
+        provider_output_failure: {
+            kind: error.code === "output_parse_failed"
+                ? "malformed_or_missing_json"
+                : "schema_mismatch",
+            diagnostic: error.message,
+        },
+    };
+}
+function taskResultEndsCurrentLineage(output) {
+    return !("needs_human" in output.result);
+}
+function gateRecoveryEvidence(input) {
+    const context = input.correction_context;
+    return {
+        previous_provider_result: context.previous_provider_result,
+        gate_failure: {
+            summary: context.summary,
+            reason_code: context.reason_code,
+            guidance: context.guidance,
+            diagnostic: context.diagnostic,
+            promotion_failure: context.promotion_failure,
+        },
+    };
+}
+function recoveryEvidenceForRun(input) {
+    if (input.pipelineInput.run_lineage.kind !== "retry" ||
+        input.session === undefined) {
+        return input.current;
+    }
+    const persisted = readCodexSessionRecoveryEvidence(input.session);
+    if (persisted === null ||
+        persisted.owner_activity_ref !== input.pipelineInput.run_lineage.parent_activity_ref) {
+        return input.current;
+    }
+    return {
+        ...input.current,
+        previous_run_recovery_evidence: persisted.evidence,
+        previous_run_recovery_evidence_truncated: persisted.truncated,
+    };
+}
+function persistRecoveryEvidence(input) {
+    if (input.session === undefined) {
+        return;
+    }
+    writeCodexSessionRecoveryEvidence({
+        session: input.session,
+        ownerActivityRef: input.pipelineInput.activity_ref,
+        evidence: input.evidence,
+    });
+}
+export async function runWorkspaceWriteTask(options, input) {
+    let session = openTaskSession(options, input);
+    const releaseSessionLock = session === undefined ? undefined : acquireCodexTaskSessionLock(session);
+    const setSession = (updated) => {
+        session = updated;
+    };
+    const approvalHandler = createApprovalHandler(options, input);
+    const skillSelectionName = input.run_lineage.kind === "continuation" ? "follow_up_run" : "workspace_write_run";
+    try {
+        let structuredResult;
+        if (input.correction_context !== undefined) {
+            const recovery = recoveryEvidenceForRun({
+                pipelineInput: input,
+                session,
+                current: gateRecoveryEvidence(input),
+            });
+            persistRecoveryEvidence({ pipelineInput: input, session, evidence: recovery });
+            structuredResult = await runTaskTurn({
+                options,
+                pipelineInput: input,
+                prompt: createRecoveryPrompt({
+                    options,
+                    pipelineInput: input,
+                    session,
+                    recovery,
+                }),
+                phase: "recovery",
+                sandboxMode: "workspace-write",
+                networkAccess: true,
+                session,
+                setSession,
+                skillSelectionName,
+                ...(approvalHandler === undefined ? {} : { approvalHandler }),
+                outputSchema: TASK_RUN_OUTPUT_SCHEMA,
+                validateOutput: (value) => isInitialTaskRunOutput(value),
+                archiveAfterTurn: taskResultEndsCurrentLineage,
+            });
+        }
+        else {
+            await runTaskTurn({
+                options,
+                pipelineInput: input,
+                prompt: createExecutePrompt(options, input, session),
+                phase: "execute",
+                sandboxMode: "workspace-write",
+                networkAccess: true,
+                session,
+                setSession,
+                skillSelectionName,
+                ...(approvalHandler === undefined ? {} : { approvalHandler }),
+            });
+            try {
+                structuredResult = await runTaskTurn({
+                    options,
+                    pipelineInput: input,
+                    prompt: createFinalizePrompt(options),
+                    phase: "finalize",
+                    sandboxMode: "read-only",
+                    networkAccess: false,
+                    session,
+                    setSession,
+                    outputSchema: TASK_RUN_OUTPUT_SCHEMA,
+                    validateOutput: (value) => isInitialTaskRunOutput(value),
+                    archiveAfterTurn: taskResultEndsCurrentLineage,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof CodexAppServerWorkspaceWriteRunError) ||
+                    (error.code !== "output_parse_failed" && error.code !== "output_validation_failed")) {
+                    throw error;
+                }
+                const recovery = outputRecoveryEvidence(error);
+                persistRecoveryEvidence({ pipelineInput: input, session, evidence: recovery });
+                structuredResult = await runTaskTurn({
+                    options,
+                    pipelineInput: input,
+                    prompt: createRecoveryPrompt({
+                        options,
+                        pipelineInput: input,
+                        session,
+                        recovery,
+                    }),
+                    phase: "recovery",
+                    sandboxMode: "read-only",
+                    networkAccess: false,
+                    session,
+                    setSession,
+                    outputSchema: TASK_RUN_OUTPUT_SCHEMA,
+                    validateOutput: (value) => isInitialTaskRunOutput(value),
+                    archiveAfterTurn: taskResultEndsCurrentLineage,
+                });
+            }
+        }
+        return normalizeTaskRunOutput(structuredResult.output);
+    }
+    finally {
+        options.approvalManager?.clearPending();
+        releaseSessionLock?.();
+    }
 }
 //# sourceMappingURL=task-run-invocation.js.map

package/dist/server-shell/http/routes/project-api/execution-routes.js

@@ -1,9 +1,11 @@
-import { CursorPageRequestSchema, ExecutionStatusProjectionSchema, GetRecoverySummariesRequestSchema, GetRecoverySummariesResponseSchema, GetRecoverySummaryResponseSchema, TaskDetailProjectionSchema, TaskProjectionSchema, TaskRunResultsPageSchema, } from "@tutti/shared/schemas/api";
+import { CursorPageRequestSchema, ExecutionStatusProjectionSchema, GetRecoverySummariesRequestSchema, GetRecoverySummariesResponseSchema, GetRecoverySummaryResponseSchema, TaskDetailProjectionSchema, TaskProjectionSchema, TaskRunResultsPageSchema, RetryTaskBodySchema, RetryTaskResponseSchema, } from "@tutti/shared/schemas/api";
 import { createIdleExecutionStatusProjection, readRecoverySummariesPage, readRecoverySummaryProjection, readTaskDetailProjection, readTaskProjection, readTaskRunResultsPage, } from "../../../../collaboration-state/index.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
 import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
 import { HostProjectNotFoundError } from "./errors.js";
 import { RecoverySummaryParamsSchema, TaskParamsSchema, } from "./schemas.js";
-import { requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+import { requireControlPlane, requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+import { taskRetryInvalidates } from "./invalidations.js";
 export function registerExecutionRoutes(app, options) {
     app.get(`${HOST_PROJECT_API_BASE_PATH}/tasks/:taskId/detail`, {
         schema: {
@@ -36,6 +38,34 @@ export function registerExecutionRoutes(app, options) {
         }
         return page;
     });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/tasks/:taskId/retry`, {
+        schema: {
+            params: TaskParamsSchema,
+            body: RetryTaskBodySchema,
+            response: { 200: RetryTaskResponseSchema },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const controlPlane = requireControlPlane(options);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "task.retry",
+            target_ref: request.body.payload.expected_latest_run_result_id,
+            payload: {
+                task_id: request.params.taskId,
+                ...request.body.payload,
+            },
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => controlPlane.retryTask(request.params.taskId, request.body.payload),
+        });
+        return {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: taskRetryInvalidates(request.params.taskId),
+        };
+    });
     app.get(`${HOST_PROJECT_API_BASE_PATH}/recovery-summaries`, {
         schema: {
             querystring: GetRecoverySummariesRequestSchema,

package/dist/server-shell/http/routes/project-api/invalidations.d.ts

@@ -1,8 +1,9 @@
-import type { ClarificationRoundRef } from "@tutti/shared/ids";
+import type { ClarificationRoundRef, TaskId } from "@tutti/shared/ids";
 import type { QueryInvalidationHint, RunSchedulerNowDisposition } from "@tutti/shared/schemas/api";
 export declare function mainChatMessageInvalidates(): QueryInvalidationHint[];
 export declare function worklistSubmitInvalidates(): QueryInvalidationHint[];
 export declare function schedulerRunNowInvalidates(disposition: RunSchedulerNowDisposition): QueryInvalidationHint[];
+export declare function taskRetryInvalidates(taskId: TaskId): QueryInvalidationHint[];
 export declare function clarificationRoundInvalidates(roundId: ClarificationRoundRef): QueryInvalidationHint[];
 export declare function approvalInvalidates(): QueryInvalidationHint[];
 export declare function readStateInvalidates(): QueryInvalidationHint[];

package/dist/server-shell/http/routes/project-api/invalidations.js

@@ -31,6 +31,19 @@ export function schedulerRunNowInvalidates(disposition) {
         { kind: "task_run_results", task_id: disposition.task_id },
     ];
 }
+export function taskRetryInvalidates(taskId) {
+    return [
+        { kind: "worklist" },
+        { kind: "task", task_id: taskId },
+        { kind: "task_detail", task_id: taskId },
+        { kind: "task_run_results", task_id: taskId },
+        { kind: "execution_status" },
+        { kind: "messages", scope: "main_chat" },
+        { kind: "project_timeline" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+}
 export function clarificationRoundInvalidates(roundId) {
     return [
         { kind: "clarification", round_id: roundId },

package/dist/server-shell/http/routes/project-api/openapi-execution-routes.d.ts

@@ -24,6 +24,7 @@ export declare const HOST_PROJECT_EXECUTION_OPENAPI_ROUTES: ({
         };
     };
     querystring?: never;
+    requestBody?: never;
 } | {
     method: "get";
     path: string;
@@ -87,6 +88,7 @@ export declare const HOST_PROJECT_EXECUTION_OPENAPI_ROUTES: ({
                         }>>;
                         error_code: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
                         retryable: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+                        retry_action: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"retryable">, import("@sinclair/typebox").TLiteral<"retried">]>>;
                         updated_at: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
                     }>;
                     frozen_contract_since_activity_ref: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -96,6 +98,7 @@ export declare const HOST_PROJECT_EXECUTION_OPENAPI_ROUTES: ({
         };
     };
     querystring?: never;
+    requestBody?: never;
 } | {
     method: "get";
     path: string;
@@ -112,6 +115,21 @@ export declare const HOST_PROJECT_EXECUTION_OPENAPI_ROUTES: ({
             schema: import("@sinclair/typebox").TSchema;
         };
     };
+    requestBody?: never;
+} | {
+    method: "post";
+    path: string;
+    summary: string;
+    tags: string[];
+    parameters: import("@tutti/shared/schemas/api").BrowserFacingOpenApiParameter[];
+    requestBody: import("@sinclair/typebox").TSchema;
+    responses: {
+        200: {
+            description: string;
+            schema: import("@sinclair/typebox").TSchema;
+        };
+    };
+    querystring?: never;
 } | {
     method: "get";
     path: string;
@@ -128,6 +146,7 @@ export declare const HOST_PROJECT_EXECUTION_OPENAPI_ROUTES: ({
         };
     };
     parameters?: never;
+    requestBody?: never;
 } | {
     method: "get";
     path: string;
@@ -149,6 +168,7 @@ export declare const HOST_PROJECT_EXECUTION_OPENAPI_ROUTES: ({
         };
     };
     querystring?: never;
+    requestBody?: never;
 } | {
     method: "get";
     path: string;
@@ -228,5 +248,6 @@ export declare const HOST_PROJECT_EXECUTION_OPENAPI_ROUTES: ({
     };
     parameters?: never;
     querystring?: never;
+    requestBody?: never;
 })[];
 //# sourceMappingURL=openapi-execution-routes.d.ts.map