@xfey/tutti 0.1.93 → 0.1.95

package/dist/providers/openai/app-server/workspace-write-run.js

@@ -8,7 +8,7 @@ import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./jso
 import { CodexAppServerInvocation, CodexAppServerLifecycleError, createManagedProcess, } from "./invocation-lifecycle.js";
 import { CodexAppServerAdmissionError, } from "./invocation-coordinator.js";
 import { createCodexAppServerRuntimeObserver, } from "./runtime-telemetry.js";
-import { createWorkspaceWriteSandboxPolicy } from "./sandbox-policy.js";
+import { createReadOnlySandboxPolicy, createWorkspaceWriteSandboxPolicy, } from "./sandbox-policy.js";
 import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
 import { buildCodexAppServerTurnInput, resolveCodexAppServerContextRuntimeHint, resolveCodexAppServerSkillsListWarmup, resolveCodexAppServerSkillInputs, CodexAppServerSkillSelectionError, } from "./skills.js";
 import { compactText, containsKnownSecret, createCodexSpawnEnv, extractAgentText, extractServerRequestMethod, findJsonObjectCandidates, isApiKeyAccount, readThreadId, readTurnError, readTurnStatus, redactWithKnownValues, } from "./runtime-helpers.js";
@@ -204,12 +204,14 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
     }
     const model = options.defaultModel ?? DEFAULT_OPENAI_MODEL;
     const tempRoot = mkdtempSync(join(tmpdir(), "tutti-codex-workspace-write-run-"));
-    const codexHome = join(tempRoot, "codex-home");
+    const codexHome = options.session?.codexHome ?? join(tempRoot, "codex-home");
     mkdirSync(codexHome, { recursive: true, mode: 0o700 });
     const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     const turnTimeoutMs = options.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
     const networkEnabled = options.networkAccess ?? true;
-    const approvalPolicy = options.approvalPolicy ?? DEFAULT_WORKSPACE_WRITE_APPROVAL_POLICY;
+    const sandboxMode = options.sandboxMode ?? "workspace-write";
+    const approvalPolicy = options.approvalPolicy ??
+        (sandboxMode === "read-only" ? "never" : DEFAULT_WORKSPACE_WRITE_APPROVAL_POLICY);
     const approvalsReviewer = resolveWorkspaceWriteApprovalsReviewer({
         ...(options.approvalsReviewer === undefined ? {} : { explicit: options.approvalsReviewer }),
         env: options.baseEnv ?? process.env,
@@ -269,6 +271,7 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
     let primaryError;
     let runResult;
     let lifecycleError;
+    let turnStartState = "not_started";
     try {
         await client.request("initialize", {
             clientInfo: {
@@ -291,22 +294,43 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
         if (skillsListWarmup !== undefined) {
             await client.request("skills/list", skillsListWarmup, requestTimeoutMs);
         }
-        const threadStartResponse = await client.request("thread/start", {
-            cwd: options.workspaceRoot,
-            model,
-            modelProvider,
-            approvalPolicy,
-            approvalsReviewer,
-            sandbox: "workspace-write",
-            config: buildWorkspaceWriteThreadConfig(options),
-            ephemeral: true,
-            experimentalRawEvents: false,
-            persistExtendedHistory: false,
-        }, requestTimeoutMs);
-        const threadId = readThreadId(threadStartResponse);
+        let threadId;
+        if (options.session?.threadId === undefined) {
+            const threadStartResponse = await client.request("thread/start", {
+                cwd: options.workspaceRoot,
+                model,
+                modelProvider,
+                approvalPolicy,
+                approvalsReviewer,
+                sandbox: sandboxMode,
+                config: buildWorkspaceWriteThreadConfig(options),
+                ephemeral: options.session === undefined,
+                experimentalRawEvents: false,
+                persistExtendedHistory: false,
+            }, requestTimeoutMs);
+            threadId = readThreadId(threadStartResponse);
+        }
+        else {
+            if (options.session.unarchive === true) {
+                await client.request("thread/unarchive", { threadId: options.session.threadId }, requestTimeoutMs);
+            }
+            const threadResumeResponse = await client.request("thread/resume", {
+                threadId: options.session.threadId,
+                cwd: options.workspaceRoot,
+                model,
+                modelProvider,
+                approvalPolicy,
+                approvalsReviewer,
+                sandbox: sandboxMode,
+                config: buildWorkspaceWriteThreadConfig(options),
+            }, requestTimeoutMs);
+            threadId = readThreadId(threadResumeResponse) ?? options.session.threadId;
+        }
         if (threadId === null) {
             throw new CodexAppServerWorkspaceWriteRunError("thread_start_failed", "Codex app-server did not return a thread id.");
         }
+        await options.session?.onThreadReady?.(threadId);
+        turnStartState = "start_requested";
         await client.request("turn/start", {
             threadId,
             input: buildCodexAppServerTurnInput({
@@ -319,12 +343,14 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
             cwd: options.workspaceRoot,
             approvalPolicy,
             approvalsReviewer,
-            sandboxPolicy: createWorkspaceWriteSandboxPolicy(options.workspaceRoot, {
-                networkEnabled,
-            }),
+            sandboxPolicy: sandboxMode === "read-only"
+                ? createReadOnlySandboxPolicy({ networkEnabled })
+                : createWorkspaceWriteSandboxPolicy(options.workspaceRoot, {
+                    networkEnabled,
+                }),
             model,
             modelProvider,
-            outputSchema: options.outputSchema,
+            ...(options.outputSchema === undefined ? {} : { outputSchema: options.outputSchema }),
         }, requestTimeoutMs);
         const turnCompletedNotification = await waitForWorkspaceWriteTurnCompletion({
             client,
@@ -349,6 +375,7 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
                 sensitiveValues,
             },
         });
+        turnStartState = "terminal";
         if (client.serverRequests.length > 0) {
             const unresolved = client.serverRequests.find((request) => client.isServerRequestPending(request.id));
             if (unresolved !== undefined) {
@@ -385,17 +412,51 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
         const agentText = client.notifications
             .map((notification) => extractAgentText(notification))
             .join("");
-        const parsed = parseWorkspaceWriteStructuredJson(agentText);
-        if (!options.validateOutput(parsed)) {
-            throw new CodexAppServerWorkspaceWriteRunError("output_validation_failed", "Codex app-server structured output did not match the expected schema.");
+        let output;
+        if (options.outputSchema === undefined && options.validateOutput === undefined) {
+            output = agentText;
+        }
+        else {
+            if (options.outputSchema === undefined || options.validateOutput === undefined) {
+                throw new CodexAppServerWorkspaceWriteRunError("output_validation_failed", "Codex app-server structured output configuration is incomplete.");
+            }
+            let parsed;
+            try {
+                parsed = parseWorkspaceWriteStructuredJson(agentText);
+            }
+            catch (error) {
+                if (error instanceof CodexAppServerWorkspaceWriteRunError) {
+                    throw new CodexAppServerWorkspaceWriteRunError(error.code, error.message, {
+                        ...error.details,
+                        agent_output: redactWithKnownValues(agentText, sensitiveValues).slice(0, 16_000),
+                    });
+                }
+                throw error;
+            }
+            if (!options.validateOutput(parsed)) {
+                throw new CodexAppServerWorkspaceWriteRunError("output_validation_failed", "Codex app-server structured output did not match the expected schema.", {
+                    agent_output: redactWithKnownValues(agentText, sensitiveValues).slice(0, 16_000),
+                });
+            }
+            output = parsed;
         }
         const rawOutput = `${client.rawStdout}\n${client.stderr}`;
         if (options.strictLeakCheck === true && containsKnownSecret(rawOutput, strictLeakCheckValues)) {
             throw new CodexAppServerWorkspaceWriteRunError("secret_leak_detected", "Codex app-server output contained a sensitive runtime value.");
         }
         const usage = extractCodexAppServerTokenUsage(client.notifications);
+        if (options.session?.archiveAfterTurn?.(output) === true) {
+            try {
+                await client.request("thread/archive", { threadId }, requestTimeoutMs);
+                await options.session.onThreadArchived?.();
+            }
+            catch {
+                await options.session.onThreadArchiveFailure?.();
+            }
+        }
         runResult = {
-            output: parsed,
+            output,
+            thread_id: threadId,
             model,
             turn_status: "completed",
             notification_count: client.notifications.length,
@@ -409,14 +470,17 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
     }
     catch (error) {
         if (error instanceof CodexAppServerWorkspaceWriteRunError) {
-            primaryError = error;
+            primaryError = new CodexAppServerWorkspaceWriteRunError(error.code, error.message, {
+                ...error.details,
+                turn_start_state: turnStartState,
+            });
         }
         else if (error instanceof CodexAppServerProtocolError) {
-            primaryError = new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues));
+            primaryError = new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues), { turn_start_state: turnStartState });
         }
         else {
             const message = error instanceof Error ? error.message : String(error);
-            primaryError = new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
+            primaryError = new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues), { turn_start_state: turnStartState });
         }
     }
     finally {
@@ -435,7 +499,7 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
     if (lifecycleError !== undefined) {
         throw new CodexAppServerWorkspaceWriteRunError("process_lifecycle_failed", lifecycleError instanceof CodexAppServerLifecycleError
             ? lifecycleError.message
-            : "Codex app-server process lifecycle did not close cleanly.");
+            : "Codex app-server process lifecycle did not close cleanly.", { turn_start_state: turnStartState });
     }
     return runResult;
 }

package/dist/providers/openai/codex-app-server.d.ts

@@ -1,3 +1,4 @@
+export declare const CODEX_APP_SERVER_VERSION: string;
 export declare const CODEX_APP_SERVER_ENTRYPOINT: string;
 export declare const CODEX_APP_SERVER_COMMAND: string;
 export declare const CODEX_APP_SERVER_LISTEN_URL: "stdio://";

package/dist/providers/openai/codex-app-server.js

@@ -2,6 +2,8 @@ import { createRequire } from "node:module";
 import { dirname, isAbsolute, join } from "node:path";
 import { DEFAULT_OPENAI_MODEL } from "./model-config.js";
 const require = createRequire(import.meta.url);
+const codexPackage = require("@openai/codex/package.json");
+export const CODEX_APP_SERVER_VERSION = codexPackage.version;
 export const CODEX_APP_SERVER_ENTRYPOINT = join(dirname(require.resolve("@openai/codex/package.json")), "bin", "codex.js");
 export const CODEX_APP_SERVER_COMMAND = process.execPath;
 export const CODEX_APP_SERVER_LISTEN_URL = "stdio://";

package/dist/run-pipeline/openai.d.ts

@@ -18,6 +18,7 @@ export type OpenAiRunPipelineRunnerOptions = {
     workspaceRoot: string;
     promptsRoot?: string;
     tuttiHome?: string;
+    projectId?: ProjectId;
     userSkillsRoot?: string;
     builtInSkillsRoot?: string;
     agentContext?: CodexAppServerAgentContextRuntime;

package/dist/run-pipeline/openai.js

@@ -17,17 +17,18 @@ function summarizeProviderError(error) {
         error.message.includes("invalid_json_schema") ||
         error.message.includes("Invalid schema") ||
         error.message.includes("response_format");
+    const turnStateUnknown = error.details.turn_start_state === "start_requested";
     const errorCode = looksLikeSchemaError
         ? "codex_app_server_output_schema_invalid"
-        : `codex_app_server_${error.code}`;
+        : turnStateUnknown
+            ? "codex_app_server_turn_state_unknown"
+            : `codex_app_server_${error.code}`;
     return failedBeforeChecks({
         summary: `Provider execution failed before checks. (${errorCode})`,
         errorCode,
         retryable: !looksLikeSchemaError &&
-            (error.code === "app_server_protocol_error" ||
-                error.code === "turn_timeout" ||
-                error.code === "turn_failed" ||
-                error.code === "thread_start_failed"),
+            error.details.turn_start_state === "not_started" &&
+            (error.code === "app_server_protocol_error" || error.code === "thread_start_failed"),
     });
 }
 function summarizeWorkspaceOpsError(error, changedPaths) {
@@ -153,12 +154,12 @@ function loggedSyncStage(options, input, stage, run, completedFields = () => ({}
     }
 }
 const MAX_SELF_CORRECTION_RETRIES = 1;
-const MAX_PROVIDER_TRANSIENT_RETRIES = 1;
 function runPipelineResultPromotion(result) {
     return "promotion" in result ? result.promotion : undefined;
 }
 function buildCorrectionContext(input) {
     const correction = {
+        previous_provider_result: input.previousProviderResult,
         summary: input.result.summary,
         reason_code: input.reasonCode,
         guidance: input.guidance,
@@ -189,23 +190,12 @@ function selfCorrectionInput(input, nextAttempt, correctionContext) {
     return {
         ...input,
         run_lineage: {
-            kind: "retry",
+            ...input.run_lineage,
             attempt: nextAttempt,
-            parent_activity_ref: input.activity_ref,
-            root_activity_ref: input.run_lineage.root_activity_ref ?? input.activity_ref,
         },
         correction_context: correctionContext,
     };
 }
-function providerTransientRetryInput(input) {
-    return {
-        ...input,
-        run_lineage: {
-            ...input.run_lineage,
-            attempt: input.run_lineage.attempt + 1,
-        },
-    };
-}
 function appendSelfCorrectionExhaustedSummary(input) {
     if (input.attemptedRetries <= 0) {
         return input.result;
@@ -218,12 +208,6 @@ function appendSelfCorrectionExhaustedSummary(input) {
 function isSelfCorrectionRequest(result) {
     return "request_kind" in result && result.request_kind === "self_correction";
 }
-function isProviderTransientRunFailure(result) {
-    return (!isSelfCorrectionRequest(result) &&
-        result.result_kind === "failed" &&
-        result.retryable &&
-        result.error_code.startsWith("codex_app_server_"));
-}
 async function runTaskAttempt(options, input) {
     let changedPaths;
     try {
@@ -289,8 +273,9 @@ async function runTaskAttempt(options, input) {
             });
             return requestSelfCorrection({
                 result,
+                previousProviderResult: taskOutput,
                 reasonCode: "no_candidate_changes",
-                guidance: "Produce a concrete candidate diff for the frozen task contract.",
+                guidance: "Produce a concrete candidate diff for the current task goal and scope.",
             });
         }
         const artifactGate = await loggedAsyncStage(options, input, "artifact_candidate_validate", () => runArtifactCandidateGate({
@@ -336,6 +321,7 @@ async function runTaskAttempt(options, input) {
             }
             return requestSelfCorrection({
                 result: artifactResult,
+                previousProviderResult: taskOutput,
                 reasonCode: artifactGate.failure.reason_code,
                 guidance: artifactGate.failure.guidance,
                 diagnostic: artifactGate.failure.diagnostic,
@@ -361,6 +347,7 @@ async function runTaskAttempt(options, input) {
             });
             return requestSelfCorrection({
                 result,
+                previousProviderResult: taskOutput,
                 reasonCode: "checks_failed",
                 guidance: "Use the failed checks summary to fix the candidate so the task can pass Tutti checks.",
             });
@@ -378,8 +365,9 @@ async function runTaskAttempt(options, input) {
             });
             return requestSelfCorrection({
                 result,
+                previousProviderResult: taskOutput,
                 reasonCode: "no_candidate_changes",
-                guidance: "Produce a concrete final candidate diff for the frozen task contract.",
+                guidance: "Produce a concrete final candidate diff for the current task goal and scope.",
             });
         }
         const checkpoint = loggedSyncStage(options, input, "accepted_checkpoint", () => createAcceptedCheckpoint({
@@ -444,25 +432,8 @@ export function createOpenAiRunPipelineRunner(options) {
         async runTask(input) {
             let currentInput = input;
             let selfCorrectionRetries = 0;
-            let providerTransientRetries = 0;
             for (;;) {
                 const result = await runTaskAttempt(options, currentInput);
-                if (isProviderTransientRunFailure(result) &&
-                    providerTransientRetries < MAX_PROVIDER_TRANSIENT_RETRIES) {
-                    providerTransientRetries += 1;
-                    input.on_stage?.({
-                        stage: "provider_retry",
-                        summary: "retrying Codex task after a transient provider failure.",
-                    });
-                    logRunPipelineStage(options, currentInput, {
-                        stage: "provider_retry",
-                        next_attempt: currentInput.run_lineage.attempt + 1,
-                        error_code: result.error_code,
-                    }, "Run pipeline scheduling provider transient retry");
-                    currentInput = providerTransientRetryInput(currentInput);
-                    continue;
-                }
-                providerTransientRetries = 0;
                 if (!isSelfCorrectionRequest(result)) {
                     return result;
                 }
@@ -512,6 +483,7 @@ export function resolveProjectOpenAiRunPipelineRunner(options) {
             apiKey: credential.secret,
             workspaceRoot: options.workspaceRoot,
             tuttiHome: options.tuttiHome,
+            projectId: options.projectId,
             userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
             ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
             ...(options.approvalManager === undefined