@xfey/tenso 0.1.130

package/dist/providers/openai/app-server/read-only-procedure.js

@@ -0,0 +1,485 @@
+import { execFileSync, 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 { reportProviderInvocationProgress, } from "../../invocation-progress.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 } from "./sandbox-policy.js";
+import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
+import { buildCodexAppServerTurnInput, resolveCodexAppServerContextRuntimeHint, resolveCodexAppServerSkillInputs, CodexAppServerSkillSelectionError, } from "./skills.js";
+import { containsKnownSecret, createCodexSpawnEnv, extractAgentText, extractServerRequestMethod, findJsonObjectCandidates, isRecord, isApiKeyAccount, readThreadId, readTurnError, readTurnStatus, redactWithKnownValues, compactText, } from "./runtime-helpers.js";
+import { extractCodexAppServerTokenUsage } from "../token-usage.js";
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+const DEFAULT_TURN_TIMEOUT_MS = 600_000;
+const DEFAULT_WEB_SEARCH_MODE = "live";
+export class CodexAppServerReadOnlyProcedureError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "CodexAppServerReadOnlyProcedureError";
+    }
+}
+export function resolveReadOnlyWebSearchMode(input) {
+    if (input.networkAccess === false) {
+        return "disabled";
+    }
+    return input.webSearchMode ?? DEFAULT_WEB_SEARCH_MODE;
+}
+export function buildReadOnlyThreadConfig(input) {
+    return {
+        web_search: resolveReadOnlyWebSearchMode(input),
+    };
+}
+function readGitStatus(repoRoot) {
+    return execFileSync("git", ["status", "--porcelain", "--untracked-files=all"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+    });
+}
+function isTurnWaitTimeout(error) {
+    return (error instanceof CodexAppServerProtocolError &&
+        (error.code === "notification_timeout" || error.code === "server_request_timeout"));
+}
+function readOnlyTimeoutDetails(input) {
+    const details = {
+        turn_timeout_ms: input.turnTimeoutMs,
+        notification_count: input.client.notifications.length,
+        completed_tool_count: structuredOutputDetails(input.client, "").completed_tool_count ?? 0,
+        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;
+}
+export function parseCodexAppServerStructuredJson(text) {
+    const candidates = findJsonObjectCandidates(text);
+    if (candidates.length === 0) {
+        throw new CodexAppServerReadOnlyProcedureError("output_parse_failed", "Codex app-server did not return a JSON object.", {
+            output_parse_reason: "no_json_object",
+            agent_output_chars: text.length,
+            json_candidate_count: 0,
+        });
+    }
+    for (const jsonText of candidates.toReversed()) {
+        try {
+            return JSON.parse(jsonText);
+        }
+        catch {
+            // Earlier app-server progress can contain brace-shaped text.
+        }
+    }
+    throw new CodexAppServerReadOnlyProcedureError("output_parse_failed", "Codex app-server returned malformed JSON.", {
+        output_parse_reason: "malformed_json",
+        agent_output_chars: text.length,
+        json_candidate_count: candidates.length,
+    });
+}
+/** Counts only; model text, tool arguments and stderr never enter structured diagnostics. */
+function structuredOutputDetails(client, text) {
+    const itemTypes = client.notifications.flatMap((notification) => {
+        const params = notification.params;
+        return notification.method === "item/completed" &&
+            isRecord(params) &&
+            isRecord(params.item) &&
+            typeof params.item.type === "string"
+            ? [params.item.type]
+            : [];
+    });
+    return {
+        turn_status: "completed",
+        notification_count: client.notifications.length,
+        notification_methods: client.notifications
+            .map((notification) => notification.method)
+            .slice(-20),
+        server_request_methods: client.serverRequests.map(extractServerRequestMethod),
+        agent_output_chars: text.length,
+        json_candidate_count: findJsonObjectCandidates(text).length,
+        agent_message_count: itemTypes.filter((type) => type === "agentMessage").length,
+        completed_tool_count: itemTypes.filter((type) => ["commandExecution", "mcpToolCall", "dynamicToolCall", "imageView", "webSearch"].includes(type)).length,
+        file_tool_count: itemTypes.filter((type) => ["commandExecution", "imageView"].includes(type))
+            .length,
+    };
+}
+export async function runCodexAppServerReadOnlyProcedure(options) {
+    if (options.invocationCoordinator !== undefined && options.invocationLease === undefined) {
+        reportProviderInvocationProgress(options.onProgress, { stage: "provider_queued" });
+        let lease;
+        try {
+            lease = await options.invocationCoordinator.acquire();
+        }
+        catch (error) {
+            throw new CodexAppServerReadOnlyProcedureError("admission_unavailable", error instanceof CodexAppServerAdmissionError
+                ? error.message
+                : "Codex app-server admission is unavailable.");
+        }
+        try {
+            return await runCodexAppServerReadOnlyProcedure({
+                ...options,
+                invocationLease: lease,
+            });
+        }
+        finally {
+            lease.release();
+        }
+    }
+    if (options.invocationLease?.isClosing?.()) {
+        throw new CodexAppServerReadOnlyProcedureError("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) => runCodexAppServerReadOnlyProcedure({
+            ...invocation,
+            apiKey,
+            invocationDeadline: Date.now() + budget,
+        }));
+    }
+    reportProviderInvocationProgress(options.onProgress, { stage: "provider_started" });
+    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.runtimeTelemetry?.activityRef === undefined
+                ? {}
+                : { activityRef: options.runtimeTelemetry.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 CodexAppServerReadOnlyProcedureError(error instanceof CodexAppServerSkillSelectionError
+            ? "skill_selection_failed"
+            : "app_server_protocol_error", redactWithKnownValues(message, [
+            options.apiKey,
+            options.workspaceRoot,
+            options.appServerCwd ?? "",
+            options.tuttiHome ?? "",
+            options.userSkillsRoot ?? "",
+            options.builtInSkillsRoot ?? "",
+        ]));
+    }
+    if (contextRuntimeHint !== undefined)
+        reportProviderInvocationProgress(options.onProgress, {
+            stage: "context_ready",
+            ...(contextRuntimeHint.invocation_ref === undefined
+                ? {}
+                : { invocation_ref: contextRuntimeHint.invocation_ref }),
+        });
+    const model = options.defaultModel ?? DEFAULT_OPENAI_MODEL;
+    const tempRoot = mkdtempSync(join(tmpdir(), "tutti-codex-readonly-procedure-"));
+    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 appServerCwd = options.appServerCwd ?? options.workspaceRoot;
+    const readablePaths = options.readablePaths === undefined || options.readablePaths.length === 0
+        ? [options.workspaceRoot]
+        : options.readablePaths;
+    const gitStatusBefore = readGitStatus(options.workspaceRoot);
+    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,
+        appServerCwd,
+        ...readablePaths,
+        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 procedureResult;
+    let lifecycleError;
+    try {
+        await client.request("initialize", {
+            clientInfo: {
+                name: "tutti-readonly-procedure",
+                title: "Tenso Read-only Procedure",
+                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 CodexAppServerReadOnlyProcedureError("auth_failed", "Codex app-server did not accept API key auth.");
+        }
+        await discoverCodexAppServerSkills({
+            client,
+            cwd: appServerCwd,
+            skills: skillInputs,
+            requestTimeoutMs,
+        });
+        reportProviderInvocationProgress(options.onProgress, {
+            stage: "skills_ready",
+            skill_count: skillInputs.length,
+        });
+        let threadId;
+        if (options.session?.threadId === undefined) {
+            const threadStartResponse = await client.request("thread/start", {
+                cwd: appServerCwd,
+                model,
+                modelProvider,
+                approvalPolicy: "never",
+                sandbox: "read-only",
+                config: buildReadOnlyThreadConfig(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: appServerCwd,
+                model,
+                modelProvider,
+                approvalPolicy: "never",
+                sandbox: "read-only",
+                config: buildReadOnlyThreadConfig(options),
+            }, requestTimeoutMs);
+            threadId = readThreadId(threadResumeResponse) ?? options.session.threadId;
+        }
+        if (threadId === null) {
+            throw new CodexAppServerReadOnlyProcedureError("thread_start_failed", "Codex app-server did not return a thread id.");
+        }
+        await options.session?.onThreadReady?.(threadId);
+        await client.request("turn/start", {
+            threadId,
+            input: buildCodexAppServerTurnInput({
+                prompt: options.prompt,
+                skills: skillInputs,
+                ...(contextRuntimeHint === undefined ? {} : { runtimeHints: [contextRuntimeHint.text] }),
+            }),
+            cwd: appServerCwd,
+            approvalPolicy: "never",
+            sandboxPolicy: createReadOnlySandboxPolicy({
+                networkEnabled,
+            }),
+            model,
+            modelProvider,
+            outputSchema: options.outputSchema,
+        }, requestTimeoutMs);
+        reportProviderInvocationProgress(options.onProgress, { stage: "turn_started" });
+        const turnCompletedPromise = client.waitForNotification((notification) => notification.method === "turn/completed", turnTimeoutMs);
+        const serverRequestPromise = client.waitForServerRequest(turnTimeoutMs);
+        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 CodexAppServerReadOnlyProcedureError("turn_timeout", "Codex app-server turn timed out before completion or an interactive server request.", readOnlyTimeoutDetails({ client, turnTimeoutMs, sensitiveValues }));
+            }
+            throw error;
+        }
+        if (completedOrRequest.kind === "server_request") {
+            throw new CodexAppServerReadOnlyProcedureError("unexpected_server_request", `Codex app-server requested interactive handling: ${completedOrRequest.request.method}`);
+        }
+        if (client.serverRequests.length > 0) {
+            throw new CodexAppServerReadOnlyProcedureError("unexpected_server_request", `Codex app-server requested interactive handling: ${client.serverRequests[0]?.method ?? "unknown"}`);
+        }
+        const turnStatus = readTurnStatus(completedOrRequest.notification.params);
+        if (turnStatus !== "completed") {
+            await client.waitForOutputSettle({ quietMs: 25, maxWaitMs: 250 });
+            const turnError = readTurnError(completedOrRequest.notification.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 }),
+                notification_count: client.notifications.length,
+                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 CodexAppServerReadOnlyProcedureError("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("");
+        reportProviderInvocationProgress(options.onProgress, {
+            stage: "turn_completed",
+            completed_tool_count: structuredOutputDetails(client, agentText).completed_tool_count ?? 0,
+        });
+        let parsed;
+        try {
+            parsed = parseCodexAppServerStructuredJson(agentText);
+        }
+        catch (error) {
+            if (!(error instanceof CodexAppServerReadOnlyProcedureError))
+                throw error;
+            throw new CodexAppServerReadOnlyProcedureError(error.code, error.message, {
+                ...structuredOutputDetails(client, agentText),
+                ...error.details,
+            });
+        }
+        if (!options.validateOutput(parsed)) {
+            throw new CodexAppServerReadOnlyProcedureError("output_validation_failed", "Codex app-server structured output did not match the expected schema.", structuredOutputDetails(client, agentText));
+        }
+        if (options.requireFileToolUse === true) {
+            const details = structuredOutputDetails(client, agentText);
+            if (details.file_tool_count === 0) {
+                throw new CodexAppServerReadOnlyProcedureError("file_read_not_observed", "Codex app-server did not attempt to inspect the summary source file.", details);
+            }
+        }
+        const gitStatusAfter = readGitStatus(options.workspaceRoot);
+        if (gitStatusAfter !== gitStatusBefore) {
+            throw new CodexAppServerReadOnlyProcedureError("write_detected", "Codex app-server read-only Procedure changed the repository.");
+        }
+        const rawOutput = `${client.rawStdout}\n${client.stderr}`;
+        if (options.strictLeakCheck === true && containsKnownSecret(rawOutput, strictLeakCheckValues)) {
+            throw new CodexAppServerReadOnlyProcedureError("secret_leak_detected", "Codex app-server output contained a sensitive runtime value.");
+        }
+        const usage = extractCodexAppServerTokenUsage(client.notifications);
+        if (options.session?.archiveAfterTurn?.(parsed) === true) {
+            try {
+                await client.request("thread/archive", { threadId }, requestTimeoutMs);
+                await options.session.onThreadArchived?.();
+            }
+            catch {
+                await options.session.onThreadArchiveFailure?.();
+            }
+        }
+        procedureResult = {
+            output: parsed,
+            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),
+            git_status_unchanged: true,
+            stderr_had_output: client.stderr.length > 0,
+            stderr_excerpt: redactWithKnownValues(client.stderr, sensitiveValues).slice(0, 500),
+            ...(usage === undefined ? {} : { usage }),
+        };
+    }
+    catch (error) {
+        if (error instanceof CodexAppServerReadOnlyProcedureError) {
+            primaryError = error;
+        }
+        else if (error instanceof CodexAppServerSkillSelectionError) {
+            primaryError = new CodexAppServerReadOnlyProcedureError("skill_selection_failed", error.message);
+        }
+        else if (error instanceof CodexAppServerProtocolError) {
+            primaryError = new CodexAppServerReadOnlyProcedureError("app_server_protocol_error", redactWithKnownValues(error.message, sensitiveValues));
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            primaryError = new CodexAppServerReadOnlyProcedureError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
+        }
+    }
+    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 CodexAppServerReadOnlyProcedureError("process_lifecycle_failed", lifecycleError instanceof CodexAppServerLifecycleError
+            ? lifecycleError.message
+            : "Codex app-server process lifecycle did not close cleanly.");
+    }
+    return procedureResult;
+}
+//# sourceMappingURL=read-only-procedure.js.map

package/dist/providers/openai/app-server/runtime-helpers.d.ts

@@ -0,0 +1,20 @@
+import type { CodexAppServerJsonRpcNotification, CodexAppServerJsonRpcServerRequest } from "./json-rpc.js";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isApiKeyAccount(value: unknown): value is {
+    type: "apiKey";
+};
+export declare function readThreadId(value: unknown): string | null;
+export declare function readTurnStatus(value: unknown): string | null;
+export declare function readTurnError(value: unknown): {
+    message?: string;
+    code?: string;
+    httpStatus?: number;
+};
+export declare function extractServerRequestMethod(value: CodexAppServerJsonRpcServerRequest): string;
+export declare function extractAgentText(notification: CodexAppServerJsonRpcNotification): string;
+export declare function createCodexSpawnEnv(codexHome: string, baseEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function redactWithKnownValues(value: string, sensitiveValues: readonly string[]): string;
+export declare function containsKnownSecret(value: string, secrets: readonly string[]): boolean;
+export declare function compactText(value: string, maxLength: number): string;
+export declare function findJsonObjectCandidates(value: string): string[];
+//# sourceMappingURL=runtime-helpers.d.ts.map

package/dist/providers/openai/app-server/runtime-helpers.js

@@ -0,0 +1,151 @@
+import { isAbsolute } from "node:path";
+import { REDACTION_LABELS, redactText } from "@tutti/shared/utils";
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isApiKeyAccount(value) {
+    return isRecord(value) && value.type === "apiKey";
+}
+export function readThreadId(value) {
+    if (!isRecord(value) || !isRecord(value.thread) || typeof value.thread.id !== "string") {
+        return null;
+    }
+    return value.thread.id;
+}
+export function readTurnStatus(value) {
+    if (!isRecord(value) || !isRecord(value.turn) || typeof value.turn.status !== "string") {
+        return null;
+    }
+    return value.turn.status;
+}
+export function readTurnError(value) {
+    if (!isRecord(value) || !isRecord(value.turn) || !isRecord(value.turn.error)) {
+        return {};
+    }
+    const error = value.turn.error;
+    const details = {};
+    if (typeof error.message === "string") {
+        details.message = error.message;
+    }
+    if (typeof error.code === "string") {
+        details.code = error.code;
+    }
+    if (isRecord(error.codexErrorInfo)) {
+        const [firstKey] = Object.keys(error.codexErrorInfo);
+        if (firstKey !== undefined) {
+            details.code = firstKey;
+            const nested = error.codexErrorInfo[firstKey];
+            if (isRecord(nested) && typeof nested.httpStatusCode === "number") {
+                details.httpStatus = nested.httpStatusCode;
+            }
+        }
+    }
+    return details;
+}
+export function extractServerRequestMethod(value) {
+    return value.method;
+}
+export function extractAgentText(notification) {
+    if (!isRecord(notification.params)) {
+        return "";
+    }
+    if (notification.method === "item/agentMessage/delta" &&
+        typeof notification.params.delta === "string") {
+        return notification.params.delta;
+    }
+    if (notification.method === "item/completed" &&
+        isRecord(notification.params.item) &&
+        notification.params.item.type === "agentMessage" &&
+        typeof notification.params.item.text === "string") {
+        return notification.params.item.text;
+    }
+    return "";
+}
+export function createCodexSpawnEnv(codexHome, baseEnv) {
+    const env = {
+        CODEX_HOME: codexHome,
+    };
+    if (baseEnv.PATH !== undefined) {
+        env.PATH = baseEnv.PATH;
+    }
+    if (baseEnv.HOME !== undefined) {
+        env.HOME = baseEnv.HOME;
+    }
+    return env;
+}
+export function redactWithKnownValues(value, sensitiveValues) {
+    let redacted = redactText(value);
+    const orderedSensitiveValues = [...sensitiveValues]
+        .filter((sensitiveValue) => sensitiveValue !== "")
+        .sort((left, right) => right.length - left.length);
+    for (const sensitiveValue of orderedSensitiveValues) {
+        redacted = redacted
+            .split(sensitiveValue)
+            .join(isAbsolute(sensitiveValue) ? REDACTION_LABELS.localPath : "[REDACTED]");
+    }
+    return redacted;
+}
+export function containsKnownSecret(value, secrets) {
+    return secrets.some((secret) => secret !== "" && value.includes(secret));
+}
+export function compactText(value, maxLength) {
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength)}...`;
+}
+function stripJsonFence(value) {
+    const trimmed = value.trim();
+    const fenceMatch = /^```(?:json)?\s*([\s\S]*?)\s*```$/iu.exec(trimmed);
+    return fenceMatch?.[1]?.trim() ?? trimmed;
+}
+export function findJsonObjectCandidates(value) {
+    const text = stripJsonFence(value);
+    const candidates = [];
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (start < 0) {
+            if (char === "{") {
+                start = index;
+                depth = 1;
+            }
+            continue;
+        }
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+            continue;
+        }
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                candidates.push(text.slice(start, index + 1));
+                start = -1;
+                inString = false;
+                escaped = false;
+            }
+        }
+    }
+    return candidates;
+}
+//# sourceMappingURL=runtime-helpers.js.map

package/dist/providers/openai/app-server/runtime-telemetry.d.ts

@@ -0,0 +1,19 @@
+import type { ActivityRef } from "@tutti/shared/ids";
+import type { ExecutionRuntimeSnapshot } from "@tutti/shared/schemas/api";
+import type { CodexAppServerJsonRpcNotification, CodexAppServerJsonRpcServerRequest } from "./json-rpc.js";
+export type CodexAppServerRuntimeTelemetryOptions = {
+    activityRef: ActivityRef;
+    stageId?: string;
+    startedAt?: string;
+    workspaceRoot?: string;
+    actionMinVisibleMs?: number;
+    now?: () => Date;
+    onSnapshot?: (snapshot: ExecutionRuntimeSnapshot) => void;
+};
+export type CodexAppServerRuntimeObserver = {
+    notification: (notification: CodexAppServerJsonRpcNotification) => void;
+    serverRequest: (request: CodexAppServerJsonRpcServerRequest) => void;
+    flush: () => void;
+};
+export declare function createCodexAppServerRuntimeObserver(options: CodexAppServerRuntimeTelemetryOptions): CodexAppServerRuntimeObserver;
+//# sourceMappingURL=runtime-telemetry.d.ts.map