visionclaw 0.1.193 → 0.1.194-dev.feat-backup-progress-reporting.1

package/dist/agent/engines/openai/session.js

@@ -1,1066 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { Agent, OpenAIResponsesCompactionSession, Runner, setTracingDisabled } from "@openai/agents";
-import { getOpenAISessionsDir, loadSessionId, loadUsageSnapshot, saveSessionId, saveUsageSnapshot, } from "../../../config/index.js";
-import { logger } from "../../../logger.js";
-import { configureOpenAIProvider, createOpenAIClient, getModelId } from "../client-factory.js";
-import { logSystemPrompt } from "../system-prompt-log.js";
-import { OpenAIFileSession } from "./file-session.js";
-import { createOpenAIMcpServers, createOpenAITools } from "./tools.js";
-const MAX_TURNS = 100;
-// GPT-5.x family currently advertises a 1M-token context window.
-// Used to compute usage `usedPct` for the OpenAI engine; keeping this
-// in one place so usage rendering and compaction gates agree.
-const OPENAI_CONTEXT_WINDOW = 1_000_000;
-// Used-token threshold (fraction of context window) at which
-// {@link OpenAIAgentSession.maybeCompact} triggers a compaction. Calibrated
-// for the 1M-token window: 70% leaves comfortable headroom for the next
-// turn's input + tool results without compacting too eagerly. Configurable
-// per call via the `usedPctThreshold` option to `maybeCompact()`.
-const OPENAI_COMPACT_USED_PCT_THRESHOLD = 0.7;
-export class OpenAIAgentSession {
-    config;
-    buildSystemPrompt;
-    runtimeSurface;
-    getDualSessionEnabled;
-    getAndroidUseEnabled;
-    dynamicMcpServers;
-    client;
-    runner;
-    // The session id is invariant across compactions, so the underlying
-    // file-backed session and its compaction wrapper are constructed once
-    // in the constructor and never replaced.
-    underlyingSession;
-    session;
-    abortController = null;
-    inputClosed = true;
-    stopRequested = false;
-    lastUsageSnapshot = null;
-    currentRun = null;
-    sessionId;
-    // Compaction state — mirrors Claude's session. `compactInFlight` blocks
-    // re-entrancy; `lastCompactRequestAtMs` enforces a cooldown so we don't
-    // hammer compaction on every heartbeat once usage crosses the threshold.
-    compactInFlight = false;
-    lastCompactRequestAtMs = 0;
-    // OpenAI engine mid-run injection state.
-    //
-    // The OpenAI Agents SDK does not expose a mid-run input channel like the
-    // Claude SDK does, so we approximate it: when a message is injected while
-    // a run is active we *abort* the run at the next safe SDK boundary (a
-    // `tool_output` event — the tool call+result pair has already been
-    // persisted to the session by then) and immediately start a follow-up run
-    // that feeds the queued items as the next turn's input. The same
-    // `session` is reused so the model continues from the existing transcript
-    // without paying any cold-start tax.
-    //
-    // - `pendingInjections`: items to feed into the next run.
-    // - `interruptArmed`: set by `injectMessage` while a run is live; the
-    //   stream loop checks this after each event and triggers the abort.
-    // - `resumeRequested`: tells the resume loop to loop one more time after
-    //   the current run terminates (either via our abort or naturally).
-    pendingInjections = [];
-    interruptArmed = false;
-    resumeRequested = false;
-    finishDetected = false;
-    mode;
-    constructor({ config, buildSystemPrompt, runtimeSurface, sessionContext, }) {
-        configureOpenAIProvider(config);
-        setTracingDisabled(true);
-        this.config = config;
-        this.buildSystemPrompt = buildSystemPrompt;
-        this.runtimeSurface = runtimeSurface;
-        this.getDualSessionEnabled = sessionContext.getDualSessionEnabled;
-        this.getAndroidUseEnabled = sessionContext.getAndroidUseEnabled;
-        this.dynamicMcpServers = {};
-        this.mode = sessionContext.mode;
-        this.client = createOpenAIClient(config);
-        this.runner = new Runner({ model: getModelId(config) });
-        const persistedSessionId = loadSessionId(this.config, this.mode);
-        this.underlyingSession = new OpenAIFileSession({
-            sessionId: persistedSessionId,
-        });
-        this.sessionId = this.underlyingSession.getSessionIdSync();
-        saveSessionId(this.config, this.sessionId, this.mode);
-        this.session = this.buildCompactionSession(this.underlyingSession);
-        const persistedUsage = loadUsageSnapshot(this.config, this.mode);
-        if (persistedUsage) {
-            this.lastUsageSnapshot = {
-                ...persistedUsage,
-                capturedAtMs: Date.now(),
-            };
-        }
-    }
-    async warmUp() {
-        // OpenAI sessions do not have an equivalent subprocess cold-start path.
-    }
-    discardWarmQuery() {
-        // OpenAI sessions hold no pre-warmed subprocess; nothing to discard.
-    }
-    sendAndStream(content, _options) {
-        // Log the resolved system prompt for training data capture. The console
-        // gets a compact head/tail preview; the full prompt goes into `data.prompt`
-        // of the JSONL entry so the log file remains complete.
-        const systemPrompt = this.buildSystemPrompt();
-        logSystemPrompt(systemPrompt);
-        const input = contentBlocksToInputItems(content);
-        this.inputClosed = false;
-        this.stopRequested = false;
-        this.pendingInjections = [];
-        this.interruptArmed = false;
-        this.resumeRequested = false;
-        this.finishDetected = false;
-        return this.streamMessages(input, this.sessionId);
-    }
-    /**
-     * Queue `content` as the next turn's input.
-     *
-     * If a run is active, this also *arms a soft interrupt*: the streaming
-     * loop in `streamMessages` watches for a safe SDK boundary (a
-     * `tool_output` event — at which point the tool call + tool result are
-     * already persisted to the session) and aborts the in-flight run as soon
-     * as one arrives. The resume loop then immediately starts a follow-up
-     * `runner.run()` with the queued items as input, against the same
-     * session, so the model perceives the new user message just like it
-     * would in the Claude path.
-     *
-     * If no run is active, the items sit in the queue until the next
-     * `sendAndStream` consumes them (or, if the session is already torn
-     * down, are reported as orphans by `hasOrphanedInjections`).
-     *
-     * Returns `true` whenever the message has been accepted (queued). Returns
-     * `false` only when the session is fully closed and no run is or will be
-     * active — in that case the caller should re-queue the message for the
-     * next wake cycle.
-     */
-    injectMessage(content, _options) {
-        if (this.inputClosed && !this.abortController && !this.resumeRequested) {
-            return false;
-        }
-        const items = contentBlocksToInputItems(content);
-        this.pendingInjections.push(...items);
-        if (this.abortController) {
-            // A run is live — let the stream loop tear it down at the next safe
-            // boundary so the queued items are picked up immediately rather than
-            // waiting for the model to finish its current chain of tool calls.
-            this.interruptArmed = true;
-            this.resumeRequested = true;
-        }
-        return true;
-    }
-    /**
-     * Mark the session as no longer accepting fresh `sendAndStream` invocations
-     * and stop the resume loop from looping into another `runner.run()`.
-     *
-     * **We deliberately do NOT clear `pendingInjections` here.**
-     *
-     * `closeInput()` is called by the stream handler from many places, including
-     * mid-stream when it observes the `finish` tool block. At that point the
-     * resume loop hasn't yet had a chance to consume any messages that
-     * `injectMessage()` queued during the run. Dropping the buffer here would
-     * silently lose those user messages — exactly the bug we hit when an
-     * interrupt landed during a memory-view turn that ended in `finish`.
-     *
-     * Instead, leftover messages stay in `pendingInjections` until either:
-     *   - the resume loop picks them up (when it's still allowed to run), or
-     *   - the wake-cycle runner sees `hasOrphanedInjections` and re-queues the
-     *     original `CommandMessage` batch for the next wake cycle.
-     *
-     * Hard teardowns that really do want the buffer wiped (e.g. `/stop`,
-     * watchdog timeout, owner-initiated shutdown) call `requestStop()` which
-     * clears it explicitly.
-     */
-    /**
-     * Mark the session as no longer accepting fresh `sendAndStream` invocations
-     * and stop the resume loop from looping into another `runner.run()`.
-     *
-     * **We deliberately do NOT clear `pendingInjections` here.**
-     *
-     * `closeInput()` is called by the stream handler from many places, including
-     * mid-stream when it observes the `finish` tool block. At that point the
-     * resume loop hasn't yet had a chance to consume any messages that
-     * `injectMessage()` queued during the run. Dropping the buffer here would
-     * silently lose those user messages — exactly the bug we hit when an
-     * interrupt landed during a memory-view turn that ended in `finish`.
-     *
-     * Instead, leftover messages stay in `pendingInjections` until either:
-     *   - the resume loop picks them up (when it's still allowed to run), or
-     *   - the wake-cycle runner sees `hasOrphanedInjections` and re-queues the
-     *     original `CommandMessage` batch for the next wake cycle.
-     *
-     * Hard teardowns that really do want the buffer wiped (e.g. `/stop`,
-     * watchdog timeout, owner-initiated shutdown) call `requestStop()` which
-     * clears it explicitly.
-     */
-    closeInput() {
-        this.inputClosed = true;
-    }
-    /**
-     * Signal that the agent has called the `finish` tool. The stream loop
-     * will abort the run at the next safe `tool_output` boundary (where
-     * `stream.rawResponses` is already populated) instead of waiting for
-     * `stream.completed` — which can idle for 30s+ in the OpenAI SDK.
-     */
-    signalFinish() {
-        this.finishDetected = true;
-    }
-    requestStop() {
-        this.stopRequested = true;
-        this.inputClosed = true;
-        this.pendingInjections = [];
-        this.interruptArmed = false;
-        this.resumeRequested = false;
-        this.abortController?.abort();
-    }
-    clearStop() {
-        this.stopRequested = false;
-        this.abortController = null;
-    }
-    isStopRequested() {
-        return this.stopRequested;
-    }
-    /**
-     * Update the persisted session ID.
-     *
-     * Only saves on first capture (null/empty → id). Once set, a different ID
-     * from the SDK is ignored — it means the resume failed and the SDK created
-     * a throwaway conversation.
-     */
-    captureSessionId(id) {
-        if (!id || this.sessionId)
-            return;
-        this.sessionId = id;
-        saveSessionId(this.config, id, this.mode);
-    }
-    captureUsageSnapshot(snapshot) {
-        const normalizedSnapshot = normalizeOpenAIUsageSnapshot(snapshot);
-        this.lastUsageSnapshot = {
-            ...normalizedSnapshot,
-            capturedAtMs: Date.now(),
-        };
-        saveUsageSnapshot(this.config, normalizedSnapshot, this.mode);
-    }
-    capturePostCompactionSnapshot(_postCompactionTokens) {
-        // OpenAI compaction is handled by the SDK session decorator.
-    }
-    /**
-     * Force the OpenAI Responses API compaction path, archiving the
-     * pre-compaction transcript to disk for audit/debugging.
-     *
-     * **The session id is invariant across compactions**, matching the
-     * Claude engine's behavior (see `captureSessionId` in the Claude
-     * session — it ignores the SDK's post-`/compact` `session_id` echo
-     * because the id "should remain the same"). Keeping it stable means:
-     *
-     *   - `session.json` never needs rewriting on compaction.
-     *   - The active transcript file path (`<sessionId>.json`) is also
-     *     stable, so no in-memory references (`this.underlyingSession`,
-     *     `this.session`) need to be rebuilt.
-     *   - Only the **contents** of the transcript change; the SDK's
-     *     `runCompaction` rewrites them in place via clearSession + addItems.
-     *
-     * Sequence:
-     *
-     *   1. Snapshot the active session file to
-     *      `<sessionId>.compacted-<iso>.json` — freezes pre-compaction state.
-     *   2. `runCompaction({ force: true })` — the SDK clears the underlying
-     *      session and writes the compacted item set into the same file.
-     *
-     * If step 1 fails (e.g. the file doesn't exist yet because no items have
-     * been persisted) we still attempt step 2 — losing the archive is
-     * preferable to skipping the actual compaction.
-     */
-    async requestCompaction() {
-        const activePath = this.underlyingSession.getFilePath();
-        const archivePath = this.archivePathForCurrent();
-        try {
-            // Step 1: archive pre-compaction state. Non-fatal on failure.
-            try {
-                fs.copyFileSync(activePath, archivePath);
-            }
-            catch (err) {
-                logger.warn(`OpenAI session pre-compaction archive failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
-            }
-            // Step 2: run compaction in place. The SDK clears the underlying
-            // session and rewrites it with the compacted items, all under the
-            // same file (`<sessionId>.json`). Session id, file path, and all
-            // wrapper references stay valid.
-            await this.session.runCompaction({ force: true });
-            logger.system(`OpenAI session compacted (${this.mode}); archive: ${archivePath}`);
-        }
-        catch (err) {
-            logger.warn(`Request /compact failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    archivePathForCurrent() {
-        const dir = getOpenAISessionsDir();
-        const safeIso = new Date().toISOString().replace(/:/g, "-");
-        return path.join(dir, `${this.sessionId}.compacted-${safeIso}.json`);
-    }
-    buildCompactionSession(underlying) {
-        return new OpenAIResponsesCompactionSession({
-            client: this.client,
-            underlyingSession: underlying,
-            model: getModelId(this.config),
-            // Disable SDK auto-compaction entirely.
-            //
-            // The SDK's auto-compaction (default threshold: 10 candidate items)
-            // calls the OpenAI Responses `responses.compact` API, which returns
-            // a single opaque `compaction` item containing only:
-            //   { id, type: "compaction", encrypted_content: "<opaque blob>" }
-            //
-            // It then *clears the underlying session and writes back only this
-            // blob* (see OpenAIResponsesCompactionSession.runCompaction at line
-            // 90 of openaiResponsesCompactionSession.mjs). That destroys our
-            // human-readable transcript, breaks the transcript indexer, and
-            // makes session history unrecoverable if we ever switch providers.
-            //
-            // It also doesn't create an archive snapshot — unlike
-            // `requestCompaction()` below which copies the active session file
-            // to `<sessionId>.compacted-<iso>.json` before invoking the same
-            // `runCompaction` API.
-            //
-            // Compaction is therefore driven exclusively by `maybeCompact()`
-            // (called from the wake-cycle runner on heartbeat), which:
-            //   1. Checks token usage against a percentage threshold.
-            //   2. Archives the pre-compaction file.
-            //   3. Calls `runCompaction({ force: true })` so the SDK still
-            //      replaces the session contents — but only when *we* decide.
-            shouldTriggerCompaction: () => false,
-        });
-    }
-    /**
-     * Token-usage-driven compaction trigger, called from the wake-cycle
-     * runner on heartbeat.
-     *
-     * Mirrors Claude's behavior: re-entrancy guard + cooldown + threshold
-     * check, then delegates to {@link requestCompaction} which archives
-     * and runs the actual SDK compaction. We deliberately do NOT use the
-     * SDK's auto-compaction path (`shouldTriggerCompaction`) because it
-     * compacts purely by item count and skips the archive — see the
-     * comment on {@link buildCompactionSession}.
-     *
-     * The default threshold (70%) is calibrated for the GPT-5.x 1M-token
-     * context window. Lower if you want more aggressive trimming, raise
-     * if cross-turn context fidelity matters more than latency.
-     */
-    async maybeCompact(options) {
-        const usedPctThreshold = options?.usedPctThreshold ?? OPENAI_COMPACT_USED_PCT_THRESHOLD;
-        const cooldownMs = options?.cooldownMs ?? 10 * 60 * 1000;
-        // --- guard: in-flight ---
-        if (this.compactInFlight) {
-            logger.debug("[compact] skip: compaction already in flight");
-            return;
-        }
-        // --- guard: cooldown ---
-        const nowMs = Date.now();
-        const sinceLastCompactMs = nowMs - this.lastCompactRequestAtMs;
-        if (sinceLastCompactMs <= cooldownMs) {
-            logger.debug(`[compact] skip: cooldown active sinceLast=${sinceLastCompactMs}ms cooldown=${cooldownMs}ms`);
-            return;
-        }
-        // --- trigger: token usage ---
-        const snap = this.lastUsageSnapshot;
-        if (!snap || snap.contextWindow <= 0) {
-            logger.debug("[compact] skip: no usage snapshot yet");
-            return;
-        }
-        if (snap.usedPct < usedPctThreshold) {
-            logger.debug(`[compact] skip: under threshold (usedPct=${(snap.usedPct * 100).toFixed(1)}% threshold=${(usedPctThreshold * 100).toFixed(1)}%)`);
-            return;
-        }
-        logger.system(`[compact] requesting compaction (usedPct=${(snap.usedPct * 100).toFixed(1)}% threshold=${(usedPctThreshold * 100).toFixed(1)}%)`);
-        this.compactInFlight = true;
-        this.lastCompactRequestAtMs = nowMs;
-        try {
-            await this.requestCompaction();
-        }
-        finally {
-            this.compactInFlight = false;
-        }
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-    getTranscriptPath() {
-        return this.underlyingSession.getFilePath();
-    }
-    getTranscriptItems() {
-        return this.underlyingSession.getAllItemsSync();
-    }
-    getUsageSnapshot() {
-        return this.lastUsageSnapshot ? { ...this.lastUsageSnapshot } : null;
-    }
-    getCurrentQuery() {
-        return this.currentRun;
-    }
-    setDynamicMcpServers(servers) {
-        this.dynamicMcpServers = { ...servers };
-    }
-    getDynamicMcpServers() {
-        return { ...this.dynamicMcpServers };
-    }
-    get isInputClosed() {
-        // While a run is active (abortController set) or about to resume after a
-        // soft-interrupt, the session is still accepting injected messages.
-        if (this.abortController || this.resumeRequested) {
-            return false;
-        }
-        return this.inputClosed;
-    }
-    /**
-     * True when injected messages have been queued but the session is no
-     * longer running. The agent loop checks this after `streamMessages`
-     * finishes to re-queue messages instead of dropping them. We deliberately
-     * ignore `resumeRequested` here: if `pendingInjections` is non-empty and
-     * there is no active abortController, the messages are by definition
-     * orphaned regardless of any stale resume flag.
-     */
-    get hasOrphanedInjections() {
-        return (this.pendingInjections.length > 0
-            && !this.abortController);
-    }
-    async *streamMessages(initialInput, sessionId) {
-        const mcpServers = createOpenAIMcpServers({
-            ...this.runtimeSurface.externalMcpServers,
-            ...this.dynamicMcpServers,
-        });
-        let lastStream = null;
-        let nextInput = initialInput;
-        try {
-            await connectMcpServers(mcpServers);
-            const tools = createOpenAITools({
-                dualSession: this.getDualSessionEnabled(),
-                androidUse: this.getAndroidUseEnabled(),
-                mode: this.mode,
-                runtimeSurface: this.runtimeSurface,
-            });
-            logOpenAIToolInventory({
-                mode: this.mode,
-                tools,
-                mcpServers,
-                runtimeSurface: this.runtimeSurface,
-            });
-            const agent = new Agent({
-                name: this.mode === "coding" ? `${this.config.agentName} Coding` : this.config.agentName,
-                instructions: renderSystemPrompt(this.buildSystemPrompt()),
-                model: getModelId(this.config),
-                tools,
-                mcpServers,
-                // Reasoning model settings.
-                //
-                // `summary: "auto"` asks the Responses API to return a human-readable
-                // summary of the model's reasoning. Without this the API returns
-                // reasoning items with empty `summary` arrays — the model still pays
-                // the reasoning tokens, we just can't see what it thought about. The
-                // summary is for our debug visibility (logs, /obs).
-                //
-                // `providerData.include = ["reasoning.encrypted_content"]` asks the
-                // API to return the opaque encrypted reasoning blob alongside each
-                // reasoning item. The SDK persists that blob into the session and
-                // replays it on subsequent turns, so the model can pick up the same
-                // reasoning chain instead of re-deriving it from scratch each turn.
-                // This matters a lot for VisionClaw because every wake cycle starts
-                // a fresh `Runner.run()` — without the encrypted blob, the model
-                // re-thinks everything from the visible artifacts (tool calls /
-                // results / messages) instead of inheriting prior chain-of-thought.
-                //
-                // NOTE: In `openaiResponsesModel.mjs` (~line 2184) `providerData` is
-                // spread into the request body AFTER the auto-built `include` array
-                // (~line 2163), which means setting `providerData.include` overwrites
-                // it. That's safe for our tool mix — the SDK's auto-includes only
-                // fire for hosted search tools with `include_search_results`, which
-                // we do not use. If we later add such tools, we'll need to merge.
-                modelSettings: {
-                    reasoning: { summary: "auto" },
-                    providerData: {
-                        include: ["reasoning.encrypted_content"],
-                    },
-                },
-            });
-            // Outer resume loop: each iteration runs one `runner.run()` to either
-            // a natural end-of-turn or a *soft-interrupt abort* — i.e. a
-            // self-initiated abort fired at the next safe SDK boundary
-            // (`tool_output`) when `injectMessage()` queued items mid-run. After
-            // the run terminates, if there are queued injections, we loop and
-            // start a new run with those items as input, reusing the same
-            // `agent`, `session`, and `mcpServers` so the model continues from
-            // the persisted transcript without paying any cold-start tax.
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- intentional: loop terminates via `break` after stream completion or non-resume exit
-            while (true) {
-                this.abortController = new AbortController();
-                // Don't reset `resumeRequested` here — `injectMessage()` may have
-                // already set it (along with `interruptArmed`) before we entered
-                // this iteration, and we need to preserve that signal.
-                let interruptedThisRun = false;
-                let finishAbortedThisRun = false;
-                const stream = await this.runner.run(agent, nextInput, {
-                    stream: true,
-                    session: this.session,
-                    maxTurns: MAX_TURNS,
-                    signal: this.abortController.signal,
-                });
-                lastStream = stream;
-                this.currentRun = null;
-                try {
-                    for await (const event of stream) {
-                        const normalized = normalizeRunEvent(event, sessionId);
-                        if (normalized) {
-                            yield normalized;
-                        }
-                        const usage = captureUsageFromEvent(event);
-                        if (usage) {
-                            this.captureUsageSnapshot(usage);
-                        }
-                        // Soft-interrupt: a message was injected while this run was
-                        // streaming. We tear the run down at the next safe boundary
-                        // (after `tool_output`, when the SDK has already persisted the
-                        // call+result pair to the session) so the queued items can be
-                        // delivered as the next turn's input rather than waiting for
-                        // the model to finish its current chain of tool calls.
-                        if (this.interruptArmed
-                            && this.pendingInjections.length > 0
-                            && !this.stopRequested
-                            && isSafeInterruptBoundary(event)) {
-                            interruptedThisRun = true;
-                            this.interruptArmed = false;
-                            // Persist work-in-progress items before aborting. Without
-                            // this, every tool call the agent already executed during
-                            // this run (memory views, screenshots, notify_user, etc.)
-                            // is dropped from the session file and the continuation
-                            // run sees only user wake events. See the longer comment
-                            // on the finish-abort branch below for the SDK trace.
-                            try {
-                                await persistRunItemsForAbort(stream, this.session);
-                            }
-                            catch (err) {
-                                logger.warn(`OpenAI session soft-interrupt: manual persistence failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
-                            }
-                            logger.system(`OpenAI session soft-interrupt: aborting run at ${event.type}/${"name" in event ? event.name : ""}; ${this.pendingInjections.length} queued message(s) will resume.`);
-                            this.abortController.abort();
-                            break;
-                        }
-                        // Finish-abort: the agent called the `finish` tool and the
-                        // tool result has been persisted (safe boundary). Abort early
-                        // instead of waiting for the SDK's stream.completed (~30s).
-                        //
-                        // IMPORTANT: We must manually persist the run items here.
-                        // The SDK only persists assistant/tool items at
-                        // `next_step_final_output` / `next_step_interruption`
-                        // (`run.mjs` lines 714/723). Aborting at `tool_output` is
-                        // earlier in the loop, so the SDK's stream-loop catches our
-                        // AbortError, calls `tryHandleRunError` which only handles
-                        // `MaxTurnsExceededError`, then rethrows — bypassing
-                        // `saveStreamResultToSession`. The result is that wake-cycle
-                        // user input is persisted (via the early `persistStreamInputIfNeeded`
-                        // path) but every assistant message, tool call, and tool
-                        // result generated this turn is lost from the session file.
-                        // Subsequent wake cycles then see a session full of user
-                        // wake events with no assistant context, which manifests as
-                        // the model repeating itself or losing state across turns.
-                        //
-                        // To preserve the speed benefit of finish-abort while not
-                        // shedding history, we replicate the SDK's persistence
-                        // payload manually before aborting: extract the raw items
-                        // from `stream.newItems` and append them via the same
-                        // `session.addItems` call the SDK would have made. The items
-                        // already include the finish tool's call+result (we're at
-                        // the `tool_output` boundary), all preceding tool calls,
-                        // any assistant messages, and reasoning items.
-                        if (this.finishDetected
-                            && !this.stopRequested
-                            && isSafeInterruptBoundary(event)) {
-                            finishAbortedThisRun = true;
-                            this.finishDetected = false;
-                            try {
-                                await persistRunItemsForAbort(stream, this.session);
-                            }
-                            catch (err) {
-                                logger.warn(`OpenAI session finish-abort: manual persistence failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
-                            }
-                            logger.system(`OpenAI session finish-abort: skipping stream.completed at ${event.type}/${"name" in event ? event.name : ""}`);
-                            this.abortController.abort();
-                            break;
-                        }
-                    }
-                    if (!interruptedThisRun && !finishAbortedThisRun) {
-                        await stream.completed;
-                    }
-                }
-                catch (err) {
-                    if (interruptedThisRun && isAbortError(err)) {
-                        // Expected: our own soft-interrupt aborted the run. Fall
-                        // through to the resume check below.
-                    }
-                    else if (finishAbortedThisRun && isAbortError(err)) {
-                        // Expected: our own finish-abort cut the run short. Fall
-                        // through to yield the result message immediately.
-                    }
-                    else if (this.stopRequested && isAbortError(err)) {
-                        // Expected: caller invoked requestStop() — treat as a clean
-                        // termination, not as a session error.
-                        logger.system("OpenAI session: run aborted by requestStop.");
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-                const usage = extractUsageFromStream(stream);
-                if (usage) {
-                    this.captureUsageSnapshot(usage);
-                }
-                // resumeRequested is mutated by injectMessage() while the stream is awaited above.
-                if (this.resumeRequested && this.pendingInjections.length > 0 && !this.stopRequested) {
-                    // Hand the queued injections to the next run and loop. The previous
-                    // run reached a safe SDK boundary (either via soft-interrupt abort
-                    // or natural completion), so its session persistence is complete
-                    // before this follow-up turn starts.
-                    nextInput = this.pendingInjections;
-                    this.pendingInjections = [];
-                    this.resumeRequested = false;
-                    this.interruptArmed = false;
-                    this.finishDetected = false;
-                    this.abortController = null;
-                    continue;
-                }
-                // Natural end of stream (no resume): emit final result and exit.
-                yield buildResultMessage(stream, this.config);
-                break;
-            }
-        }
-        catch (err) {
-            // Flush any remaining final-result message so the loop sees a clean
-            // termination event instead of a raw throw.
-            if (lastStream) {
-                try {
-                    yield buildResultMessage(lastStream, this.config);
-                }
-                catch {
-                    // best-effort
-                }
-            }
-            throw err;
-        }
-        finally {
-            this.inputClosed = true;
-            this.abortController = null;
-            this.currentRun = null;
-            this.interruptArmed = false;
-            this.resumeRequested = false;
-            this.finishDetected = false;
-            await closeMcpServers(mcpServers);
-        }
-    }
-}
-function logOpenAIToolInventory(options) {
-    const hosted = options.runtimeSurface.nativeTools.kind === "openai-hosted"
-        ? options.runtimeSurface.nativeTools.hostedTools.map(() => "WebSearch")
-        : [];
-    const extensions = options.mode === "coding" ? ["codex"] : [];
-    const sdkLocal = [];
-    const directTools = [];
-    for (const t of options.tools) {
-        const display = getToolDisplayName(t);
-        if (!display)
-            continue;
-        if (getToolType(t) === "shell" || getToolType(t) === "apply_patch") {
-            sdkLocal.push(display);
-        }
-        else {
-            directTools.push(display);
-        }
-    }
-    const mcpServerNames = options.mcpServers.map((server) => server.name);
-    logger.system(`OpenAI tool inventory (${options.mode}): hosted=[${hosted.join(", ") || "none"}] extensions=[${extensions.join(", ") || "none"}] sdkLocal=[${sdkLocal.join(", ") || "none"}] direct=[${directTools.join(", ") || "none"}] mcpServers=[${mcpServerNames.join(", ") || "none"}]`);
-}
-function getToolDisplayName(toolLike) {
-    if (!toolLike || typeof toolLike !== "object")
-        return null;
-    const record = toolLike;
-    const name = record.name ?? record.toolName;
-    return typeof name === "string" && name.length > 0 ? name : null;
-}
-function getToolType(toolLike) {
-    if (!toolLike || typeof toolLike !== "object")
-        return null;
-    const record = toolLike;
-    const type = record.type;
-    return typeof type === "string" && type.length > 0 ? type : null;
-}
-function isAbortError(err) {
-    if (!err || typeof err !== "object")
-        return false;
-    const candidate = err;
-    return candidate.name === "AbortError" || candidate.code === "ABORT_ERR";
-}
-/**
- * Whether a stream event marks a safe place to abort the current run.
- *
- * "Safe" means the runtime state is balanced: any in-flight tool call has
- * its matching tool result already produced, so aborting here leaves a
- * clean tool_call + tool_call_result pair in the in-memory run state. The
- * Responses API would otherwise reject a resume payload that referenced an
- * orphan tool call without its result.
- *
- * IMPORTANT: "safe" here refers only to runtime state, NOT to session file
- * persistence. The SDK only writes assistant/tool items to the session at
- * `next_step_final_output` / `next_step_interruption` (see
- * `runner/sessionPersistence.mjs::persistRunItemsToSession` invoked from
- * `run.mjs` lines 714/723). When we abort at `tool_output` we are *before*
- * those checkpoints, so the manual persistence helper
- * {@link persistRunItemsForAbort} must be called by the caller.
- *
- * - `run_item_stream_event` / `tool_output`: a tool just finished. This is
- *   the most common boundary we hit.
- * - `agent_updated_stream_event`: a handoff completed and the SDK swapped
- *   the active agent.
- *
- * We deliberately do NOT treat raw model deltas (`raw_model_stream_event`)
- * as safe — those fire mid-token while a tool call is being constructed,
- * before any tool result has been produced.
- */
-function isSafeInterruptBoundary(event) {
-    if (event.type === "agent_updated_stream_event") {
-        return true;
-    }
-    if (event.type !== "run_item_stream_event") {
-        return false;
-    }
-    return event.name === "tool_output";
-}
-/**
- * Manually persist the assistant/tool items the SDK has accumulated
- * during the current run before we abort it.
- *
- * This is what `runner/sessionPersistence.mjs::persistRunItemsToSession`
- * does internally — but only at `next_step_final_output` /
- * `next_step_interruption` (`run.mjs` lines 714/723). Both of our abort
- * triggers fire much earlier in the SDK loop:
- *   - **finish-abort**: at the `run_item_stream_event/tool_output` for
- *     the `finish` tool's result.
- *   - **soft-interrupt**: at the same `tool_output` boundary, when a new
- *     user message has been queued and we want to inject it now instead
- *     of waiting out the current chain.
- *
- * In both cases the SDK's stream loop catches our `AbortError`, runs
- * `tryHandleRunError` (which only handles `MaxTurnsExceededError` —
- * verified in `runner/errorHandlers.mjs` line 25), and rethrows. The
- * `await saveStreamResultToSession(...)` call is bypassed entirely, so
- * every tool call, tool result, reasoning summary, and assistant
- * message produced this turn is lost from the session file. The next
- * wake cycle then sees a session full of user wake events with no
- * record of the agent's prior work, which manifests as the model
- * "forgetting" what it just did or repeating itself.
- *
- * We replicate the relevant subset of the SDK's persistence logic:
- *
- *   1. Pull `stream.newItems` (the public read-only run-items collection).
- *   2. Filter out `tool_approval_item` (matches the SDK's filter at
- *      `runner/items.mjs::extractOutputItemsFromRunItems`).
- *   3. Map each `RunItem` to its `rawItem` (the persistable
- *      `AgentInputItem` shape — function_call, function_call_result,
- *      reasoning, message, etc.).
- *   4. Call `session.addItems()` to append. The wrapping
- *      `OpenAIResponsesCompactionSession` forwards to the underlying
- *      file-backed session, which writes to disk.
- *
- * We deliberately do not normalize ids or strip transient call ids the
- * way the SDK's `normalizeItemsForSessionPersistence` does — for our
- * file-only session those normalizations are mostly server-side concerns
- * and the rawItem already passes through cleanly. If we ever observe
- * resume-time conflicts on encrypted_content or call_id collisions, we
- * can mirror more of `sessionPersistence.mjs::stripTransientCallIds`
- * here.
- */
-async function persistRunItemsForAbort(stream, session) {
-    const newItems = stream.newItems;
-    if (!Array.isArray(newItems) || newItems.length === 0) {
-        return;
-    }
-    const rawItems = [];
-    for (const entry of newItems) {
-        if (entry === null || typeof entry !== "object")
-            continue;
-        const item = entry;
-        if (item.type === "tool_approval_item")
-            continue;
-        const raw = item.rawItem;
-        if (raw && typeof raw === "object") {
-            rawItems.push(raw);
-        }
-    }
-    if (rawItems.length === 0) {
-        return;
-    }
-    await session.addItems(rawItems);
-    logger.debug(`OpenAI session: manually persisted ${rawItems.length} run item(s) before abort`);
-}
-function renderSystemPrompt(prompt) {
-    if (typeof prompt === "string") {
-        return prompt;
-    }
-    const presetIntro = "You are in a coding-focused session. Prefer careful, multi-step engineering work.";
-    return [presetIntro, prompt.append ?? ""].filter(Boolean).join("\n\n");
-}
-function contentBlocksToInputItems(content) {
-    const blocks = normalizeInputContent(content);
-    return [
-        {
-            role: "user",
-            content: blocks.map((block) => {
-                if (block.type === "text") {
-                    return {
-                        type: "input_text",
-                        text: block.text,
-                    };
-                }
-                if (block.source.type === "url") {
-                    return {
-                        type: "input_image",
-                        image: block.source.url,
-                        detail: "original",
-                    };
-                }
-                return {
-                    type: "input_image",
-                    image: `data:${block.source.media_type};base64,${block.source.data}`,
-                    detail: "original",
-                };
-            }),
-        },
-    ];
-}
-function normalizeInputContent(content) {
-    if (typeof content === "string") {
-        return [{ type: "text", text: content }];
-    }
-    const blocks = [];
-    for (const block of content) {
-        if (block.type === "text") {
-            blocks.push({ type: "text", text: block.text });
-            continue;
-        }
-        if (block.type === "image") {
-            if (block.source.type === "url") {
-                blocks.push({ type: "image", source: { type: "url", url: block.source.url } });
-                continue;
-            }
-            blocks.push({
-                type: "image",
-                source: {
-                    type: "base64",
-                    media_type: block.source.media_type,
-                    data: block.source.data,
-                },
-            });
-        }
-    }
-    return blocks;
-}
-export function normalizeOpenAIRunEventForTest(event, sessionId) {
-    return normalizeRunEvent(event, sessionId);
-}
-function normalizeRunEvent(event, sessionId) {
-    if (event.type === "raw_model_stream_event") {
-        const data = event.data;
-        if (data.type === "output_text_delta" && data.delta) {
-            return {
-                type: "assistant",
-                session_id: sessionId,
-                message: {
-                    role: "assistant",
-                    content: [{ type: "text", text: data.delta }],
-                },
-            };
-        }
-        return null;
-    }
-    if (event.type !== "run_item_stream_event") {
-        return null;
-    }
-    const raw = event.item.rawItem;
-    if (!raw?.type) {
-        return null;
-    }
-    if (event.name === "message_output_created" && raw.type === "message") {
-        return null;
-    }
-    if (event.name === "reasoning_item_created" && raw.type === "reasoning") {
-        // The OpenAI Agents SDK's `RunReasoningItem` normalizes the API's
-        // `summary_text` parts as `{ type: "input_text", text, providerData: { type: "summary_text" } }`.
-        // Earlier we filtered by `entry.type === "reasoning_text"` which never
-        // matched any item the SDK actually produces, so reasoning summaries
-        // were silently dropped before reaching the stream handler. Match
-        // both shapes so we work whether the SDK changes its internal tag in
-        // a future release or keeps the current `input_text` mapping.
-        const text = raw.content
-            ?.filter((entry) => (entry.type === "input_text"
-            || entry.type === "reasoning_text"
-            || entry.type === "summary_text")
-            && typeof entry.text === "string")
-            .map((entry) => entry.text)
-            .join(" ");
-        if (!text) {
-            return null;
-        }
-        return {
-            type: "assistant",
-            session_id: sessionId,
-            message: {
-                role: "assistant",
-                content: [{ type: "thinking", thinking: text }],
-            },
-        };
-    }
-    if (event.name === "tool_called") {
-        if (raw.type === "function_call") {
-            return {
-                type: "assistant",
-                session_id: sessionId,
-                message: {
-                    role: "assistant",
-                    content: [{
-                            type: "tool_use",
-                            id: raw.callId,
-                            tool_use_id: raw.callId,
-                            name: raw.name ?? "tool",
-                            input: parseToolArguments(raw.arguments),
-                        }],
-                },
-            };
-        }
-        if (raw.type === "computer_call") {
-            return {
-                type: "assistant",
-                session_id: sessionId,
-                message: {
-                    role: "assistant",
-                    content: [{
-                            type: "tool_use",
-                            id: raw.callId,
-                            tool_use_id: raw.callId,
-                            name: "computer",
-                            input: raw.action ?? {},
-                        }],
-                },
-            };
-        }
-    }
-    if (event.name === "tool_output") {
-        if (raw.type === "function_call_result" || raw.type === "computer_call_result") {
-            return {
-                type: "user",
-                session_id: sessionId,
-                parent_tool_use_id: null,
-                message: {
-                    role: "user",
-                    content: [{
-                            type: "tool_result",
-                            tool_use_id: raw.callId ?? "",
-                            content: raw.output ?? "",
-                            is_error: false,
-                        }],
-                },
-            };
-        }
-    }
-    return null;
-}
-function parseToolArguments(value) {
-    if (!value) {
-        return {};
-    }
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return value;
-    }
-}
-function captureUsageFromEvent(event) {
-    if (event.type !== "raw_model_stream_event") {
-        return null;
-    }
-    const data = event.data;
-    if (data.type !== "response_done") {
-        return null;
-    }
-    const inputTokens = data.response?.usage?.inputTokens;
-    if (typeof inputTokens !== "number") {
-        return null;
-    }
-    return buildOpenAIUsageSnapshot(inputTokens);
-}
-function extractUsageFromStream(stream) {
-    const usage = stream.rawResponses?.at(-1)?.usage;
-    if (typeof usage?.inputTokens !== "number") {
-        return null;
-    }
-    return buildOpenAIUsageSnapshot(usage.inputTokens);
-}
-function buildOpenAIUsageSnapshot(inputTokens) {
-    return {
-        usedInputTokens: inputTokens,
-        contextWindow: OPENAI_CONTEXT_WINDOW,
-        usedPct: inputTokens / OPENAI_CONTEXT_WINDOW,
-    };
-}
-function normalizeOpenAIUsageSnapshot(snapshot) {
-    if (snapshot.contextWindow > 0) {
-        return snapshot;
-    }
-    return buildOpenAIUsageSnapshot(snapshot.usedInputTokens);
-}
-function buildResultMessage(stream, config) {
-    const usage = stream.rawResponses?.at(-1)?.usage;
-    const inputTokens = usage?.inputTokens ?? 0;
-    const outputTokens = usage?.outputTokens ?? 0;
-    const modelId = getModelId(config);
-    const errorText = stream.error instanceof Error
-        ? stream.error.message
-        : stream.error
-            ? JSON.stringify(stream.error)
-            : "";
-    const hasUsage = typeof usage?.inputTokens === "number";
-    const modelUsage = hasUsage
-        ? {
-            [modelId]: {
-                contextWindow: OPENAI_CONTEXT_WINDOW,
-                inputTokens,
-                outputTokens,
-                cacheReadInputTokens: 0,
-                cacheCreationInputTokens: 0,
-            },
-        }
-        : undefined;
-    return {
-        type: "result",
-        subtype: errorText ? "error" : "success",
-        num_turns: 1,
-        usage: {
-            input_tokens: inputTokens,
-            output_tokens: outputTokens,
-        },
-        total_cost_usd: 0,
-        is_error: Boolean(errorText),
-        errors: errorText ? [errorText] : [],
-        model: modelId,
-        ...(modelUsage ? { modelUsage } : {}),
-    };
-}
-async function connectMcpServers(servers) {
-    for (const server of servers) {
-        await server.connect();
-    }
-}
-async function closeMcpServers(servers) {
-    for (const server of servers) {
-        try {
-            await server.close();
-        }
-        catch (err) {
-            logger.warn(`Failed to close MCP server "${server.name}": ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-}
-//# sourceMappingURL=session.js.map