@xfey/tutti 0.1.0

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

@@ -0,0 +1,157 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CODEX_APP_SERVER_COMMAND, CODEX_APP_SERVER_LISTEN_URL, buildCodexAppServerProcessPlan, } from "../codex-app-server.js";
+import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
+import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { createReadOnlyPermissionProfile } from "./permission-profile.js";
+import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
+import { containsKnownSecret, countAvailableModels, createCodexSpawnEnv, createSmokeRepo, extractAgentText, extractNotificationMethod, isApiKeyAccount, modelListContains, readAccountType, readGitStatus, readThreadId, readTurnStatus, redactWithKnownValues, renderNoWriteSmokePrompt, } from "./smoke-helpers.js";
+import { resolveCodexAppServerSmokeProviderInput } from "./smoke-provider-input.js";
+import { CODEX_APP_SERVER_READ_ONLY_SMOKE_OUTPUT_SCHEMA, CodexAppServerSmokeError, DEFAULT_REQUEST_TIMEOUT_MS, DEFAULT_TURN_TIMEOUT_MS, SMOKE_SENTINEL, } from "./smoke-types.js";
+export { CODEX_APP_SERVER_COMMAND, CODEX_APP_SERVER_LISTEN_URL };
+export { resolveCodexAppServerSmokeProviderInput };
+export { CodexAppServerSmokeError, SMOKE_SENTINEL, } from "./smoke-types.js";
+export async function runCodexAppServerNoWriteSmoke(options) {
+    const model = options.defaultModel ?? DEFAULT_OPENAI_MODEL;
+    const tempRoot = mkdtempSync(join(tmpdir(), "tutti-codex-app-server-smoke-"));
+    const codexHome = join(tempRoot, "codex-home");
+    mkdirSync(codexHome, { recursive: true, mode: 0o700 });
+    const repoRoot = createSmokeRepo(tempRoot);
+    const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const turnTimeoutMs = options.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS;
+    const modelProvider = resolveCodexAppServerModelProvider(options);
+    const processPlan = buildCodexAppServerProcessPlan({
+        codexHome,
+        configOverrides: buildCodexAppServerProviderConfigOverrides(options),
+    });
+    const command = options.codexCommand ?? processPlan.command;
+    const child = spawn(command, processPlan.args, {
+        cwd: process.cwd(),
+        env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
+        stdio: "pipe",
+    });
+    const client = new CodexAppServerJsonRpcClient(child);
+    try {
+        await client.request("initialize", {
+            clientInfo: {
+                name: "tutti-smoke",
+                title: "Tutti Smoke",
+                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 CodexAppServerSmokeError("auth_failed", "Codex app-server did not accept API key auth.");
+        }
+        const accountResponse = await client.request("account/read", { refreshToken: false }, requestTimeoutMs);
+        const accountType = readAccountType(accountResponse);
+        if (accountType !== "apiKey") {
+            throw new CodexAppServerSmokeError("auth_failed", "Codex app-server account/read is not apiKey.");
+        }
+        const modelListResponse = await client.request("model/list", { includeHidden: false, limit: 50 }, requestTimeoutMs);
+        const modelCount = countAvailableModels(modelListResponse);
+        const defaultModelAvailable = modelListContains(modelListResponse, model);
+        if (!defaultModelAvailable) {
+            throw new CodexAppServerSmokeError("model_unavailable", "Codex app-server model/list does not include the configured default model.");
+        }
+        const threadStartResponse = await client.request("thread/start", {
+            cwd: repoRoot,
+            model,
+            modelProvider,
+            approvalPolicy: "never",
+            permissionProfile: createReadOnlyPermissionProfile(repoRoot),
+            ephemeral: true,
+            experimentalRawEvents: false,
+            persistExtendedHistory: false,
+        }, requestTimeoutMs);
+        const threadId = readThreadId(threadStartResponse);
+        if (threadId === null) {
+            throw new CodexAppServerSmokeError("thread_start_failed", "Codex app-server did not return a thread id.");
+        }
+        await client.request("turn/start", {
+            threadId,
+            input: [
+                {
+                    type: "text",
+                    text: renderNoWriteSmokePrompt(),
+                    text_elements: [],
+                },
+            ],
+            cwd: repoRoot,
+            approvalPolicy: "never",
+            permissionProfile: createReadOnlyPermissionProfile(repoRoot),
+            model,
+            modelProvider,
+            outputSchema: CODEX_APP_SERVER_READ_ONLY_SMOKE_OUTPUT_SCHEMA,
+        }, requestTimeoutMs);
+        const serverRequestPromise = client
+            .waitForServerRequest(turnTimeoutMs)
+            .then((request) => {
+            throw new CodexAppServerSmokeError("unexpected_server_request", `Codex app-server requested interactive handling: ${request.method}`);
+        });
+        const turnCompletedPromise = client.waitForNotification((notification) => notification.method === "turn/completed", turnTimeoutMs);
+        const turnCompleted = await Promise.race([turnCompletedPromise, serverRequestPromise]);
+        const turnStatus = readTurnStatus(turnCompleted.params);
+        if (turnStatus !== "completed") {
+            throw new CodexAppServerSmokeError("turn_failed", `Codex app-server turn did not complete successfully: ${turnStatus ?? "unknown"}`);
+        }
+        await client.waitForOutputSettle({ quietMs: 25, maxWaitMs: 250 });
+        const agentText = client.notifications
+            .map((notification) => extractAgentText(notification))
+            .join("");
+        if (!agentText.includes(SMOKE_SENTINEL)) {
+            throw new CodexAppServerSmokeError("sentinel_missing", "Codex app-server completed but did not return the README sentinel.");
+        }
+        const gitStatus = readGitStatus(repoRoot);
+        if (gitStatus !== "") {
+            throw new CodexAppServerSmokeError("write_detected", "Codex app-server no-write smoke changed the temporary repository.");
+        }
+        const sensitiveValues = [options.apiKey, tempRoot, codexHome, repoRoot];
+        const rawOutput = `${client.rawStdout}\n${client.stderr}`;
+        if (options.strictLeakCheck === true && containsKnownSecret(rawOutput, [options.apiKey])) {
+            throw new CodexAppServerSmokeError("secret_leak_detected", "Codex app-server output contained the provider API key.");
+        }
+        const stderrExcerpt = redactWithKnownValues(client.stderr, sensitiveValues).slice(0, 500);
+        return {
+            status: "passed",
+            model,
+            account_type: "apiKey",
+            model_count: modelCount,
+            default_model_available: defaultModelAvailable,
+            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(extractNotificationMethod),
+            git_status_clean: true,
+            stderr_had_output: client.stderr.length > 0,
+            stderr_excerpt: stderrExcerpt,
+        };
+    }
+    catch (error) {
+        if (error instanceof CodexAppServerSmokeError) {
+            throw error;
+        }
+        if (error instanceof CodexAppServerProtocolError) {
+            throw new CodexAppServerSmokeError("app_server_protocol_error", redactWithKnownValues(error.message, [options.apiKey, tempRoot, codexHome, repoRoot]));
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CodexAppServerSmokeError("app_server_protocol_error", redactWithKnownValues(message, [options.apiKey, tempRoot, codexHome, repoRoot]));
+    }
+    finally {
+        client.dispose();
+        if (options.keepTemp !== true) {
+            rmSync(tempRoot, { recursive: true, force: true });
+        }
+    }
+}
+//# sourceMappingURL=smoke.js.map

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

@@ -0,0 +1,87 @@
+import type { ActivityRef, TaskId } from "@tutti/shared/ids";
+import type { CodexAppServerApprovalPolicy } from "../codex-app-server.js";
+import { type CodexAppServerJsonRpcError, type CodexAppServerJsonRpcServerRequest } from "./json-rpc.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;
+        runWorkspaceRoot: string;
+        codexHome: string;
+        tuttiHome?: string;
+        builtInSkillsRoot?: string;
+        taskId?: TaskId;
+        activityRef?: ActivityRef;
+        turnTimeoutMs: number;
+        sensitiveValues: readonly string[];
+    };
+}) => Promise<CodexAppServerApprovalResponse>;
+export type CodexAppServerWorkspaceWriteRunInput<TOutput> = {
+    apiKey: string;
+    apiBaseUrl?: string;
+    defaultModel?: string;
+    workspaceRoot: string;
+    prompt: string;
+    outputSchema: unknown;
+    validateOutput: (value: unknown) => value is TOutput;
+    networkAccess?: boolean;
+    webSearchMode?: "disabled" | "cached" | "live";
+    approvalPolicy?: CodexAppServerApprovalPolicy;
+    approvalsReviewer?: CodexAppServerApprovalsReviewer;
+    skillSelectionName?: CodexAppServerSkillSelectionName;
+    tuttiHome?: string;
+    builtInSkillsRoot?: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    approvalHandler?: CodexAppServerApprovalHandler;
+    approvalContext?: {
+        workspaceRoot?: string;
+        runWorkspaceRoot?: string;
+        taskId?: TaskId;
+        activityRef?: ActivityRef;
+    };
+    strictLeakCheck?: boolean;
+    codexCommand?: string;
+    requestTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+};
+export type CodexAppServerWorkspaceWriteRunResult<TOutput> = {
+    output: TOutput;
+    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_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;
+    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";
+    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", 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,379 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildCodexAppServerProcessPlan } from "../codex-app-server.js";
+import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
+import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { createWorkspaceWritePermissionProfile } from "./permission-profile.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";
+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) {
+    let skillInputs;
+    let skillsListWarmup;
+    let contextRuntimeHint;
+    try {
+        skillInputs = resolveCodexAppServerSkillInputs({
+            ...(options.skillSelectionName === undefined ? {} : { selectionName: options.skillSelectionName }),
+            ...(options.tuttiHome === undefined ? {} : { tuttiHome: options.tuttiHome }),
+            ...(options.builtInSkillsRoot === undefined
+                ? {}
+                : { builtInSkillsRoot: options.builtInSkillsRoot }),
+        });
+        skillsListWarmup = resolveCodexAppServerSkillsListWarmup({
+            cwd: options.workspaceRoot,
+            ...(options.skillSelectionName === undefined ? {} : { selectionName: options.skillSelectionName }),
+            ...(options.tuttiHome === undefined ? {} : { tuttiHome: options.tuttiHome }),
+        });
+        contextRuntimeHint = resolveCodexAppServerContextRuntimeHint({
+            ...(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.builtInSkillsRoot ?? "",
+        ]));
+    }
+    const model = options.defaultModel ?? DEFAULT_OPENAI_MODEL;
+    const tempRoot = mkdtempSync(join(tmpdir(), "tutti-codex-workspace-write-run-"));
+    const 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 approvalsReviewer = resolveWorkspaceWriteApprovalsReviewer({
+        ...(options.approvalsReviewer === undefined ? {} : { explicit: options.approvalsReviewer }),
+        env: options.baseEnv ?? process.env,
+    });
+    const modelProvider = resolveCodexAppServerModelProvider(options);
+    const processPlan = buildCodexAppServerProcessPlan({
+        codexHome,
+        configOverrides: buildCodexAppServerProviderConfigOverrides(options),
+    });
+    const command = options.codexCommand ?? processPlan.command;
+    const child = spawn(command, processPlan.args, {
+        cwd: process.cwd(),
+        env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
+        stdio: "pipe",
+    });
+    const client = new CodexAppServerJsonRpcClient(child);
+    const sensitiveValues = [
+        options.apiKey,
+        tempRoot,
+        codexHome,
+        options.workspaceRoot,
+        options.tuttiHome ?? "",
+        options.builtInSkillsRoot ?? "",
+        ...(contextRuntimeHint?.sensitiveValues ?? []),
+        ...skillInputs.map((skill) => skill.path),
+        ...(skillsListWarmup?.perCwdExtraUserRoots.flatMap((entry) => [
+            entry.cwd,
+            ...entry.extraUserRoots,
+        ]) ?? []),
+    ];
+    const strictLeakCheckValues = [
+        options.apiKey,
+        ...(contextRuntimeHint?.sensitiveValues ?? []),
+    ];
+    try {
+        await client.request("initialize", {
+            clientInfo: {
+                name: "tutti-workspace-write-run",
+                title: "Tutti 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.");
+        }
+        if (skillsListWarmup !== undefined) {
+            await client.request("skills/list", skillsListWarmup, requestTimeoutMs);
+        }
+        const threadStartResponse = await client.request("thread/start", {
+            cwd: options.workspaceRoot,
+            model,
+            modelProvider,
+            approvalPolicy,
+            approvalsReviewer,
+            permissionProfile: createWorkspaceWritePermissionProfile(options.workspaceRoot, {
+                networkEnabled,
+            }),
+            config: buildWorkspaceWriteThreadConfig(options),
+            ephemeral: true,
+            experimentalRawEvents: false,
+            persistExtendedHistory: false,
+        }, requestTimeoutMs);
+        const threadId = readThreadId(threadStartResponse);
+        if (threadId === null) {
+            throw new CodexAppServerWorkspaceWriteRunError("thread_start_failed", "Codex app-server did not return a thread id.");
+        }
+        await client.request("turn/start", {
+            threadId,
+            input: buildCodexAppServerTurnInput({
+                prompt: options.prompt,
+                skills: skillInputs,
+                ...(contextRuntimeHint === undefined
+                    ? {}
+                    : { runtimeHints: [contextRuntimeHint.text] }),
+            }),
+            cwd: options.workspaceRoot,
+            approvalPolicy,
+            approvalsReviewer,
+            permissionProfile: createWorkspaceWritePermissionProfile(options.workspaceRoot, {
+                networkEnabled,
+            }),
+            model,
+            modelProvider,
+            outputSchema: options.outputSchema,
+        }, requestTimeoutMs);
+        const turnCompletedNotification = await waitForWorkspaceWriteTurnCompletion({
+            client,
+            turnTimeoutMs,
+            sensitiveValues,
+            ...(options.approvalHandler === undefined
+                ? {}
+                : { approvalHandler: options.approvalHandler }),
+            approvalContext: {
+                workspaceRoot: options.approvalContext?.workspaceRoot ?? options.workspaceRoot,
+                runWorkspaceRoot: options.approvalContext?.runWorkspaceRoot ?? 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,
+            },
+        });
+        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("");
+        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.");
+        }
+        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);
+        return {
+            output: parsed,
+            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) {
+            throw error;
+        }
+        if (error instanceof CodexAppServerProtocolError) {
+            throw new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues));
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
+    }
+    finally {
+        client.dispose();
+        rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=workspace-write-run.js.map

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

@@ -0,0 +1,34 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type ReadOnlyChatAssistantModel } from "../../chat-assistant/index.js";
+import { type OpenAiProviderConfig } from "./provider-config.js";
+import type { CodexAppServerAgentContextRuntime } from "./app-server/skills.js";
+import type { ProviderUsageRecorder } from "../../provider-usage/index.js";
+export type OpenAiReadOnlyChatAssistantModelOptions = {
+    config: OpenAiProviderConfig;
+    apiKey: string;
+    workspaceRoot: string;
+    tuttiHome?: string;
+    builtInSkillsRoot?: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    codexCommand?: string;
+    requestTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+    recordUsage?: ProviderUsageRecorder;
+};
+export type ProjectOpenAiReadOnlyChatAssistantModelOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    recordUsage?: ProviderUsageRecorder;
+};
+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