@cydm/happy-elves 0.1.0-beta.258 → 0.1.0-beta.260

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.258",
+  "version": "0.1.0-beta.260",
   "private": true,
   "type": "module"
 }

package/apps/daemon/dist/runtime/external-provider.js

@@ -169,6 +169,10 @@ export function createExternalAgentRuntimeProvider(options) {
     const clients = options.providers.map((config) => new ExternalProviderClient(config));
     const clientsByAgent = new Map();
     async function initialize() {
+        const fallback = options.fallback;
+        if (typeof fallback.initialize === "function") {
+            await fallback.initialize().catch(() => undefined);
+        }
         await Promise.all(clients.map(async (client) => {
             await client.initialize().catch(() => undefined);
             for (const agent of client.listAgents())
@@ -273,7 +277,11 @@ export function createExternalAgentRuntimeProvider(options) {
     return {
         initialize,
         diagnostics() {
-            return clients.map((client) => client.diagnostics());
+            const fallback = options.fallback;
+            const fallbackDiagnostics = typeof fallback.diagnostics === "function"
+                ? fallback.diagnostics()
+                : [];
+            return [...fallbackDiagnostics, ...clients.map((client) => client.diagnostics())];
         },
         dispose() {
             for (const client of clients)

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.258",
+  "version": "0.1.0-beta.260",
   "private": true,
   "type": "module"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.258",
+  "version": "0.1.0-beta.260",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {

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

@@ -1,4 +1,4 @@
-import type { RuntimePromptMode, RuntimeTurn } from "../../runtime/dist/index.js";
+import type { RuntimeModelOption, RuntimePromptMode, RuntimeTurn } from "../../runtime/dist/index.js";
 import type { RuntimePermissionMode } from "./permissions.js";
 export declare class CodexAppServerSession {
     private readonly command;
@@ -20,7 +20,12 @@ export declare class CodexAppServerSession {
     threadId: string | null;
     constructor(command: string, cwd: string, threadId?: string, onThreadIdChanged?: ((threadId: string) => void) | undefined, restartableEmptyThread?: boolean, initialModel?: string | undefined);
     ensure(permissionMode?: RuntimePermissionMode, model?: string): Promise<string>;
+    discoverRuntimeOptions(): Promise<{
+        defaultModel?: string;
+        models?: RuntimeModelOption[];
+    } | undefined>;
     private ensureCurrentPermission;
+    private loadAllModelListPages;
     private ensurePermission;
     private startNewThread;
     private canRestartEmptyThread;
@@ -56,4 +61,12 @@ export declare class CodexAppServerSession {
     private noteTurnActivity;
     private emptyCompletionFailure;
 }
+export declare function discoverCodexRuntimeOptions(input: {
+    command: string;
+    cwd: string;
+    timeoutMs?: number;
+}): Promise<{
+    defaultModel?: string;
+    models?: RuntimeModelOption[];
+} | undefined>;
 //# sourceMappingURL=codex-app-server.d.ts.map

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

@@ -33,9 +33,43 @@ export class CodexAppServerSession {
     async ensure(permissionMode, model) {
         return await this.ensurePermission(normalizeCodexPermissionMode(permissionMode), normalizeModel(model ?? this.initialModel));
     }
+    async discoverRuntimeOptions() {
+        if (!this.rpc)
+            await this.connect();
+        return codexRuntimeOptionsFromModelList(await this.loadAllModelListPages());
+    }
     async ensureCurrentPermission() {
         return await this.ensurePermission(normalizeCodexPermissionMode(this.appliedPermissionMode), this.appliedModel ?? normalizeModel(this.initialModel));
     }
+    async loadAllModelListPages() {
+        const models = [];
+        const seenModelIds = new Set();
+        const seenCursors = new Set();
+        let cursor;
+        for (let pageCount = 0; pageCount < CODEX_MODEL_LIST_PAGE_SAFETY_LIMIT; pageCount += 1) {
+            const result = await this.request("model/list", {
+                limit: CODEX_MODEL_LIST_PAGE_LIMIT,
+                ...(cursor !== undefined ? { cursor } : {}),
+            });
+            for (const model of codexModelsFromModelList(result)) {
+                const id = codexModelId(model);
+                if (id && seenModelIds.has(id))
+                    continue;
+                if (id)
+                    seenModelIds.add(id);
+                models.push(model);
+            }
+            const nextCursor = codexModelListNextCursor(result);
+            if (nextCursor === undefined)
+                return { data: models };
+            if (seenCursors.has(nextCursor)) {
+                throw new Error(`Codex model/list returned repeated cursor ${JSON.stringify(nextCursor)}`);
+            }
+            seenCursors.add(nextCursor);
+            cursor = nextCursor;
+        }
+        throw new Error(`Codex model/list exceeded the ${CODEX_MODEL_LIST_PAGE_SAFETY_LIMIT} page safety limit`);
+    }
     async ensurePermission(permissionMode, model) {
         const hadProcess = Boolean(this.rpc);
         if (!this.rpc)
@@ -349,6 +383,27 @@ export class CodexAppServerSession {
         return `Codex turn completed without assistant output after runtime errors${detail ? `: ${detail}` : ""}`;
     }
 }
+const CODEX_MODEL_LIST_PAGE_LIMIT = 100;
+const CODEX_MODEL_LIST_PAGE_SAFETY_LIMIT = 100;
+const CODEX_PROVIDER_DISCOVERY_TIMEOUT_MS = 20_000;
+export async function discoverCodexRuntimeOptions(input) {
+    const discovery = new CodexAppServerSession(input.command, input.cwd);
+    const timeoutMs = Math.max(1, input.timeoutMs ?? CODEX_PROVIDER_DISCOVERY_TIMEOUT_MS);
+    let timeout;
+    try {
+        return await Promise.race([
+            discovery.discoverRuntimeOptions(),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new Error(`Codex provider model discovery timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        await discovery.close();
+    }
+}
 function codexStderrMessage(text) {
     try {
         const parsed = JSON.parse(text);
@@ -415,4 +470,49 @@ function numberField(record, ...keys) {
 function normalizeModel(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function codexModelsFromModelList(value) {
+    const record = recordFrom(value);
+    return Array.isArray(record.models)
+        ? record.models
+        : Array.isArray(record.items)
+            ? record.items
+            : Array.isArray(record.data)
+                ? record.data
+                : [];
+}
+function codexModelId(value) {
+    return stringField(recordFrom(value), "id", "key", "name");
+}
+function codexModelListNextCursor(value) {
+    const nextCursor = recordFrom(value).nextCursor;
+    if (nextCursor === undefined || nextCursor === null)
+        return undefined;
+    if (typeof nextCursor !== "string" || nextCursor.length === 0) {
+        throw new Error("Codex model/list returned an invalid nextCursor");
+    }
+    return nextCursor;
+}
+function codexRuntimeOptionsFromModelList(value) {
+    const rawModels = codexModelsFromModelList(value);
+    const seen = new Set();
+    const models = rawModels.flatMap((item) => {
+        const model = recordFrom(item);
+        const id = codexModelId(model)?.trim();
+        if (!id || seen.has(id))
+            return [];
+        seen.add(id);
+        const label = stringField(model, "label", "displayName", "name");
+        return [{ id, ...(label ? { label } : {}) }];
+    });
+    if (models.length === 0)
+        return undefined;
+    const defaultModel = rawModels
+        .map((item) => recordFrom(item))
+        .find((item) => item.isDefault === true);
+    const defaultModelId = defaultModel ? codexModelId(defaultModel)?.trim() : undefined;
+    return {
+        ...(defaultModelId ? { defaultModel: defaultModelId } : {}),
+        models,
+    };
+}
 //# sourceMappingURL=codex-app-server.js.map

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

@@ -5,7 +5,12 @@ export type CliRuntimeProviderOptions = {
     cwd: string;
     stateDir: string;
     codexCommand?: string;
+    /** Maximum total time for the provider-level Codex catalog probe. */
+    codexDiscoveryTimeoutMs?: number;
     claudeCommand?: string;
 };
-export declare function createCliRuntimeProvider(options: CliRuntimeProviderOptions): HappyElvesRuntime;
+export declare function createCliRuntimeProvider(options: CliRuntimeProviderOptions): HappyElvesRuntime & {
+    initialize(): Promise<void>;
+    diagnostics(): Array<Record<string, unknown>>;
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import os from "node:os";
 import { readClaudeHistoricalEvents, readClaudeHistoricalSessionPage } from "./claude-history.js";
 import { renameClaudeSession } from "./claude-rename.js";
+import { discoverCodexRuntimeOptions } from "./codex-app-server.js";
 import { forkAndTruncateClaudeSession, forkClaudeSession } from "./claude-session-store.js";
 import { startClaudeTurn } from "./claude-turn.js";
 import { readCodexCanonicalHistoricalSessionPage, readCodexHistoricalEvents } from "./codex-history.js";
@@ -13,6 +14,15 @@ export { HistoryCursorStaleError, isHistoryCursorStaleError, mergeHistoricalSess
 export function createCliRuntimeProvider(options) {
     const codexCommand = options.codexCommand ?? process.env.HAPPY_ELVES_CODEX_COMMAND ?? "codex";
     const claudeCommand = options.claudeCommand ?? process.env.HAPPY_ELVES_CLAUDE_COMMAND ?? "claude";
+    let codexOptions = codexAgentModels();
+    let codexModelDiscovery = {
+        provider: "cli",
+        component: "codex-model-discovery",
+        status: "not-run",
+        source: codexOptions.models && codexOptions.models.length > 0 ? "fallback" : undefined,
+        modelCount: codexOptions.models?.length ?? 0,
+        ...(codexOptions.defaultModel ? { defaultModel: codexOptions.defaultModel } : {}),
+    };
     const sessions = new CliSessionStore({ cwd: options.cwd, codexCommand });
     const historySnapshotDir = path.join(options.stateDir, "history-snapshots");
     async function listHistoricalSessionPage(input) {
@@ -66,6 +76,75 @@ export function createCliRuntimeProvider(options) {
         }), loadedByBackendId);
     }
     return {
+        async initialize() {
+            const configured = agentModelsFromEnv("HAPPY_ELVES_CODEX");
+            if (configured.models && configured.models.length > 0) {
+                codexOptions = configured;
+                codexModelDiscovery = {
+                    provider: "cli",
+                    component: "codex-model-discovery",
+                    status: "configured",
+                    source: "env",
+                    modelCount: configured.models.length,
+                    ...(configured.defaultModel ? { defaultModel: configured.defaultModel } : {}),
+                };
+                return;
+            }
+            const startedAt = Date.now();
+            const discovered = await discoverCodexRuntimeOptions({
+                command: codexCommand,
+                cwd: options.cwd,
+                timeoutMs: options.codexDiscoveryTimeoutMs,
+            }).catch((error) => {
+                codexModelDiscovery = {
+                    provider: "cli",
+                    component: "codex-model-discovery",
+                    status: "failed",
+                    source: "provider",
+                    elapsedMs: Date.now() - startedAt,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+                return undefined;
+            });
+            if (discovered?.models && discovered.models.length > 0) {
+                codexOptions = {
+                    ...(configured.defaultModel ? { defaultModel: configured.defaultModel } : discovered.defaultModel ? { defaultModel: discovered.defaultModel } : {}),
+                    models: discovered.models,
+                };
+                codexModelDiscovery = {
+                    provider: "cli",
+                    component: "codex-model-discovery",
+                    status: "ok",
+                    source: "provider",
+                    elapsedMs: Date.now() - startedAt,
+                    modelCount: discovered.models.length,
+                    ...(codexOptions.defaultModel ? { defaultModel: codexOptions.defaultModel } : {}),
+                };
+                return;
+            }
+            codexOptions = codexAgentModels();
+            if (codexModelDiscovery.status !== "failed") {
+                codexModelDiscovery = {
+                    provider: "cli",
+                    component: "codex-model-discovery",
+                    status: "failed",
+                    source: "provider",
+                    elapsedMs: Date.now() - startedAt,
+                    error: "Codex provider model/list returned no models",
+                };
+            }
+            if (codexOptions.models && codexOptions.models.length > 0) {
+                codexModelDiscovery = {
+                    ...codexModelDiscovery,
+                    source: "fallback",
+                    modelCount: codexOptions.models.length,
+                    ...(codexOptions.defaultModel ? { defaultModel: codexOptions.defaultModel } : {}),
+                };
+            }
+        },
+        diagnostics() {
+            return [codexModelDiscovery];
+        },
         getCapabilities() {
             return {
                 provider: "cli",
@@ -75,7 +154,7 @@ export function createCliRuntimeProvider(options) {
         },
         listAgents() {
             return [
-                { id: "codex", label: "Codex", ...codexAgentModels() },
+                { id: "codex", label: "Codex", ...codexOptions },
                 { id: "claude", label: "Claude Code", ...agentModelsFromEnv("HAPPY_ELVES_CLAUDE") },
             ];
         },