@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/packages/runtime/dist/index.d.ts

@@ -7,6 +7,7 @@ export type RuntimeHandle = {
     sessionKey: string;
     backend: string;
     runtimeSessionName: string;
+    model?: string;
     cwd?: string;
     acpxRecordId?: string;
     backendSessionId?: string;
@@ -15,9 +16,22 @@ export type RuntimeHandle = {
     externalHandle?: Record<string, unknown>;
 };
 export type RuntimeTurnAttachment = {
+    name?: string;
     mediaType: string;
+    sizeBytes?: number;
     data: string;
 };
+export type RuntimeModelOption = {
+    id: string;
+    label?: string;
+    unavailable?: boolean;
+    reason?: string;
+};
+export type RuntimeOptionChoice = {
+    id: string;
+    label: string;
+    description?: string;
+};
 export type RuntimeEvent = {
     type: "text_delta";
     text: string;
@@ -29,6 +43,16 @@ export type RuntimeEvent = {
     tag?: string;
     used?: number;
     size?: number;
+} | {
+    type: "session_usage";
+    source: "provider" | "estimated";
+    usedTokens: number;
+    contextWindowTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    reasoningOutputTokens?: number;
+    totalTokens?: number;
 } | {
     type: "tool_call";
     text: string;
@@ -36,6 +60,13 @@ export type RuntimeEvent = {
     toolCallId?: string;
     status?: string;
     title?: string;
+} | {
+    type: "option_request";
+    optionRequestId: string;
+    title?: string;
+    message: string;
+    options: RuntimeOptionChoice[];
+    allowFreeText?: boolean;
 } | {
     type: "done";
     stopReason?: string;
@@ -74,6 +105,11 @@ export interface RuntimeTurn {
     cancel(input?: {
         reason?: string;
     }): Promise<void>;
+    respondOption?(input: {
+        optionRequestId: string;
+        selectedOptionId?: string;
+        text?: string;
+    }): Promise<void>;
     closeStream(input?: {
         reason?: string;
     }): Promise<void>;
@@ -99,6 +135,8 @@ export type RuntimeAgentProfile = {
     label: string;
     command?: string;
     historyModel?: RuntimeHistoryModel;
+    defaultModel?: string;
+    models?: RuntimeModelOption[];
     sessionPrimitives?: RuntimeCapabilities["sessionPrimitives"];
 };
 export type RuntimeHistoricalSession = {
@@ -153,6 +191,26 @@ export type RuntimeHistoricalEventPage = {
     currentHead?: string;
     lastTurnId?: string;
 };
+export type RuntimeTurnInspection = {
+    status: "active";
+    currentHead?: string;
+    lastTurnId?: string;
+    providerTurnId?: string;
+    evidence?: string;
+} | {
+    status: "terminal";
+    terminalStatus: "completed" | "cancelled" | "failed";
+    currentHead?: string;
+    lastTurnId?: string;
+    providerTurnId?: string;
+    error?: string;
+    evidence?: string;
+} | {
+    status: "unknown" | "not_found" | "uninspectable";
+    providerTurnId?: string;
+    reason?: string;
+    evidence?: string;
+};
 export interface HappyElvesRuntime {
     getCapabilities(): RuntimeCapabilities;
     listAgents(): RuntimeAgentProfile[];
@@ -164,6 +222,7 @@ export interface HappyElvesRuntime {
         resumeHandle?: RuntimeHandle;
         cwd?: string;
         permissionMode?: RuntimePermissionMode;
+        model?: string;
         restartableEmptySession?: boolean;
     }): Promise<RuntimeHandle>;
     listHistoricalSessions?(input: {
@@ -196,12 +255,19 @@ export interface HappyElvesRuntime {
         before?: string;
         limit?: number;
     }): Promise<RuntimeHistoricalEventPage>;
+    inspectTurn?(input: {
+        handle: RuntimeHandle;
+        turnId?: string;
+        providerTurnId?: string;
+        requestId?: string;
+    }): Promise<RuntimeTurnInspection>;
     startTurn(input: {
         handle: RuntimeHandle;
         text: string;
         attachments?: RuntimeTurnAttachment[];
         mode: RuntimePromptMode;
         permissionMode?: RuntimePermissionMode;
+        model?: string;
         requestId: string;
         timeoutMs?: number;
         signal?: AbortSignal;

package/packages/runtime-acpx/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { HappyElvesRuntime } from "@happy-elves/runtime";
+import type { HappyElvesRuntime } from "../../runtime/dist/index.js";
 export type AcpxRuntimeProviderOptions = {
     cwd: string;
     stateDir: string;

package/packages/runtime-acpx/dist/index.js

@@ -101,6 +101,14 @@ export function createAcpxRuntimeProvider(options) {
         startTurn(input) {
             return runtime.startTurn(input);
         },
+        async inspectTurn(input) {
+            return {
+                status: "uninspectable",
+                providerTurnId: input.providerTurnId ?? input.handle.backendSessionId ?? input.handle.acpxRecordId,
+                reason: "ACP runtime does not expose an authoritative inspectTurn primitive",
+                evidence: "unsupported",
+            };
+        },
         cancel(input) {
             return runtime.cancel({ ...input, handle: input.handle });
         },

package/packages/runtime-cli/dist/claude-history.d.ts

@@ -1,6 +1,5 @@
-import type { RuntimeHistoricalEvent, RuntimeHistoricalSession, RuntimeHistoricalSessionPage } from "@happy-elves/runtime";
+import type { RuntimeHistoricalEvent, RuntimeHistoricalSessionPage } from "../../runtime/dist/index.js";
 import { type ClaudeContentBlock } from "./claude-json.js";
-export declare function readClaudeHistoricalSessions(cwd: string | undefined, limit: number): Promise<RuntimeHistoricalSession[]>;
 export declare function readClaudeHistoricalSessionPage(cwd: string | undefined, limit: number, cursor?: string): Promise<RuntimeHistoricalSessionPage>;
 export declare function readClaudeSessionName(filePath: string): Promise<string | undefined>;
 export declare function contentBlocks(value: unknown): ClaudeContentBlock[];

package/packages/runtime-cli/dist/claude-history.js

@@ -3,9 +3,6 @@ import { readFile, readdir, stat } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { parseClaudeJsonLine, record } from "./claude-json.js";
 import { canonicalClaudeCwd, claudeProjectDirsForCwd, claudeProjectsDir, claudeSessionPath } from "./claude-session-store.js";
-export async function readClaudeHistoricalSessions(cwd, limit) {
-    return (await readClaudeHistoricalSessionPage(cwd, limit)).sessions;
-}
 export async function readClaudeHistoricalSessionPage(cwd, limit, cursor) {
     const offset = claudeHistoryOffset(cursor);
     if (cwd?.trim()) {

package/packages/runtime-cli/dist/claude-session-store.d.ts

@@ -1,4 +1,3 @@
-export declare function claudeProjectDir(cwd: string): string;
 export declare function claudeProjectDirsForCwd(cwd: string): string[];
 export declare function canonicalClaudeCwd(cwd: string): string;
 export declare function claudeProjectsDir(): string;

package/packages/runtime-cli/dist/claude-session-store.js

@@ -5,7 +5,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { parseClaudeJsonLine } from "./claude-json.js";
-export function claudeProjectDir(cwd) {
+function claudeProjectDir(cwd) {
     const projectId = canonicalClaudeCwd(cwd).replace(/[^a-zA-Z0-9-]/g, "-");
     return join(claudeProjectsDir(), projectId);
 }

package/packages/runtime-cli/dist/claude-turn.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeHandle, RuntimeTurn } from "@happy-elves/runtime";
+import type { RuntimeHandle, RuntimeTurn } from "../../runtime/dist/index.js";
 import { type RuntimePermissionMode } from "./permissions.js";
 export declare function startClaudeTurn(input: {
     command: string;
@@ -7,6 +7,7 @@ export declare function startClaudeTurn(input: {
     requestId: string;
     timeoutMs?: number;
     permissionMode?: RuntimePermissionMode;
+    model?: string;
     resume: boolean;
     name?: string;
 }): RuntimeTurn;

package/packages/runtime-cli/dist/claude-turn.js

@@ -17,6 +17,7 @@ export function startClaudeTurn(input) {
         "--verbose",
         ...sessionArgs,
         ...(input.name ? ["--name", input.name] : []),
+        ...(input.model ? ["--model", input.model] : []),
         "--permission-mode",
         claudePermissionMode(input.permissionMode),
         input.text,
@@ -35,18 +36,35 @@ export function startClaudeTurn(input) {
         if (settled)
             return;
         settled = true;
+        clearInactivityTimer();
         queue.close();
         resolveResult(value);
     };
-    const timer = input.timeoutMs
-        ? setTimeout(() => {
-            proc.kill("SIGTERM");
-            finish({ status: "failed", error: { message: `Claude turn timed out after ${input.timeoutMs}ms` } });
-        }, input.timeoutMs)
-        : null;
+    let inactivityTimer = null;
+    const clearInactivityTimer = () => {
+        if (!inactivityTimer)
+            return;
+        clearTimeout(inactivityTimer);
+        inactivityTimer = null;
+    };
+    const refreshInactivityTimer = () => {
+        if (!input.timeoutMs || settled)
+            return;
+        clearInactivityTimer();
+        inactivityTimer = setTimeout(() => {
+            inactivityTimer = null;
+            queue.push({
+                type: "status",
+                text: `No Claude runtime activity for ${input.timeoutMs}ms; still waiting for provider completion.`,
+                tag: "inactivity",
+            });
+        }, input.timeoutMs);
+    };
+    refreshInactivityTimer();
     createInterface({ input: proc.stdout }).on("line", (line) => {
         if (!line.trim())
             return;
+        refreshInactivityTimer();
         const message = parseClaudeJsonLine(line);
         if (!message) {
             queue.push({ type: "text_delta", text: line, stream: "output" });
@@ -79,10 +97,12 @@ export function startClaudeTurn(input) {
             queue.push({ type: "status", text: "Claude session resumed", tag: typeof message.session_id === "string" ? message.session_id : undefined });
         }
     });
-    proc.stderr.on("data", (chunk) => queue.push({ type: "status", text: chunk.toString(), tag: "stderr" }));
+    proc.stderr.on("data", (chunk) => {
+        refreshInactivityTimer();
+        queue.push({ type: "status", text: chunk.toString(), tag: "stderr" });
+    });
     proc.on("exit", (code, signal) => {
-        if (timer)
-            clearTimeout(timer);
+        clearInactivityTimer();
         if (!settled && code === 0)
             finish({ status: "completed" });
         if (!settled)

package/packages/runtime-cli/dist/codex-app-server.d.ts

@@ -1,9 +1,10 @@
-import type { RuntimePromptMode, RuntimeTurn } from "@happy-elves/runtime";
+import type { RuntimePromptMode, RuntimeTurn } from "../../runtime/dist/index.js";
 import type { RuntimePermissionMode } from "./permissions.js";
 export declare class CodexAppServerSession {
     private readonly command;
     private readonly cwd;
     private readonly onThreadIdChanged?;
+    private readonly initialModel?;
     private rpc;
     private turnQueue;
     private turnResolve;
@@ -11,12 +12,14 @@ export declare class CodexAppServerSession {
     private activeTurnId;
     private activeTurnOutputCount;
     private activeTurnStderr;
+    private activeTurnActivity;
     private completedTurnIds;
     private appliedPermissionMode;
+    private appliedModel;
     private restartableEmptyThread;
     threadId: string | null;
-    constructor(command: string, cwd: string, threadId?: string, onThreadIdChanged?: ((threadId: string) => void) | undefined, restartableEmptyThread?: boolean);
-    ensure(permissionMode?: RuntimePermissionMode): Promise<string>;
+    constructor(command: string, cwd: string, threadId?: string, onThreadIdChanged?: ((threadId: string) => void) | undefined, restartableEmptyThread?: boolean, initialModel?: string | undefined);
+    ensure(permissionMode?: RuntimePermissionMode, model?: string): Promise<string>;
     private ensureCurrentPermission;
     private ensurePermission;
     private startNewThread;
@@ -28,6 +31,7 @@ export declare class CodexAppServerSession {
         timeoutMs?: number;
         mode: RuntimePromptMode;
         permissionMode?: RuntimePermissionMode;
+        model?: string;
     }): RuntimeTurn;
     close(): Promise<void>;
     cancel(): Promise<void>;
@@ -49,6 +53,7 @@ export declare class CodexAppServerSession {
     private handleNotification;
     private extractTurnId;
     private recordStderr;
+    private noteTurnActivity;
     private emptyCompletionFailure;
 }
 //# sourceMappingURL=codex-app-server.d.ts.map

package/packages/runtime-cli/dist/codex-app-server.js

@@ -8,6 +8,7 @@ export class CodexAppServerSession {
     command;
     cwd;
     onThreadIdChanged;
+    initialModel;
     rpc = null;
     turnQueue = null;
     turnResolve = null;
@@ -15,51 +16,56 @@ export class CodexAppServerSession {
     activeTurnId = null;
     activeTurnOutputCount = 0;
     activeTurnStderr = [];
+    activeTurnActivity = null;
     completedTurnIds = [];
     appliedPermissionMode;
+    appliedModel;
     restartableEmptyThread = false;
     threadId;
-    constructor(command, cwd, threadId, onThreadIdChanged, restartableEmptyThread = false) {
+    constructor(command, cwd, threadId, onThreadIdChanged, restartableEmptyThread = false, initialModel) {
         this.command = command;
         this.cwd = cwd;
         this.onThreadIdChanged = onThreadIdChanged;
+        this.initialModel = initialModel;
         this.threadId = threadId ?? null;
         this.restartableEmptyThread = Boolean(threadId) && restartableEmptyThread;
     }
-    async ensure(permissionMode) {
-        return await this.ensurePermission(normalizeCodexPermissionMode(permissionMode));
+    async ensure(permissionMode, model) {
+        return await this.ensurePermission(normalizeCodexPermissionMode(permissionMode), normalizeModel(model ?? this.initialModel));
     }
     async ensureCurrentPermission() {
-        return await this.ensurePermission(normalizeCodexPermissionMode(this.appliedPermissionMode));
+        return await this.ensurePermission(normalizeCodexPermissionMode(this.appliedPermissionMode), this.appliedModel ?? normalizeModel(this.initialModel));
     }
-    async ensurePermission(permissionMode) {
+    async ensurePermission(permissionMode, model) {
         const hadProcess = Boolean(this.rpc);
         if (!this.rpc)
             await this.connect();
         if (this.threadId) {
-            if (!hadProcess || permissionMode !== this.appliedPermissionMode) {
+            if (!hadProcess || permissionMode !== this.appliedPermissionMode || model !== this.appliedModel) {
                 try {
-                    await this.request("thread/resume", codexThreadResumeParams(this.threadId, this.cwd, permissionMode));
+                    await this.request("thread/resume", codexThreadResumeParams(this.threadId, this.cwd, permissionMode, model));
                 }
                 catch (error) {
                     if (!this.canRestartEmptyThread(error))
                         throw error;
-                    return await this.restartEmptyThread(permissionMode);
+                    return await this.restartEmptyThread(permissionMode, model);
                 }
                 this.appliedPermissionMode = permissionMode;
+                this.appliedModel = model;
             }
             return this.threadId;
         }
-        return await this.startNewThread(permissionMode, true);
+        return await this.startNewThread(permissionMode, true, model);
     }
-    async startNewThread(permissionMode, restartableEmptyThread) {
-        const result = (await this.request("thread/start", codexThreadStartParams(this.cwd, permissionMode)));
+    async startNewThread(permissionMode, restartableEmptyThread, model) {
+        const result = (await this.request("thread/start", codexThreadStartParams(this.cwd, permissionMode, model)));
         const threadId = result.thread?.id;
         if (!threadId)
             throw new Error("Codex app-server did not return a thread id");
         this.threadId = threadId;
         this.restartableEmptyThread = restartableEmptyThread;
         this.appliedPermissionMode = permissionMode;
+        this.appliedModel = model;
         this.onThreadIdChanged?.(threadId);
         return threadId;
     }
@@ -69,20 +75,21 @@ export class CodexAppServerSession {
             !this.activeTurnId &&
             /no rollout found|failed to load thread history|invalid thread-store request/iu.test(error instanceof Error ? error.message : String(error)));
     }
-    async restartEmptyThread(permissionMode) {
+    async restartEmptyThread(permissionMode, model) {
         const previousThreadId = this.threadId;
         if (previousThreadId) {
             await this.request("thread/archive", { threadId: previousThreadId }).catch(() => undefined);
         }
         this.threadId = null;
         this.appliedPermissionMode = undefined;
+        this.appliedModel = undefined;
         this.restartableEmptyThread = false;
         this.turnQueue?.push({
             type: "status",
             text: "Codex empty thread could not be resumed; starting a fresh empty thread with the requested permission mode.",
             tag: "runtime",
         });
-        return await this.startNewThread(permissionMode, true);
+        return await this.startNewThread(permissionMode, true, model);
     }
     startTurn(input) {
         const queue = new AsyncQueue();
@@ -101,7 +108,7 @@ export class CodexAppServerSession {
             queue.close();
             resolveResult(value);
         };
-        this.sendTurn(input.text, input.timeoutMs, input.permissionMode).catch((error) => {
+        this.sendTurn(input.text, input.timeoutMs, input.permissionMode, input.model).catch((error) => {
             queue.push({ type: "error", message: error instanceof Error ? error.message : String(error) });
             this.turnResolve?.({ status: "failed", error: { message: error instanceof Error ? error.message : String(error) } });
         });
@@ -198,20 +205,44 @@ export class CodexAppServerSession {
             throw error;
         }
     }
-    async sendTurn(text, timeoutMs = 10 * 60 * 1000, permissionMode) {
-        const threadId = await this.ensure(permissionMode);
+    async sendTurn(text, inactivityTimeoutMs, permissionMode, model) {
+        const threadId = await this.ensure(permissionMode, model);
         const completion = new Promise((resolve) => {
             this.activeCompletionResolve = resolve;
         });
-        const timer = setTimeout(() => {
-            this.turnResolve?.({ status: "failed", error: { message: `Codex turn timed out after ${timeoutMs}ms` } });
-        }, timeoutMs);
-        const result = (await this.request("turn/start", codexTurnStartParams(threadId, this.cwd, text, normalizeCodexPermissionMode(permissionMode))));
-        this.activeTurnId = result.turn?.id ?? null;
-        const finalResult = await completion;
-        clearTimeout(timer);
-        this.turnResolve?.(finalResult);
-        this.activeCompletionResolve = null;
+        let inactivityTimer = null;
+        const clearInactivityTimer = () => {
+            if (!inactivityTimer)
+                return;
+            clearTimeout(inactivityTimer);
+            inactivityTimer = null;
+        };
+        const refreshInactivityTimer = () => {
+            if (!inactivityTimeoutMs)
+                return;
+            clearInactivityTimer();
+            inactivityTimer = setTimeout(() => {
+                inactivityTimer = null;
+                this.turnQueue?.push({
+                    type: "status",
+                    text: `No Codex runtime activity for ${inactivityTimeoutMs}ms; still waiting for provider completion.`,
+                    tag: "inactivity",
+                });
+            }, inactivityTimeoutMs);
+        };
+        this.activeTurnActivity = refreshInactivityTimer;
+        refreshInactivityTimer();
+        try {
+            const result = (await this.request("turn/start", codexTurnStartParams(threadId, this.cwd, text, normalizeCodexPermissionMode(permissionMode))));
+            this.activeTurnId = result.turn?.id ?? null;
+            const finalResult = await completion;
+            this.turnResolve?.(finalResult);
+        }
+        finally {
+            clearInactivityTimer();
+            this.activeTurnActivity = null;
+            this.activeCompletionResolve = null;
+        }
     }
     async interrupt() {
         if (!this.threadId || !this.activeTurnId)
@@ -225,6 +256,7 @@ export class CodexAppServerSession {
         const decision = codexServerRequestResponse(method, params, this.appliedPermissionMode);
         if (!decision)
             throw new Error(`Unsupported Codex app-server request: ${method}`);
+        this.noteTurnActivity();
         this.turnQueue?.push({ type: "status", text: decision.summary, tag: "approval" });
         return decision.response;
     }
@@ -232,7 +264,13 @@ export class CodexAppServerSession {
         const queue = this.turnQueue;
         if (!method || !queue)
             return;
+        this.noteTurnActivity();
         const payload = recordFrom(params);
+        const usage = codexUsageEventFromNotification(method, payload);
+        if (usage) {
+            queue.push(usage);
+            return;
+        }
         if (method === "turn/started") {
             this.activeTurnId = stringField(recordFrom(payload.turn), "id") ?? stringField(payload, "turnId") ?? this.activeTurnId;
             queue.push({ type: "status", text: "Codex turn started", tag: "turn" });
@@ -283,12 +321,16 @@ export class CodexAppServerSession {
     }
     recordStderr(text) {
         if (this.turnQueue) {
+            this.noteTurnActivity();
             this.activeTurnStderr.push(text);
             if (this.activeTurnStderr.length > 25)
                 this.activeTurnStderr.shift();
             this.turnQueue.push({ type: "status", text, tag: "stderr" });
         }
     }
+    noteTurnActivity() {
+        this.activeTurnActivity?.();
+    }
     emptyCompletionFailure() {
         if (this.activeTurnOutputCount > 0)
             return undefined;
@@ -318,4 +360,59 @@ function codexStderrMessage(text) {
     }
     return text.trim();
 }
+function codexUsageEventFromNotification(method, payload) {
+    const candidates = [
+        payload,
+        recordFrom(payload.payload),
+        recordFrom(payload.event),
+        recordFrom(payload.message),
+    ];
+    for (const candidate of candidates) {
+        const type = stringField(candidate, "type");
+        const info = recordFrom(candidate.info);
+        const total = recordFrom(info.total_token_usage ?? candidate.total_token_usage ?? candidate.totalTokenUsage);
+        const last = recordFrom(info.last_token_usage ?? candidate.last_token_usage ?? candidate.lastTokenUsage);
+        const contextWindow = numberField(info, "model_context_window", "modelContextWindow") ?? numberField(candidate, "model_context_window", "modelContextWindow");
+        const totalTokens = numberField(total, "total_tokens", "totalTokens") ??
+            numberField(candidate, "total_tokens", "totalTokens");
+        const inputTokens = numberField(total, "input_tokens", "inputTokens") ??
+            numberField(last, "input_tokens", "inputTokens") ??
+            numberField(candidate, "input_tokens", "inputTokens");
+        const outputTokens = numberField(total, "output_tokens", "outputTokens") ??
+            numberField(last, "output_tokens", "outputTokens") ??
+            numberField(candidate, "output_tokens", "outputTokens");
+        const cachedInputTokens = numberField(total, "cached_input_tokens", "cachedInputTokens") ??
+            numberField(last, "cached_input_tokens", "cachedInputTokens") ??
+            numberField(candidate, "cached_input_tokens", "cachedInputTokens");
+        const reasoningOutputTokens = numberField(total, "reasoning_output_tokens", "reasoningOutputTokens") ??
+            numberField(last, "reasoning_output_tokens", "reasoningOutputTokens") ??
+            numberField(candidate, "reasoning_output_tokens", "reasoningOutputTokens");
+        const usedTokens = totalTokens ?? inputTokens;
+        if (usedTokens === undefined || (type !== "token_count" && !/token|usage/i.test(method) && contextWindow === undefined))
+            continue;
+        return {
+            type: "session_usage",
+            source: "provider",
+            usedTokens,
+            ...(contextWindow !== undefined ? { contextWindowTokens: contextWindow } : {}),
+            ...(inputTokens !== undefined ? { inputTokens } : {}),
+            ...(outputTokens !== undefined ? { outputTokens } : {}),
+            ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}),
+            ...(reasoningOutputTokens !== undefined ? { reasoningOutputTokens } : {}),
+            ...(totalTokens !== undefined ? { totalTokens } : {}),
+        };
+    }
+    return undefined;
+}
+function numberField(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return Math.max(0, Math.round(value));
+    }
+    return undefined;
+}
+function normalizeModel(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 //# sourceMappingURL=codex-app-server.js.map

package/packages/runtime-cli/dist/codex-history.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeHistoricalEvent, RuntimeHistoricalSession, RuntimeHistoricalSessionPage } from "@happy-elves/runtime";
+import type { RuntimeHistoricalEvent, RuntimeHistoricalSession, RuntimeHistoricalSessionPage } from "../../runtime/dist/index.js";
 export declare function readCodexCanonicalHistoricalSessionPage(input: {
     command: string;
     cwd?: string;
@@ -9,7 +9,6 @@ export declare function readCodexCanonicalHistoricalSessionPage(input: {
     snapshotDir?: string;
 }): Promise<RuntimeHistoricalSessionPage>;
 export declare function readCodexFilesystemHistoricalSessionPage(cwd: string | undefined, limit: number, runtimeCwd?: string, includeArchived?: boolean, cursor?: string): Promise<RuntimeHistoricalSessionPage>;
-export declare function readCodexHistoricalSessions(command: string, cwd: string | undefined, limit: number, runtimeCwd?: string, includeArchived?: boolean): Promise<RuntimeHistoricalSession[]>;
 export declare function readCodexHistoricalSessionPage(command: string, cwd: string | undefined, limit: number, runtimeCwd?: string, includeArchived?: boolean, cursor?: string): Promise<RuntimeHistoricalSessionPage>;
 export declare function codexThreadRecordToHistoricalSession(item: unknown, cwd: string | undefined, runtimeCwd?: string): RuntimeHistoricalSession | undefined;
 export declare function codexToolEventFromItem(item: unknown, fallbackStatus?: "started" | "completed"): RuntimeHistoricalEvent["payload"] | undefined;

package/packages/runtime-cli/dist/codex-history.js

@@ -111,9 +111,6 @@ export async function readCodexFilesystemHistoricalSessionPage(cwd, limit, runti
         ...(hasMore ? { nextCursor: encodeFilesystemCursor({ phase, indexOffset, directoryIndex, fileIndex, legacySkip }) } : {}),
     };
 }
-export async function readCodexHistoricalSessions(command, cwd, limit, runtimeCwd = process.cwd(), includeArchived = false) {
-    return (await readCodexHistoricalSessionPage(command, cwd, limit, runtimeCwd, includeArchived)).sessions;
-}
 export async function readCodexHistoricalSessionPage(command, cwd, limit, runtimeCwd = process.cwd(), includeArchived = false, cursor) {
     const rpc = probeClient(command, cwd ? canonicalPath(cwd) : runtimeCwd);
     try {
@@ -209,6 +206,15 @@ function timestampMs(value) {
     }
     return undefined;
 }
+function uuidV7TimestampMs(value) {
+    if (!value)
+        return undefined;
+    const match = /^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.exec(value);
+    if (!match)
+        return undefined;
+    const timestamp = Number.parseInt(`${match[1]}${match[2]}`, 16);
+    return Number.isSafeInteger(timestamp) ? timestamp : undefined;
+}
 function stringifyToolText(value) {
     if (typeof value === "string")
         return value.trim();
@@ -269,7 +275,7 @@ export function codexToolEventFromItem(item, fallbackStatus = "completed") {
 export function codexTurnToHistoricalEvents(turn) {
     const record = recordFrom(turn);
     const turnId = typeof record.id === "string" ? record.id : randomUUID();
-    const turnTimestamp = timestampMs(recordFrom(turn).createdAt ?? recordFrom(turn).timestamp ?? recordFrom(turn).updatedAt);
+    const turnTimestamp = timestampMs(recordFrom(turn).createdAt ?? recordFrom(turn).timestamp ?? recordFrom(turn).updatedAt) ?? uuidV7TimestampMs(turnId);
     const events = [];
     for (const item of Array.isArray(record.items) ? record.items : []) {
         const itemRecord = recordFrom(item);
@@ -594,7 +600,7 @@ function parseCodexRolloutEvents(records) {
             turnIndex += 1;
             stableTurnId = `turn_${turnIndex}`;
         }
-        const occurredAt = timestampMs(record.timestamp ?? payload.createdAt ?? payload.updatedAt);
+        const occurredAt = timestampMs(record.timestamp ?? payload.createdAt ?? payload.updatedAt) ?? uuidV7TimestampMs(stableTurnId);
         if (record.type === "event_msg" && payloadType === "user_message") {
             const text = stringField(payload, "message")?.trim();
             if (text)

package/packages/runtime-cli/dist/codex-protocol.d.ts

@@ -1,6 +1,6 @@
 import { type RuntimePermissionMode } from "./permissions.js";
 export declare function normalizeCodexPermissionMode(mode?: RuntimePermissionMode): RuntimePermissionMode;
-export declare function codexThreadStartParams(cwd: string, permissionMode: RuntimePermissionMode): Record<string, unknown>;
-export declare function codexThreadResumeParams(threadId: string, cwd: string, permissionMode: RuntimePermissionMode): Record<string, unknown>;
+export declare function codexThreadStartParams(cwd: string, permissionMode: RuntimePermissionMode, model?: string): Record<string, unknown>;
+export declare function codexThreadResumeParams(threadId: string, cwd: string, permissionMode: RuntimePermissionMode, model?: string): Record<string, unknown>;
 export declare function codexTurnStartParams(threadId: string, cwd: string, text: string, permissionMode: RuntimePermissionMode): Record<string, unknown>;
 //# sourceMappingURL=codex-protocol.d.ts.map