@xfey/tenso 0.1.130

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

@@ -0,0 +1,109 @@
+import type { ActivityRef, TaskId } from "@tutti/shared/ids";
+import { type OpenAiCredentialAccess } from "../execution-access.js";
+import type { CodexAppServerApprovalPolicy } from "../codex-app-server.js";
+import { type CodexAppServerJsonRpcError, type CodexAppServerJsonRpcServerRequest } from "./json-rpc.js";
+import { type CodexAppServerLifecycleIncident } from "./invocation-lifecycle.js";
+import { type CodexAppServerInvocationCoordinator, type CodexAppServerInvocationLease } from "./invocation-coordinator.js";
+import { type CodexAppServerRuntimeTelemetryOptions } from "./runtime-telemetry.js";
+import { type CodexAppServerAgentContextRuntime, type CodexAppServerSkillSelectionName } from "./skills.js";
+import { type OpenAiTokenUsage } from "../token-usage.js";
+export type CodexAppServerApprovalsReviewer = "user" | "auto_review" | "guardian_subagent";
+export type CodexAppServerApprovalResponse = {
+    kind: "result";
+    result: unknown;
+} | {
+    kind: "error";
+    error: CodexAppServerJsonRpcError;
+};
+export type CodexAppServerApprovalHandler = (input: {
+    request: CodexAppServerJsonRpcServerRequest;
+    context: {
+        workspaceRoot: string;
+        codexHome: string;
+        tuttiHome?: string;
+        builtInSkillsRoot?: string;
+        taskId?: TaskId;
+        activityRef?: ActivityRef;
+        turnTimeoutMs: number;
+        sensitiveValues: readonly string[];
+    };
+}) => Promise<CodexAppServerApprovalResponse>;
+export type CodexAppServerWorkspaceWriteRunInput<TOutput> = OpenAiCredentialAccess & {
+    apiBaseUrl?: string;
+    defaultModel?: string;
+    workspaceRoot: string;
+    prompt: string;
+    outputSchema?: unknown;
+    validateOutput?: (value: unknown) => value is TOutput;
+    sandboxMode?: "workspace-write" | "read-only";
+    session?: {
+        codexHome: string;
+        threadId?: string;
+        unarchive?: boolean;
+        onThreadReady?: (threadId: string) => void | Promise<void>;
+        archiveAfterTurn?: (output: TOutput) => boolean;
+        onThreadArchived?: () => void | Promise<void>;
+        onThreadArchiveFailure?: () => void | Promise<void>;
+    };
+    networkAccess?: boolean;
+    webSearchMode?: "disabled" | "cached" | "live";
+    approvalPolicy?: CodexAppServerApprovalPolicy;
+    approvalsReviewer?: CodexAppServerApprovalsReviewer;
+    skillSelectionName?: CodexAppServerSkillSelectionName;
+    tuttiHome?: string;
+    userSkillsRoot?: string;
+    builtInSkillsRoot?: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    approvalHandler?: CodexAppServerApprovalHandler;
+    approvalContext?: {
+        workspaceRoot?: string;
+        taskId?: TaskId;
+        activityRef?: ActivityRef;
+    };
+    strictLeakCheck?: boolean;
+    codexCommand?: string;
+    requestTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+    runtimeTelemetry?: CodexAppServerRuntimeTelemetryOptions;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    /** @internal Set only by the coordinator wrapper. */
+    invocationLease?: CodexAppServerInvocationLease;
+    /** @internal Overall deadline supplied by the managed credential wrapper. */
+    invocationDeadline?: number;
+};
+export type CodexAppServerWorkspaceWriteRunResult<TOutput> = {
+    output: TOutput;
+    thread_id: string;
+    model: string;
+    turn_status: "completed";
+    notification_count: number;
+    agent_message_event_count: number;
+    server_request_methods: string[];
+    stderr_had_output: boolean;
+    stderr_excerpt: string;
+    usage?: OpenAiTokenUsage;
+};
+export type CodexAppServerWorkspaceWriteRunErrorDetails = {
+    turn_start_state?: "not_started" | "start_requested" | "terminal";
+    turn_status?: string;
+    turn_error_message?: string;
+    turn_error_code?: string;
+    turn_error_http_status?: number;
+    turn_timeout_ms?: number;
+    last_activity_at?: string;
+    notification_count?: number;
+    server_request_methods?: string[];
+    notification_methods?: string[];
+    agent_message_excerpt?: string;
+    agent_output?: string;
+    stderr_excerpt?: string;
+};
+export declare class CodexAppServerWorkspaceWriteRunError extends Error {
+    readonly code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable" | "session_unavailable";
+    readonly details: CodexAppServerWorkspaceWriteRunErrorDetails;
+    constructor(code: "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable" | "session_unavailable", message: string, details?: CodexAppServerWorkspaceWriteRunErrorDetails);
+}
+export declare function runCodexAppServerWorkspaceWriteRun<TOutput>(options: CodexAppServerWorkspaceWriteRunInput<TOutput>): Promise<CodexAppServerWorkspaceWriteRunResult<TOutput>>;
+//# sourceMappingURL=workspace-write-run.d.ts.map

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

@@ -0,0 +1,520 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { discoverCodexAppServerSkills } from "./skill-discovery.js";
+import { managedInvocationBudget } from "../execution-access.js";
+import { armInvocationDeadline } from "./invocation-deadline.js";
+import { buildCodexAppServerProcessPlan } from "../codex-app-server.js";
+import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
+import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { CodexAppServerInvocation, CodexAppServerLifecycleError, createManagedProcess, } from "./invocation-lifecycle.js";
+import { CodexAppServerAdmissionError, } from "./invocation-coordinator.js";
+import { createCodexAppServerRuntimeObserver, } from "./runtime-telemetry.js";
+import { createReadOnlySandboxPolicy, createWorkspaceWriteSandboxPolicy, } from "./sandbox-policy.js";
+import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
+import { buildCodexAppServerTurnInput, resolveCodexAppServerContextRuntimeHint, resolveCodexAppServerSkillInputs, CodexAppServerSkillSelectionError, } from "./skills.js";
+import { compactText, containsKnownSecret, createCodexSpawnEnv, extractAgentText, extractServerRequestMethod, findJsonObjectCandidates, isApiKeyAccount, readThreadId, readTurnError, readTurnStatus, redactWithKnownValues, } from "./runtime-helpers.js";
+import { extractCodexAppServerTokenUsage } from "../token-usage.js";
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+const DEFAULT_TURN_TIMEOUT_MS = 1_200_000;
+const DEFAULT_WEB_SEARCH_MODE = "live";
+const DEFAULT_WORKSPACE_WRITE_APPROVAL_POLICY = "on-request";
+const DEFAULT_WORKSPACE_WRITE_APPROVALS_REVIEWER = "auto_review";
+const WORKSPACE_WRITE_APPROVALS_REVIEWER_ENV = "TUTTI_CODEX_APPROVALS_REVIEWER";
+export class CodexAppServerWorkspaceWriteRunError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "CodexAppServerWorkspaceWriteRunError";
+    }
+}
+function workspaceWriteWebSearchMode(input) {
+    if (input.networkAccess === false) {
+        return "disabled";
+    }
+    return input.webSearchMode ?? DEFAULT_WEB_SEARCH_MODE;
+}
+function buildWorkspaceWriteThreadConfig(input) {
+    return {
+        web_search: workspaceWriteWebSearchMode(input),
+    };
+}
+function isCodexAppServerApprovalsReviewer(value) {
+    return value === "user" || value === "auto_review" || value === "guardian_subagent";
+}
+function resolveWorkspaceWriteApprovalsReviewer(input) {
+    if (input.explicit !== undefined) {
+        return input.explicit;
+    }
+    const raw = input.env?.[WORKSPACE_WRITE_APPROVALS_REVIEWER_ENV]?.trim();
+    if (raw === undefined || raw === "") {
+        return DEFAULT_WORKSPACE_WRITE_APPROVALS_REVIEWER;
+    }
+    if (isCodexAppServerApprovalsReviewer(raw)) {
+        return raw;
+    }
+    throw new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", `${WORKSPACE_WRITE_APPROVALS_REVIEWER_ENV} must be one of: user, auto_review, guardian_subagent.`);
+}
+function isTurnWaitTimeout(error) {
+    return (error instanceof CodexAppServerProtocolError &&
+        (error.code === "notification_timeout" || error.code === "server_request_timeout"));
+}
+function workspaceWriteTimeoutDetails(input) {
+    const details = {
+        turn_timeout_ms: input.turnTimeoutMs,
+        notification_count: input.client.notifications.length,
+        server_request_methods: input.client.serverRequests.map(extractServerRequestMethod),
+        notification_methods: input.client.notifications
+            .map((notification) => notification.method)
+            .slice(-20),
+        stderr_excerpt: redactWithKnownValues(input.client.stderr, input.sensitiveValues).slice(0, 500),
+    };
+    if (input.client.lastActivityAt !== undefined) {
+        details.last_activity_at = input.client.lastActivityAt;
+    }
+    return details;
+}
+function isUnsupportedApprovalResponse(response) {
+    return (response.kind === "error" &&
+        (response.error.code === "unsupported_approval_request" ||
+            response.error.code === "approval_already_pending"));
+}
+async function waitForWorkspaceWriteTurnCompletion(input) {
+    const deadline = Date.now() + input.turnTimeoutMs;
+    for (;;) {
+        const remainingMs = Math.max(1, deadline - Date.now());
+        const turnCompletedPromise = input.client.waitForNotification((notification) => notification.method === "turn/completed", remainingMs);
+        const serverRequestPromise = input.client.waitForServerRequest(remainingMs);
+        let completedOrRequest;
+        try {
+            completedOrRequest = await Promise.race([
+                turnCompletedPromise.then((notification) => ({
+                    kind: "completed",
+                    notification,
+                })),
+                serverRequestPromise.then((request) => ({
+                    kind: "server_request",
+                    request,
+                })),
+            ]);
+        }
+        catch (error) {
+            if (isTurnWaitTimeout(error)) {
+                throw new CodexAppServerWorkspaceWriteRunError("turn_timeout", "Codex app-server turn timed out before completion or an interactive server request.", workspaceWriteTimeoutDetails({
+                    client: input.client,
+                    turnTimeoutMs: input.turnTimeoutMs,
+                    sensitiveValues: input.sensitiveValues,
+                }));
+            }
+            throw error;
+        }
+        if (completedOrRequest.kind === "completed") {
+            return completedOrRequest.notification;
+        }
+        if (input.approvalHandler === undefined) {
+            throw new CodexAppServerWorkspaceWriteRunError("unexpected_server_request", `Codex app-server requested interactive handling: ${completedOrRequest.request.method}`);
+        }
+        const response = await input.approvalHandler({
+            request: completedOrRequest.request,
+            context: {
+                ...input.approvalContext,
+                turnTimeoutMs: Math.max(1, deadline - Date.now()),
+            },
+        });
+        if (isUnsupportedApprovalResponse(response)) {
+            throw new CodexAppServerWorkspaceWriteRunError("unexpected_server_request", `Codex app-server requested unsupported interactive handling: ${completedOrRequest.request.method}`);
+        }
+        if (response.kind === "result") {
+            input.client.respondToServerRequest(completedOrRequest.request.id, response.result);
+        }
+        else {
+            input.client.rejectServerRequest(completedOrRequest.request.id, response.error);
+        }
+    }
+}
+function parseWorkspaceWriteStructuredJson(text) {
+    const candidates = findJsonObjectCandidates(text);
+    if (candidates.length === 0) {
+        throw new CodexAppServerWorkspaceWriteRunError("output_parse_failed", "Codex app-server did not return a JSON object.");
+    }
+    for (const jsonText of candidates.toReversed()) {
+        try {
+            return JSON.parse(jsonText);
+        }
+        catch {
+            // Keep looking: earlier agent progress can contain brace-shaped text.
+        }
+    }
+    throw new CodexAppServerWorkspaceWriteRunError("output_parse_failed", "Codex app-server returned malformed JSON.");
+}
+export async function runCodexAppServerWorkspaceWriteRun(options) {
+    if (options.invocationCoordinator !== undefined && options.invocationLease === undefined) {
+        let lease;
+        try {
+            lease = await options.invocationCoordinator.acquire();
+        }
+        catch (error) {
+            throw new CodexAppServerWorkspaceWriteRunError("admission_unavailable", error instanceof CodexAppServerAdmissionError
+                ? error.message
+                : "Codex app-server admission is unavailable.");
+        }
+        try {
+            return await runCodexAppServerWorkspaceWriteRun({
+                ...options,
+                invocationLease: lease,
+            });
+        }
+        finally {
+            lease.release();
+        }
+    }
+    if (options.invocationLease?.isClosing?.()) {
+        throw new CodexAppServerWorkspaceWriteRunError("admission_unavailable", "Codex app-server admission is closed.");
+    }
+    if (options.credentialLease !== undefined) {
+        const { credentialLease, ...invocation } = options;
+        const budget = managedInvocationBudget(options.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS);
+        return credentialLease(budget, (apiKey) => runCodexAppServerWorkspaceWriteRun({
+            ...invocation,
+            apiKey,
+            invocationDeadline: Date.now() + budget,
+        }));
+    }
+    let skillInputs;
+    let contextRuntimeHint;
+    try {
+        skillInputs = resolveCodexAppServerSkillInputs({
+            ...(options.skillSelectionName === undefined
+                ? {}
+                : { selectionName: options.skillSelectionName }),
+            ...(options.userSkillsRoot === undefined ? {} : { userSkillsRoot: options.userSkillsRoot }),
+            ...(options.builtInSkillsRoot === undefined
+                ? {}
+                : { builtInSkillsRoot: options.builtInSkillsRoot }),
+        });
+        contextRuntimeHint = resolveCodexAppServerContextRuntimeHint({
+            ...(options.approvalContext?.activityRef === undefined
+                ? {}
+                : { activityRef: options.approvalContext.activityRef }),
+            ...(options.skillSelectionName === undefined
+                ? {}
+                : { selectionName: options.skillSelectionName }),
+            ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CodexAppServerWorkspaceWriteRunError(error instanceof CodexAppServerSkillSelectionError
+            ? "skill_selection_failed"
+            : "app_server_protocol_error", redactWithKnownValues(message, [
+            options.apiKey,
+            options.workspaceRoot,
+            options.tuttiHome ?? "",
+            options.userSkillsRoot ?? "",
+            options.builtInSkillsRoot ?? "",
+        ]));
+    }
+    const model = options.defaultModel ?? DEFAULT_OPENAI_MODEL;
+    const tempRoot = mkdtempSync(join(tmpdir(), "tutti-codex-workspace-write-run-"));
+    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 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,
+    });
+    const modelProvider = resolveCodexAppServerModelProvider(options);
+    const processPlan = buildCodexAppServerProcessPlan({
+        codexHome,
+        configOverrides: buildCodexAppServerProviderConfigOverrides(options),
+        ...(options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }),
+    });
+    const managedProcess = createManagedProcess(spawn(processPlan.command, processPlan.args, {
+        cwd: process.cwd(),
+        detached: process.platform !== "win32",
+        env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
+        stdio: "pipe",
+    }));
+    const child = managedProcess.child;
+    const runtimeObserver = options.runtimeTelemetry === undefined
+        ? undefined
+        : createCodexAppServerRuntimeObserver(options.runtimeTelemetry);
+    const client = new CodexAppServerJsonRpcClient(child, {
+        ...(runtimeObserver === undefined
+            ? {}
+            : {
+                onNotification: runtimeObserver.notification,
+                onServerRequest: runtimeObserver.serverRequest,
+            }),
+    });
+    const invocation = new CodexAppServerInvocation({
+        managedProcess,
+        tempRoot,
+        closeProtocol: () => client.close(),
+        ...(options.onLifecycleIncident === undefined
+            ? {}
+            : { onIncident: options.onLifecycleIncident }),
+    });
+    options.invocationLease?.setCloser(() => invocation.close());
+    const disarmDeadline = armInvocationDeadline(invocation, options.invocationDeadline);
+    const sensitiveValues = [
+        options.apiKey,
+        tempRoot,
+        codexHome,
+        options.workspaceRoot,
+        options.tuttiHome ?? "",
+        options.userSkillsRoot ?? "",
+        options.builtInSkillsRoot ?? "",
+        ...(contextRuntimeHint?.sensitiveValues ?? []),
+        ...skillInputs.flatMap((skill) => [skill.path, dirname(skill.path)]),
+    ];
+    const strictLeakCheckValues = [options.apiKey, ...(contextRuntimeHint?.sensitiveValues ?? [])];
+    let primaryError;
+    let runResult;
+    let lifecycleError;
+    let turnStartState = "not_started";
+    try {
+        await client.request("initialize", {
+            clientInfo: {
+                name: "tutti-workspace-write-run",
+                title: "Tenso Workspace-write Run",
+                version: "0.0.0",
+            },
+            capabilities: {
+                experimentalApi: false,
+            },
+        }, requestTimeoutMs);
+        client.notify("initialized");
+        const loginResponse = await client.request("account/login/start", {
+            type: "apiKey",
+            apiKey: options.apiKey,
+        }, requestTimeoutMs);
+        if (!isApiKeyAccount(loginResponse)) {
+            throw new CodexAppServerWorkspaceWriteRunError("auth_failed", "Codex app-server did not accept API key auth.");
+        }
+        await discoverCodexAppServerSkills({
+            client,
+            cwd: options.workspaceRoot,
+            skills: skillInputs,
+            requestTimeoutMs,
+        });
+        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({
+                prompt: options.prompt,
+                skills: skillInputs,
+                ...(contextRuntimeHint === undefined ? {} : { runtimeHints: [contextRuntimeHint.text] }),
+            }),
+            cwd: options.workspaceRoot,
+            approvalPolicy,
+            approvalsReviewer,
+            sandboxPolicy: sandboxMode === "read-only"
+                ? createReadOnlySandboxPolicy({ networkEnabled })
+                : createWorkspaceWriteSandboxPolicy(options.workspaceRoot, {
+                    networkEnabled,
+                }),
+            model,
+            modelProvider,
+            ...(options.outputSchema === undefined ? {} : { outputSchema: options.outputSchema }),
+        }, requestTimeoutMs);
+        const turnCompletedNotification = await waitForWorkspaceWriteTurnCompletion({
+            client,
+            turnTimeoutMs,
+            sensitiveValues,
+            ...(options.approvalHandler === undefined
+                ? {}
+                : { approvalHandler: options.approvalHandler }),
+            approvalContext: {
+                workspaceRoot: options.approvalContext?.workspaceRoot ?? options.workspaceRoot,
+                codexHome,
+                ...(options.tuttiHome === undefined ? {} : { tuttiHome: options.tuttiHome }),
+                ...(options.builtInSkillsRoot === undefined
+                    ? {}
+                    : { builtInSkillsRoot: options.builtInSkillsRoot }),
+                ...(options.approvalContext?.taskId === undefined
+                    ? {}
+                    : { taskId: options.approvalContext.taskId }),
+                ...(options.approvalContext?.activityRef === undefined
+                    ? {}
+                    : { activityRef: options.approvalContext.activityRef }),
+                sensitiveValues,
+            },
+        });
+        turnStartState = "terminal";
+        if (client.serverRequests.length > 0) {
+            const unresolved = client.serverRequests.find((request) => client.isServerRequestPending(request.id));
+            if (unresolved !== undefined) {
+                throw new CodexAppServerWorkspaceWriteRunError("unexpected_server_request", `Codex app-server requested interactive handling: ${unresolved.method}`);
+            }
+        }
+        const turnStatus = readTurnStatus(turnCompletedNotification.params);
+        if (turnStatus !== "completed") {
+            await client.waitForOutputSettle({ quietMs: 25, maxWaitMs: 250 });
+            const turnError = readTurnError(turnCompletedNotification.params);
+            const agentText = client.notifications
+                .map((notification) => extractAgentText(notification))
+                .join("");
+            const details = {
+                ...(turnStatus === null ? {} : { turn_status: turnStatus }),
+                ...(turnError.message === undefined
+                    ? {}
+                    : { turn_error_message: redactWithKnownValues(turnError.message, sensitiveValues) }),
+                ...(turnError.code === undefined ? {} : { turn_error_code: turnError.code }),
+                ...(turnError.httpStatus === undefined
+                    ? {}
+                    : { turn_error_http_status: turnError.httpStatus }),
+                server_request_methods: client.serverRequests.map(extractServerRequestMethod),
+                notification_methods: client.notifications
+                    .map((notification) => notification.method)
+                    .slice(-20),
+                agent_message_excerpt: compactText(redactWithKnownValues(agentText, sensitiveValues), 500),
+                stderr_excerpt: redactWithKnownValues(client.stderr, sensitiveValues).slice(0, 500),
+            };
+            const detailSuffix = details.turn_error_message === undefined ? "" : `: ${details.turn_error_message}`;
+            throw new CodexAppServerWorkspaceWriteRunError("turn_failed", `Codex app-server turn did not complete successfully: ${turnStatus ?? "unknown"}${detailSuffix}`, details);
+        }
+        await client.waitForOutputSettle({ quietMs: 25, maxWaitMs: 250 });
+        const agentText = client.notifications
+            .map((notification) => extractAgentText(notification))
+            .join("");
+        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,
+            thread_id: threadId,
+            model,
+            turn_status: "completed",
+            notification_count: client.notifications.length,
+            agent_message_event_count: client.notifications.filter((notification) => notification.method === "item/agentMessage/delta" ||
+                notification.method === "item/completed").length,
+            server_request_methods: client.serverRequests.map(extractServerRequestMethod),
+            stderr_had_output: client.stderr.length > 0,
+            stderr_excerpt: redactWithKnownValues(client.stderr, sensitiveValues).slice(0, 500),
+            ...(usage === undefined ? {} : { usage }),
+        };
+    }
+    catch (error) {
+        if (error instanceof CodexAppServerWorkspaceWriteRunError) {
+            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), { turn_start_state: turnStartState });
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            primaryError = new CodexAppServerWorkspaceWriteRunError(error instanceof CodexAppServerSkillSelectionError
+                ? "skill_selection_failed"
+                : "app_server_protocol_error", redactWithKnownValues(message, sensitiveValues), { turn_start_state: turnStartState });
+        }
+    }
+    finally {
+        disarmDeadline();
+        runtimeObserver?.flush();
+        try {
+            await invocation.close();
+        }
+        catch (error) {
+            invocation.reportProcessTerminationFailure(error);
+            lifecycleError = error;
+        }
+    }
+    if (primaryError !== undefined) {
+        throw primaryError;
+    }
+    if (lifecycleError !== undefined) {
+        throw new CodexAppServerWorkspaceWriteRunError("process_lifecycle_failed", lifecycleError instanceof CodexAppServerLifecycleError
+            ? lifecycleError.message
+            : "Codex app-server process lifecycle did not close cleanly.", { turn_start_state: turnStartState });
+    }
+    return runResult;
+}
+//# sourceMappingURL=workspace-write-run.js.map

package/dist/providers/openai/chat-assistant.d.ts

@@ -0,0 +1,40 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type ReadOnlyChatAssistantModel } from "../../chat-assistant/index.js";
+import { type OpenAiCredentialAccess, type OpenAiExecutionConfig } from "./execution-access.js";
+import type { CodexAppServerAgentContextRuntime } from "./app-server/skills.js";
+import type { CodexAppServerInvocationCoordinator } from "./app-server/invocation-coordinator.js";
+import type { CodexAppServerLifecycleIncident } from "./app-server/invocation-lifecycle.js";
+import type { ProviderUsageRecorder } from "../../provider-usage/index.js";
+export type OpenAiReadOnlyChatAssistantModelOptions = OpenAiCredentialAccess & {
+    config: OpenAiExecutionConfig;
+    workspaceRoot: string;
+    tuttiHome?: string;
+    userSkillsRoot?: string;
+    builtInSkillsRoot?: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    codexCommand?: string;
+    requestTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+    recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
+};
+export type ProjectOpenAiReadOnlyChatAssistantModelOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
+};
+export type ReadOnlyChatAssistantModelResolution = {
+    kind: "ready";
+    model: ReadOnlyChatAssistantModel;
+} | {
+    kind: "not_configured";
+};
+export declare function createOpenAiReadOnlyChatAssistantModel(options: OpenAiReadOnlyChatAssistantModelOptions): ReadOnlyChatAssistantModel;
+export declare function resolveProjectOpenAiReadOnlyChatAssistantModel(options: ProjectOpenAiReadOnlyChatAssistantModelOptions): ReadOnlyChatAssistantModelResolution;
+//# sourceMappingURL=chat-assistant.d.ts.map