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

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

@@ -2,9 +2,9 @@ import { codexApprovalPolicy, codexSandbox } from "./permissions.js";
 export function normalizeCodexPermissionMode(mode) {
     return mode ?? "approve-reads";
 }
-export function codexThreadStartParams(cwd, permissionMode) {
+export function codexThreadStartParams(cwd, permissionMode, model) {
     return {
-        model: null,
+        model: model || null,
         modelProvider: null,
         profile: null,
         cwd,
@@ -19,11 +19,11 @@ export function codexThreadStartParams(cwd, permissionMode) {
         persistExtendedHistory: true,
     };
 }
-export function codexThreadResumeParams(threadId, cwd, permissionMode) {
+export function codexThreadResumeParams(threadId, cwd, permissionMode, model) {
     return {
         threadId,
         cwd,
-        model: null,
+        model: model || null,
         modelProvider: null,
         approvalPolicy: codexApprovalPolicy(permissionMode),
         sandbox: codexSandbox(permissionMode),

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

@@ -1,4 +1,4 @@
-import type { RuntimeHistoricalSessionPage } from "@happy-elves/runtime";
+import type { RuntimeHistoricalSessionPage } from "../../runtime/dist/index.js";
 export type HistoricalSessionSource = {
     id: string;
     load(cursor: string | undefined, limit: number): Promise<RuntimeHistoricalSessionPage>;

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

@@ -1,4 +1,4 @@
-import type { HappyElvesRuntime } from "@happy-elves/runtime";
+import type { HappyElvesRuntime } from "../../runtime/dist/index.js";
 export { resolveCliCommand } from "./command-resolver.js";
 export { HistoryCursorStaleError, isHistoryCursorStaleError, mergeHistoricalSessionSources, type HistoricalSessionSource } from "./history-merge.js";
 export type CliRuntimeProviderOptions = {

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

@@ -73,8 +73,8 @@ export function createCliRuntimeProvider(options) {
         },
         listAgents() {
             return [
-                { id: "codex", label: "Codex" },
-                { id: "claude", label: "Claude Code" },
+                { id: "codex", label: "Codex", ...agentModelsFromEnv("HAPPY_ELVES_CODEX") },
+                { id: "claude", label: "Claude Code", ...agentModelsFromEnv("HAPPY_ELVES_CLAUDE") },
             ];
         },
         async ensureSession(input) {
@@ -95,8 +95,49 @@ export function createCliRuntimeProvider(options) {
                 return await readCodexHistoricalEvents(codexCommand, cwd, input.runtimeSessionId);
             return [];
         },
+        async inspectTurn(input) {
+            assertNotExternalProviderHandle(input.handle);
+            const agent = input.handle.runtimeSessionName;
+            if (agent !== "codex" && agent !== "claude") {
+                return {
+                    status: "uninspectable",
+                    reason: `CLI runtime cannot inspect ${agent || "unknown"} sessions`,
+                    evidence: "unsupported-agent",
+                };
+            }
+            const runtimeSessionId = input.handle.backendSessionId;
+            if (!runtimeSessionId) {
+                return {
+                    status: "uninspectable",
+                    reason: "Runtime handle is missing backendSessionId",
+                    evidence: "missing-backend-session-id",
+                };
+            }
+            const cwd = input.handle.cwd || options.cwd;
+            try {
+                const events = agent === "claude"
+                    ? await readClaudeHistoricalEvents(cwd, runtimeSessionId)
+                    : await readCodexHistoricalEvents(codexCommand, cwd, runtimeSessionId);
+                return inspectHistoricalEvents(events, {
+                    turnId: input.turnId,
+                    providerTurnId: input.providerTurnId,
+                    fallbackProviderTurnId: runtimeSessionId,
+                });
+            }
+            catch (error) {
+                return {
+                    status: "unknown",
+                    providerTurnId: input.providerTurnId ?? runtimeSessionId,
+                    reason: error instanceof Error ? error.message : String(error),
+                    evidence: "provider-history-error",
+                };
+            }
+        },
         startTurn(input) {
             assertNotExternalProviderHandle(input.handle);
+            if (input.attachments && input.attachments.length > 0) {
+                throw new Error("CLI runtime does not support binary prompt attachments yet. Text attachments are inlined before runtime start; use an external provider with attachment support for images or binary files.");
+            }
             const session = sessions.get(input.handle.sessionKey);
             if (!session)
                 throw new Error(`Runtime session is not loaded: ${input.handle.sessionKey}`);
@@ -109,6 +150,7 @@ export function createCliRuntimeProvider(options) {
                     timeoutMs: input.timeoutMs,
                     mode: input.mode,
                     permissionMode: input.permissionMode,
+                    model: input.model ?? input.handle.model,
                 });
             }
             const turn = startClaudeTurn({
@@ -118,6 +160,7 @@ export function createCliRuntimeProvider(options) {
                 requestId: input.requestId,
                 timeoutMs: input.timeoutMs,
                 permissionMode: input.permissionMode,
+                model: input.model ?? input.handle.model,
                 resume: session.claudeStarted === true,
                 name: session.pendingClaudeName,
             });
@@ -232,6 +275,45 @@ function assertNotExternalProviderHandle(handle) {
     const provider = handle.externalProviderId || handle.runtimeSessionName || "external";
     throw new Error(`External provider ${provider} is unavailable. Start the daemon with that provider enabled before continuing this session.`);
 }
+function inspectHistoricalEvents(events, input) {
+    const candidates = new Set([input.turnId, input.providerTurnId].filter((value) => typeof value === "string" && value.length > 0));
+    const providerTurnId = input.providerTurnId ?? input.fallbackProviderTurnId;
+    const relevant = candidates.size === 0
+        ? events
+        : events.filter((event) => {
+            if (candidates.has(event.turnId))
+                return true;
+            if (event.payload.type !== "done")
+                return false;
+            return Boolean((event.payload.currentHead && candidates.has(event.payload.currentHead)) ||
+                (event.payload.lastTurnId && candidates.has(event.payload.lastTurnId)));
+        });
+    if (relevant.length === 0) {
+        return {
+            status: "not_found",
+            providerTurnId,
+            reason: "No provider history event matched the requested turn",
+            evidence: "provider-history-empty",
+        };
+    }
+    const done = [...relevant].reverse().find((event) => event.payload.type === "done");
+    if (done?.payload.type === "done") {
+        return {
+            status: "terminal",
+            terminalStatus: done.payload.status,
+            currentHead: done.payload.currentHead,
+            lastTurnId: done.payload.lastTurnId ?? done.turnId,
+            providerTurnId: done.payload.lastTurnId ?? done.payload.currentHead ?? providerTurnId,
+            error: done.payload.error,
+            evidence: "provider-history-terminal",
+        };
+    }
+    return {
+        status: "active",
+        providerTurnId,
+        evidence: "provider-history-nonterminal-events",
+    };
+}
 function withLoadedSessionIds(page, loadedByBackendId) {
     return {
         ...page,
@@ -241,4 +323,28 @@ function withLoadedSessionIds(page, loadedByBackendId) {
         })),
     };
 }
+function agentModelsFromEnv(prefix) {
+    const defaultModel = process.env[`${prefix}_DEFAULT_MODEL`]?.trim() || undefined;
+    const models = modelOptionsFromEnv(process.env[`${prefix}_MODELS`]);
+    return {
+        ...(defaultModel ? { defaultModel } : {}),
+        ...(models.length > 0 ? { models } : {}),
+    };
+}
+function modelOptionsFromEnv(value) {
+    const seen = new Set();
+    return (value ?? "")
+        .split(",")
+        .map((raw) => raw.trim())
+        .filter(Boolean)
+        .flatMap((raw) => {
+        const [idPart, labelPart] = raw.split("=", 2);
+        const id = idPart.trim();
+        if (!id || seen.has(id))
+            return [];
+        seen.add(id);
+        const label = labelPart?.trim();
+        return [{ id, ...(label ? { label } : {}) }];
+    });
+}
 //# sourceMappingURL=index.js.map

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

@@ -1,4 +1,4 @@
-import type { RuntimePermissionMode } from "@happy-elves/runtime";
+import type { RuntimePermissionMode } from "../../runtime/dist/index.js";
 export type { RuntimePermissionMode };
 export declare function codexApprovalPolicy(mode?: RuntimePermissionMode): string;
 export declare function codexSandbox(mode?: RuntimePermissionMode): string;

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

@@ -1,4 +1,4 @@
-import type { RuntimeHandle, RuntimePermissionMode } from "@happy-elves/runtime";
+import type { RuntimeHandle, RuntimePermissionMode } from "../../runtime/dist/index.js";
 import { CodexAppServerSession } from "./codex-app-server.js";
 export type CliSession = {
     handle: RuntimeHandle;
@@ -17,6 +17,7 @@ export declare class CliSessionStore {
         sessionKey: string;
         agent: string;
         cwd?: string;
+        model?: string;
         resumeSessionId?: string;
         permissionMode?: RuntimePermissionMode;
         restartableEmptySession?: boolean;

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

@@ -7,6 +7,7 @@ function cliHandle(input) {
         runtimeSessionName: input.agent,
         cwd: input.cwd,
         backendSessionId: input.backendSessionId,
+        ...(input.model ? { model: input.model } : {}),
     };
 }
 export class CliSessionStore {
@@ -22,9 +23,9 @@ export class CliSessionStore {
         const cwd = input.cwd ?? this.input.cwd;
         const agent = cliAgent(input.agent);
         if (agent === "codex") {
-            return await this.createCodex(input.sessionKey, cwd, input.resumeSessionId, input.permissionMode, input.restartableEmptySession);
+            return await this.createCodex(input.sessionKey, cwd, input.resumeSessionId, input.permissionMode, input.model, input.restartableEmptySession);
         }
-        return this.createClaude(input.sessionKey, cwd, input.resumeSessionId);
+        return this.createClaude(input.sessionKey, cwd, input.resumeSessionId, input.model);
     }
     get(sessionKey) {
         return this.sessions.get(sessionKey);
@@ -61,23 +62,23 @@ export class CliSessionStore {
         this.sessions.set(sessionKey, session);
         return session;
     }
-    async createCodex(sessionKey, cwd, resumeSessionId, permissionMode, restartableEmptySession) {
+    async createCodex(sessionKey, cwd, resumeSessionId, permissionMode, model, restartableEmptySession) {
         const session = {
-            handle: cliHandle({ agent: "codex", backendSessionId: resumeSessionId, cwd, sessionKey }),
+            handle: cliHandle({ agent: "codex", backendSessionId: resumeSessionId, cwd, model, sessionKey }),
         };
         const codex = new CodexAppServerSession(this.input.codexCommand, cwd, resumeSessionId, (nextThreadId) => {
             session.handle.backendSessionId = nextThreadId;
-        }, Boolean(restartableEmptySession));
-        const threadId = await codex.ensure(permissionMode);
+        }, Boolean(restartableEmptySession), model);
+        const threadId = await codex.ensure(permissionMode, model);
         session.handle.backendSessionId = threadId;
         session.codex = codex;
         this.sessions.set(sessionKey, session);
         return session;
     }
-    createClaude(sessionKey, cwd, resumeSessionId) {
+    createClaude(sessionKey, cwd, resumeSessionId, model) {
         const sessionId = resumeSessionId ?? randomUUID();
         const session = {
-            handle: cliHandle({ agent: "claude", backendSessionId: sessionId, cwd, sessionKey }),
+            handle: cliHandle({ agent: "claude", backendSessionId: sessionId, cwd, model, sessionKey }),
             claudeStarted: Boolean(resumeSessionId),
         };
         this.sessions.set(sessionKey, session);

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

@@ -2,6 +2,8 @@ export * from "./crypto.js";
 export * from "./args.js";
 export * from "./ids.js";
 export * from "./protocol.js";
+export * from "./protocol-types.js";
 export * from "./session-name.js";
 export * from "./session-state.js";
+export * from "./session-tags.js";
 //# sourceMappingURL=index.d.ts.map

package/packages/shared/dist/index.js

@@ -2,6 +2,8 @@ export * from "./crypto.js";
 export * from "./args.js";
 export * from "./ids.js";
 export * from "./protocol.js";
+export * from "./protocol-types.js";
 export * from "./session-name.js";
 export * from "./session-state.js";
+export * from "./session-tags.js";
 //# sourceMappingURL=index.js.map