@zakstam/codex-local-component 0.2.1 → 0.4.0

package/dist/host/runtime.js

@@ -1,6 +1,76 @@
-import { buildInitializeRequest, buildInitializedNotification, buildThreadStartRequest, buildTurnInterruptRequest, buildTurnStartTextRequest, isUuidLikeThreadId, } from "../app-server/client.js";
+import { buildAccountLoginCancelRequest, buildAccountLoginStartRequest, buildAccountLogoutRequest, buildAccountRateLimitsReadRequest, buildAccountReadRequest, buildChatgptAuthTokensRefreshResponse, buildCommandExecutionApprovalResponse, buildDynamicToolCallResponse, buildFileChangeApprovalResponse, buildThreadArchiveRequest, buildThreadForkRequest, buildThreadListRequest, buildThreadLoadedListRequest, buildThreadReadRequest, buildThreadResumeRequest, buildThreadRollbackRequest, buildInitializeRequestWithCapabilities, buildInitializedNotification, buildThreadStartRequest, buildThreadUnarchiveRequest, buildToolRequestUserInputResponse, buildTurnInterruptRequest, buildTurnStartTextRequest, isUuidLikeThreadId, } from "../app-server/client.js";
 import { CodexLocalBridge } from "../local-adapter/bridge.js";
 const MAX_BATCH_SIZE = 32;
+const MANAGED_SERVER_REQUEST_METHODS = new Set([
+    "item/commandExecution/requestApproval",
+    "item/fileChange/requestApproval",
+    "item/tool/requestUserInput",
+    "item/tool/call",
+]);
+const TURN_SCOPED_EVENT_PREFIXES = ["turn/", "item/"];
+function toRequestKey(requestId) {
+    return `${typeof requestId}:${String(requestId)}`;
+}
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function parseManagedServerRequestFromEvent(event) {
+    if (!MANAGED_SERVER_REQUEST_METHODS.has(event.kind)) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(event.payloadJson);
+    }
+    catch {
+        return null;
+    }
+    const message = asObject(parsed);
+    if (!message || typeof message.method !== "string") {
+        return null;
+    }
+    if (!MANAGED_SERVER_REQUEST_METHODS.has(message.method)) {
+        return null;
+    }
+    if (typeof message.id !== "number" && typeof message.id !== "string") {
+        return null;
+    }
+    const params = asObject(message.params);
+    if (!params) {
+        return null;
+    }
+    if (typeof params.threadId !== "string" || typeof params.turnId !== "string") {
+        return null;
+    }
+    const method = message.method;
+    const itemId = typeof params.itemId === "string"
+        ? params.itemId
+        : method === "item/tool/call" && typeof params.callId === "string"
+            ? params.callId
+            : null;
+    if (!itemId) {
+        return null;
+    }
+    const reason = typeof params.reason === "string" ? params.reason : undefined;
+    const questionsRaw = params.questions;
+    const questions = method === "item/tool/requestUserInput" && Array.isArray(questionsRaw)
+        ? questionsRaw
+        : undefined;
+    return {
+        requestId: message.id,
+        method,
+        threadId: params.threadId,
+        turnId: params.turnId,
+        itemId,
+        payloadJson: event.payloadJson,
+        createdAt: event.createdAt,
+        ...(reason ? { reason } : {}),
+        ...(questions ? { questions } : {}),
+    };
+}
+function isTurnScopedEvent(kind) {
+    return kind === "error" || TURN_SCOPED_EVENT_PREFIXES.some((prefix) => kind.startsWith(prefix));
+}
 function randomSessionId() {
     if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
         return crypto.randomUUID();
@@ -10,18 +80,20 @@ function randomSessionId() {
 function isServerNotification(message) {
     return "method" in message;
 }
+function isChatgptAuthTokensRefreshRequest(message) {
+    if (!("method" in message) ||
+        message.method !== "account/chatgptAuthTokens/refresh" ||
+        !("id" in message) ||
+        (typeof message.id !== "number" && typeof message.id !== "string") ||
+        !("params" in message)) {
+        return false;
+    }
+    const params = asObject(message.params);
+    return !!params && typeof params.reason === "string";
+}
 function isResponse(message) {
     return "id" in message && !isServerNotification(message);
 }
-function normalizeIngestKind(kind) {
-    if (kind === "codex/event/task_started") {
-        return "turn/started";
-    }
-    if (kind === "codex/event/task_complete") {
-        return "turn/completed";
-    }
-    return kind;
-}
 export function createCodexHostRuntime(args) {
     let bridge = null;
     let actor = null;
@@ -38,7 +110,25 @@ export function createCodexHostRuntime(args) {
     let flushTimer = null;
     let flushTail = Promise.resolve();
     let ingestFlushMs = 250;
+    const pendingServerRequests = new Map();
+    const pendingAuthTokensRefreshRequests = new Map();
+    const enqueuedByKind = new Map();
+    const skippedByKind = new Map();
+    let enqueuedEventCount = 0;
+    let skippedEventCount = 0;
     const pendingRequests = new Map();
+    const incrementCount = (counts, kind) => {
+        counts.set(kind, (counts.get(kind) ?? 0) + 1);
+    };
+    const snapshotKindCounts = (counts) => Array.from(counts.entries())
+        .sort((left, right) => left[0].localeCompare(right[0]))
+        .map(([kind, count]) => ({ kind, count }));
+    const resetIngestMetrics = () => {
+        enqueuedByKind.clear();
+        skippedByKind.clear();
+        enqueuedEventCount = 0;
+        skippedEventCount = 0;
+    };
     const emitState = (lastError = null) => {
         args.handlers?.onState?.({
             running: !!bridge,
@@ -46,6 +136,13 @@ export function createCodexHostRuntime(args) {
             externalThreadId,
             turnId,
             turnInFlight,
+            pendingServerRequestCount: pendingServerRequests.size,
+            ingestMetrics: {
+                enqueuedEventCount,
+                skippedEventCount,
+                enqueuedByKind: snapshotKindCounts(enqueuedByKind),
+                skippedByKind: snapshotKindCounts(skippedByKind),
+            },
             lastError,
         });
     };
@@ -60,15 +157,123 @@ export function createCodexHostRuntime(args) {
         nextRequestId += 1;
         return id;
     };
-    const sendMessage = (message, trackedMethod) => {
+    const assertRuntimeReady = () => {
         if (!bridge) {
             throw new Error("Bridge not started");
         }
-        bridge.send(message);
+        return bridge;
+    };
+    const methodForRequest = (message) => message.method;
+    const sendMessage = (message, trackedMethod) => {
+        const runtimeBridge = assertRuntimeReady();
+        runtimeBridge.send(message);
         if ("id" in message && typeof message.id === "number" && trackedMethod) {
             pendingRequests.set(message.id, { method: trackedMethod });
         }
     };
+    const sendRequest = (message) => {
+        const runtimeBridge = assertRuntimeReady();
+        if (typeof message.id !== "number") {
+            throw new Error("Runtime requires numeric request ids.");
+        }
+        const messageId = message.id;
+        return new Promise((resolve, reject) => {
+            pendingRequests.set(messageId, { method: methodForRequest(message), resolve, reject });
+            runtimeBridge.send(message);
+        });
+    };
+    const registerPendingServerRequest = async (request) => {
+        pendingServerRequests.set(toRequestKey(request.requestId), request);
+        if (actor) {
+            await args.persistence.upsertPendingServerRequest({ actor, request });
+        }
+        emitState();
+    };
+    const resolvePendingServerRequest = async (argsForResolve) => {
+        const key = toRequestKey(argsForResolve.requestId);
+        const pending = pendingServerRequests.get(key);
+        if (!pending) {
+            return;
+        }
+        pendingServerRequests.delete(key);
+        if (actor) {
+            await args.persistence.resolvePendingServerRequest({
+                actor,
+                threadId: pending.threadId,
+                requestId: pending.requestId,
+                status: argsForResolve.status,
+                resolvedAt: Date.now(),
+                ...(argsForResolve.responseJson ? { responseJson: argsForResolve.responseJson } : {}),
+            });
+        }
+        emitState();
+    };
+    const expireTurnServerRequests = async (turn) => {
+        if (!turn.turnId) {
+            return;
+        }
+        const idsToExpire = [];
+        for (const request of pendingServerRequests.values()) {
+            if (request.threadId === turn.threadId && request.turnId === turn.turnId) {
+                idsToExpire.push(request.requestId);
+            }
+        }
+        for (const requestId of idsToExpire) {
+            await resolvePendingServerRequest({ requestId, status: "expired" });
+        }
+    };
+    const getPendingServerRequest = (requestId) => {
+        const pending = pendingServerRequests.get(toRequestKey(requestId));
+        if (!pending) {
+            throw new Error(`No pending server request found for id ${String(requestId)}`);
+        }
+        return pending;
+    };
+    const sendServerRequestResponse = async (requestId, responseMessage) => {
+        getPendingServerRequest(requestId);
+        sendMessage(responseMessage);
+        await resolvePendingServerRequest({
+            requestId,
+            status: "answered",
+            responseJson: JSON.stringify(responseMessage),
+        });
+    };
+    const registerPendingAuthTokensRefreshRequest = (request) => {
+        pendingAuthTokensRefreshRequests.set(toRequestKey(request.requestId), request);
+    };
+    const getPendingAuthTokensRefreshRequest = (requestId) => {
+        const pending = pendingAuthTokensRefreshRequests.get(toRequestKey(requestId));
+        if (!pending) {
+            throw new Error(`No pending auth token refresh request found for id ${String(requestId)}`);
+        }
+        return pending;
+    };
+    const resolvePendingAuthTokensRefreshRequest = (requestId) => {
+        pendingAuthTokensRefreshRequests.delete(toRequestKey(requestId));
+    };
+    const throwIfTurnMutationLocked = () => {
+        if (turnInFlight && !turnSettled) {
+            throw new Error("Cannot change thread lifecycle while a turn is in flight.");
+        }
+    };
+    const setRuntimeThreadFromResponse = (message, method) => {
+        if (message.error || !message.result || typeof message.result !== "object") {
+            return;
+        }
+        if (!("thread" in message.result) || typeof message.result.thread !== "object" || message.result.thread === null) {
+            return;
+        }
+        if (!("id" in message.result.thread) || typeof message.result.thread.id !== "string") {
+            return;
+        }
+        if (method === "thread/start" || method === "thread/resume" || method === "thread/fork") {
+            runtimeThreadId = message.result.thread.id;
+            if (!externalThreadId) {
+                externalThreadId = message.result.thread.id;
+            }
+            emitState();
+        }
+    };
     const flushQueue = async () => {
         if (!actor || !sessionId || !threadId) {
             return;
@@ -94,6 +299,28 @@ export function createCodexHostRuntime(args) {
         flushTail = next.catch(() => undefined);
         await next;
     };
+    const toIngestDelta = (event, persistedThreadId) => {
+        const resolvedTurnId = event.turnId ?? turnId;
+        if (!resolvedTurnId || !isTurnScopedEvent(event.kind)) {
+            return null;
+        }
+        const resolvedStreamId = event.streamId;
+        if (!resolvedStreamId) {
+            throw new Error(`Protocol event missing streamId for turn-scoped kind: ${event.kind}`);
+        }
+        return {
+            type: "stream_delta",
+            eventId: event.eventId,
+            kind: event.kind,
+            payloadJson: event.payloadJson,
+            cursorStart: event.cursorStart,
+            cursorEnd: event.cursorEnd,
+            createdAt: event.createdAt,
+            threadId: persistedThreadId,
+            turnId: resolvedTurnId,
+            streamId: resolvedStreamId,
+        };
+    };
     const enqueueIngestDelta = async (delta, forceFlush) => {
         ingestQueue.push(delta);
         if (forceFlush || ingestQueue.length >= MAX_BATCH_SIZE) {
@@ -116,6 +343,7 @@ export function createCodexHostRuntime(args) {
         sessionId = startArgs.sessionId ? `${startArgs.sessionId}-${randomSessionId()}` : randomSessionId();
         externalThreadId = startArgs.externalThreadId ?? null;
         ingestFlushMs = startArgs.ingestFlushMs ?? 250;
+        resetIngestMetrics();
         const bridgeConfig = {};
         if (args.bridge?.codexBin !== undefined) {
             bridgeConfig.codexBin = args.bridge.codexBin;
@@ -124,7 +352,7 @@ export function createCodexHostRuntime(args) {
         if (resolvedCwd !== undefined) {
             bridgeConfig.cwd = resolvedCwd;
         }
-        bridge = new CodexLocalBridge(bridgeConfig, {
+        const bridgeHandlers = {
             onEvent: async (event) => {
                 if (!actor || !sessionId) {
                     return;
@@ -167,11 +395,15 @@ export function createCodexHostRuntime(args) {
                         interruptRequested = false;
                     }
                 }
-                if (event.kind === "turn/completed" || event.kind === "codex/event/turn_aborted") {
+                if (event.kind === "turn/completed") {
                     turnId = null;
                     turnInFlight = false;
                     turnSettled = true;
                     emitState();
+                    await expireTurnServerRequests({
+                        threadId: threadId ?? event.threadId,
+                        ...(event.turnId ? { turnId: event.turnId } : {}),
+                    });
                 }
                 if (event.kind === "error") {
                     turnInFlight = false;
@@ -180,53 +412,51 @@ export function createCodexHostRuntime(args) {
                         turnId = null;
                     }
                     emitState();
+                    await expireTurnServerRequests({
+                        threadId: threadId ?? event.threadId,
+                        ...(event.turnId ? { turnId: event.turnId } : {}),
+                    });
+                }
+                const pendingServerRequest = parseManagedServerRequestFromEvent(event);
+                if (pendingServerRequest) {
+                    const persistedThreadId = threadId;
+                    if (persistedThreadId) {
+                        await registerPendingServerRequest({
+                            ...pendingServerRequest,
+                            threadId: persistedThreadId,
+                        });
+                    }
                 }
                 args.handlers?.onEvent?.(event);
                 const persistedThreadId = threadId;
                 if (!persistedThreadId) {
                     return;
                 }
-                const delta = event.streamId && event.turnId
-                    ? {
-                        type: "stream_delta",
-                        eventId: event.eventId,
-                        kind: normalizeIngestKind(event.kind),
-                        payloadJson: event.payloadJson,
-                        cursorStart: event.cursorStart,
-                        cursorEnd: event.cursorEnd,
-                        createdAt: event.createdAt,
-                        threadId: persistedThreadId,
-                        turnId: event.turnId,
-                        streamId: event.streamId,
-                    }
-                    : {
-                        type: "lifecycle_event",
-                        eventId: event.eventId,
-                        kind: normalizeIngestKind(event.kind),
-                        payloadJson: event.payloadJson,
-                        createdAt: event.createdAt,
-                        threadId: persistedThreadId,
-                        ...(event.turnId ? { turnId: event.turnId } : {}),
-                    };
+                const delta = toIngestDelta(event, persistedThreadId);
+                if (!delta) {
+                    skippedEventCount += 1;
+                    incrementCount(skippedByKind, event.kind);
+                    return;
+                }
+                enqueuedEventCount += 1;
+                incrementCount(enqueuedByKind, event.kind);
                 const forceFlush = event.kind === "turn/completed" ||
-                    event.kind === "codex/event/turn_aborted" ||
                     event.kind === "error";
                 await enqueueIngestDelta(delta, forceFlush);
             },
             onGlobalMessage: async (message) => {
+                if (isChatgptAuthTokensRefreshRequest(message)) {
+                    registerPendingAuthTokensRefreshRequest({
+                        requestId: message.id,
+                        params: message.params,
+                        createdAt: Date.now(),
+                    });
+                }
                 if (isResponse(message) && typeof message.id === "number") {
                     const pending = pendingRequests.get(message.id);
                     pendingRequests.delete(message.id);
-                    if (pending?.method === "thread/start" &&
-                        !message.error &&
-                        message.result &&
-                        typeof message.result === "object" &&
-                        "thread" in message.result &&
-                        typeof message.result.thread === "object" &&
-                        message.result.thread !== null &&
-                        "id" in message.result.thread &&
-                        typeof message.result.thread.id === "string") {
-                        runtimeThreadId = message.result.thread.id;
+                    if (pending) {
+                        setRuntimeThreadFromResponse(message, pending.method);
                     }
                     if (message.error && pending?.method === "turn/start") {
                         turnInFlight = false;
@@ -234,6 +464,15 @@ export function createCodexHostRuntime(args) {
                         turnId = null;
                         emitState();
                     }
+                    if (pending?.resolve) {
+                        if (message.error) {
+                            const code = typeof message.error.code === "number" ? String(message.error.code) : "UNKNOWN";
+                            pending.reject?.(new Error(`[${code}] ${message.error.message}`));
+                        }
+                        else {
+                            pending.resolve(message);
+                        }
+                    }
                 }
                 args.handlers?.onGlobalMessage?.(message);
             },
@@ -245,23 +484,53 @@ export function createCodexHostRuntime(args) {
             onProcessExit: (code) => {
                 emitState(`codex exited with code ${String(code)}`);
             },
-        });
+        };
+        bridge = args.bridgeFactory
+            ? args.bridgeFactory(bridgeConfig, bridgeHandlers)
+            : new CodexLocalBridge(bridgeConfig, bridgeHandlers);
         bridge.start();
-        sendMessage(buildInitializeRequest(requestId(), {
+        sendMessage(buildInitializeRequestWithCapabilities(requestId(), {
             name: "codex_local_host_runtime",
             title: "Codex Local Host Runtime",
             version: "0.1.0",
+        }, {
+            experimentalApi: Array.isArray(startArgs.dynamicTools) && startArgs.dynamicTools.length > 0,
         }), "initialize");
         sendMessage(buildInitializedNotification());
-        sendMessage(buildThreadStartRequest(requestId(), {
-            ...(startArgs.model ? { model: startArgs.model } : {}),
-            ...(startArgs.cwd ? { cwd: startArgs.cwd } : {}),
-        }), "thread/start");
+        const strategy = startArgs.threadStrategy ?? "start";
+        if ((strategy === "resume" || strategy === "fork") && !startArgs.runtimeThreadId) {
+            throw new Error(`runtimeThreadId is required when threadStrategy=\"${strategy}\".`);
+        }
+        if (strategy === "start") {
+            sendMessage(buildThreadStartRequest(requestId(), {
+                ...(startArgs.model ? { model: startArgs.model } : {}),
+                ...(startArgs.cwd ? { cwd: startArgs.cwd } : {}),
+                ...(startArgs.dynamicTools ? { dynamicTools: startArgs.dynamicTools } : {}),
+            }), "thread/start");
+        }
+        else if (strategy === "resume") {
+            sendMessage(buildThreadResumeRequest(requestId(), {
+                threadId: startArgs.runtimeThreadId,
+                ...(startArgs.model ? { model: startArgs.model } : {}),
+                ...(startArgs.cwd ? { cwd: startArgs.cwd } : {}),
+                ...(startArgs.dynamicTools ? { dynamicTools: startArgs.dynamicTools } : {}),
+            }), "thread/resume");
+        }
+        else {
+            sendMessage(buildThreadForkRequest(requestId(), {
+                threadId: startArgs.runtimeThreadId,
+                ...(startArgs.model ? { model: startArgs.model } : {}),
+                ...(startArgs.cwd ? { cwd: startArgs.cwd } : {}),
+            }), "thread/fork");
+        }
         emitState();
     };
     const stop = async () => {
         clearFlushTimer();
         await flushQueue();
+        for (const [, pending] of pendingRequests) {
+            pending.reject?.(new Error("Bridge stopped before request completed."));
+        }
         bridge?.stop();
         bridge = null;
         actor = null;
@@ -274,6 +543,9 @@ export function createCodexHostRuntime(args) {
         turnSettled = false;
         interruptRequested = false;
         pendingRequests.clear();
+        pendingServerRequests.clear();
+        pendingAuthTokensRefreshRequests.clear();
+        resetIngestMetrics();
         emitState();
     };
     const sendTurn = (text) => {
@@ -301,12 +573,112 @@ export function createCodexHostRuntime(args) {
         }
         sendMessage(buildTurnInterruptRequest(requestId(), { threadId: runtimeThreadId, turnId }), "turn/interrupt");
     };
+    const resumeThread = async (nextRuntimeThreadId, params) => {
+        throwIfTurnMutationLocked();
+        return sendRequest(buildThreadResumeRequest(requestId(), {
+            threadId: nextRuntimeThreadId,
+            ...(params ?? {}),
+        }));
+    };
+    const forkThread = async (sourceRuntimeThreadId, params) => {
+        throwIfTurnMutationLocked();
+        return sendRequest(buildThreadForkRequest(requestId(), {
+            threadId: sourceRuntimeThreadId,
+            ...(params ?? {}),
+        }));
+    };
+    const archiveThread = async (targetRuntimeThreadId) => {
+        throwIfTurnMutationLocked();
+        return sendRequest(buildThreadArchiveRequest(requestId(), {
+            threadId: targetRuntimeThreadId,
+        }));
+    };
+    const unarchiveThread = async (targetRuntimeThreadId) => {
+        throwIfTurnMutationLocked();
+        return sendRequest(buildThreadUnarchiveRequest(requestId(), {
+            threadId: targetRuntimeThreadId,
+        }));
+    };
+    const rollbackThread = async (targetRuntimeThreadId, numTurns) => {
+        throwIfTurnMutationLocked();
+        return sendRequest(buildThreadRollbackRequest(requestId(), {
+            threadId: targetRuntimeThreadId,
+            numTurns,
+        }));
+    };
+    const readThread = async (targetRuntimeThreadId, includeTurns = false) => sendRequest(buildThreadReadRequest(requestId(), {
+        threadId: targetRuntimeThreadId,
+        includeTurns,
+    }));
+    const readAccount = async (params) => sendRequest(buildAccountReadRequest(requestId(), params));
+    const loginAccount = async (params) => sendRequest(buildAccountLoginStartRequest(requestId(), params));
+    const cancelAccountLogin = async (params) => sendRequest(buildAccountLoginCancelRequest(requestId(), params));
+    const logoutAccount = async () => sendRequest(buildAccountLogoutRequest(requestId()));
+    const readAccountRateLimits = async () => sendRequest(buildAccountRateLimitsReadRequest(requestId()));
+    const listThreads = async (params) => sendRequest(buildThreadListRequest(requestId(), params));
+    const listLoadedThreads = async (params) => sendRequest(buildThreadLoadedListRequest(requestId(), params));
+    const listPendingServerRequests = async (threadIdFilter) => {
+        if (actor) {
+            return args.persistence.listPendingServerRequests({
+                actor,
+                ...(threadIdFilter ? { threadId: threadIdFilter } : {}),
+            });
+        }
+        return [];
+    };
+    const respondCommandApproval = async (argsForDecision) => {
+        const pending = getPendingServerRequest(argsForDecision.requestId);
+        if (pending.method !== "item/commandExecution/requestApproval") {
+            throw new Error(`Server request ${String(argsForDecision.requestId)} is ${pending.method}, expected item/commandExecution/requestApproval`);
+        }
+        await sendServerRequestResponse(argsForDecision.requestId, buildCommandExecutionApprovalResponse(argsForDecision.requestId, argsForDecision.decision));
+    };
+    const respondFileChangeApproval = async (argsForDecision) => {
+        const pending = getPendingServerRequest(argsForDecision.requestId);
+        if (pending.method !== "item/fileChange/requestApproval") {
+            throw new Error(`Server request ${String(argsForDecision.requestId)} is ${pending.method}, expected item/fileChange/requestApproval`);
+        }
+        await sendServerRequestResponse(argsForDecision.requestId, buildFileChangeApprovalResponse(argsForDecision.requestId, argsForDecision.decision));
+    };
+    const respondToolUserInput = async (argsForAnswer) => {
+        const pending = getPendingServerRequest(argsForAnswer.requestId);
+        if (pending.method !== "item/tool/requestUserInput") {
+            throw new Error(`Server request ${String(argsForAnswer.requestId)} is ${pending.method}, expected item/tool/requestUserInput`);
+        }
+        await sendServerRequestResponse(argsForAnswer.requestId, buildToolRequestUserInputResponse(argsForAnswer.requestId, argsForAnswer.answers));
+    };
+    const respondDynamicToolCall = async (argsForResult) => {
+        const pending = getPendingServerRequest(argsForResult.requestId);
+        if (pending.method !== "item/tool/call") {
+            throw new Error(`Server request ${String(argsForResult.requestId)} is ${pending.method}, expected item/tool/call`);
+        }
+        await sendServerRequestResponse(argsForResult.requestId, buildDynamicToolCallResponse(argsForResult.requestId, {
+            success: argsForResult.success,
+            contentItems: argsForResult.contentItems,
+        }));
+    };
+    const respondChatgptAuthTokensRefresh = async (argsForTokens) => {
+        getPendingAuthTokensRefreshRequest(argsForTokens.requestId);
+        const responseMessage = buildChatgptAuthTokensRefreshResponse(argsForTokens.requestId, {
+            idToken: argsForTokens.idToken,
+            accessToken: argsForTokens.accessToken,
+        });
+        sendMessage(responseMessage);
+        resolvePendingAuthTokensRefreshRequest(argsForTokens.requestId);
+    };
     const getState = () => ({
         running: !!bridge,
         threadId,
         externalThreadId,
         turnId,
         turnInFlight,
+        pendingServerRequestCount: pendingServerRequests.size,
+        ingestMetrics: {
+            enqueuedEventCount,
+            skippedEventCount,
+            enqueuedByKind: snapshotKindCounts(enqueuedByKind),
+            skippedByKind: snapshotKindCounts(skippedByKind),
+        },
         lastError: null,
     });
     return {
@@ -314,6 +686,25 @@ export function createCodexHostRuntime(args) {
         stop,
         sendTurn,
         interrupt,
+        resumeThread,
+        forkThread,
+        archiveThread,
+        unarchiveThread,
+        rollbackThread,
+        readThread,
+        readAccount,
+        loginAccount,
+        cancelAccountLogin,
+        logoutAccount,
+        readAccountRateLimits,
+        listThreads,
+        listLoadedThreads,
+        listPendingServerRequests,
+        respondCommandApproval,
+        respondFileChangeApproval,
+        respondToolUserInput,
+        respondDynamicToolCall,
+        respondChatgptAuthTokensRefresh,
         getState,
     };
 }