@cydm/happy-elves 0.1.0-beta.248 → 0.1.0-beta.254

package/apps/cli/dist/commands/session.js

@@ -353,8 +353,9 @@ export async function handleSession({ domain, action, positional, flags }) {
         const requestedRuntimeName = typeof flags.name === "string" ? flags.name : undefined;
         const name = "main";
         const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const model = typeof flags.model === "string" && flags.model.trim() ? flags.model.trim() : undefined;
         const client = await makeClient();
-        const result = await client.createSession({ machineId, agent, cwd, name, runtimeName: requestedRuntimeName, permissionMode });
+        const result = await client.createSession({ machineId, agent, cwd, name, runtimeName: requestedRuntimeName, permissionMode, model });
         const session = result.sessionId ? await client.getSession(result.sessionId) : undefined;
         const projectedSession = session
             ? wantsVerbose(flags)

package/apps/cli/dist/commands/turn.js

@@ -201,6 +201,8 @@ export async function handleTurn({ domain, action, positional, flags }) {
                 : "";
         if (!continuation.trim())
             throw new CliError("Missing --text or --text-file", "MISSING_ARGUMENT");
+        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const model = typeof flags.model === "string" && flags.model.trim() ? flags.model.trim() : undefined;
         const sourceSession = await requireProjectedSession(client, sessionId, "turn.recover");
         const sourceMetadata = await client.decodeSessionMetadata(sourceSession);
         const sourceName = sourceMetadata.name ?? sourceSession.name;
@@ -229,7 +231,8 @@ export async function handleTurn({ domain, action, positional, flags }) {
                 cwd: sourceMetadata.cwd ?? sourceSession.cwd,
                 name: recoveryName,
                 createdFrom: "turn.recover",
-                permissionMode: parsePermissionMode(flags["permission-mode"] ?? flags.permission),
+                permissionMode,
+                model,
             });
             if (!created.sessionId)
                 throw new CliError("Recovery session create was acknowledged without sessionId", "RELAY_RESPONSE_INVALID");
@@ -237,7 +240,6 @@ export async function handleTurn({ domain, action, positional, flags }) {
             promptText = recoveryPromptWithContext(turns, inputTurnId, continuation);
         }
         await client.wait(recoverySessionId, { timeoutMs: 120_000 });
-        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
         const wait = flags.detach !== true && flags["no-wait"] !== true;
         const memoryMode = parseMemoryModeFlag(flags["memory-mode"] ?? flags.memory) ?? "readonly";
         const recoverySession = await client.getSession(recoverySessionId);
@@ -250,6 +252,7 @@ export async function handleTurn({ domain, action, positional, flags }) {
             wait,
             permissionMode,
             memoryMode,
+            model,
             ...(memoryProject ? { memoryProjectKey: memoryProject } : {}),
             memoryTopN: 3,
             waitTimeoutMs: parseDurationMs(flags.timeout, DEFAULT_COMMAND_TIMEOUT_MS),
@@ -289,6 +292,7 @@ export async function handleTurn({ domain, action, positional, flags }) {
         const ackTimeoutMs = 15_000;
         const inactivityTimeoutMs = parseDurationMs(flags["inactivity-timeout"] ?? flags["runtime-timeout"], DEFAULT_COMMAND_TIMEOUT_MS);
         const memoryMode = parseMemoryModeFlag(flags["memory-mode"] ?? flags.memory) ?? "readonly";
+        const model = typeof flags.model === "string" && flags.model.trim() ? flags.model.trim() : undefined;
         const session = await client.getSession(sessionId);
         const memoryProject = typeof flags["memory-project"] === "string"
             ? flags["memory-project"]
@@ -302,6 +306,7 @@ export async function handleTurn({ domain, action, positional, flags }) {
             wait,
             permissionMode,
             memoryMode,
+            model,
             ...(memoryProject ? { memoryProjectKey: memoryProject } : {}),
             memoryTopN,
             waitTimeoutMs: watchTimeoutMs,

package/apps/cli/package.json

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

package/apps/daemon/dist/gateway/runtime.js

@@ -294,6 +294,7 @@ async function createGatewayMapping(config, channel, externalConversationId, cre
         agent: channel.defaultAgent,
         cwd: channel.targetCwd,
         name: `Gateway ${channel.type}: ${externalConversationId}`,
+        ...(channel.defaultModel ? { model: channel.defaultModel } : {}),
         encryptedMetadata: await encryptJson(config.accountSecret, `gateway:create:${createRequestId}`, {
             createdFrom: "gateway",
             gateway: {
@@ -353,6 +354,7 @@ async function admitGatewayPromptNow(config, channel, input) {
                 text: input.text,
             }),
             permissionMode: "approve-reads",
+            ...(channel.defaultModel ? { model: channel.defaultModel } : {}),
         });
         const turnId = sent.turnId ?? input.turnId;
         const lastAdmitted = {

package/apps/daemon/dist/relay/admission.d.ts

@@ -15,6 +15,7 @@ export declare function admitMachineCreateSession(config: DaemonConfig, input: {
     agent: string;
     cwd: string;
     name: string;
+    model?: string;
     encryptedMetadata?: EncryptedEnvelope;
 }): Promise<MachineAdmissionAck>;
 export declare function admitMachinePrompt(config: DaemonConfig, input: {
@@ -24,5 +25,6 @@ export declare function admitMachinePrompt(config: DaemonConfig, input: {
     encryptedPrompt: EncryptedEnvelope;
     encryptedMemoryOptions?: EncryptedEnvelope;
     permissionMode?: PermissionMode;
+    model?: string;
     timeoutMs?: number;
 }): Promise<MachineAdmissionAck>;

package/apps/daemon/dist/relay/connection.js

@@ -7,7 +7,7 @@ import { tickSchedules } from "../schedule/runner.js";
 import { handleListDirectory } from "../session/directory.js";
 import { handlePreviewFile } from "../session/file-preview.js";
 import { handleClose, handleCreateSession, handleImportHistoricalSession, handleListHistoricalSessions, handleResume } from "../session/lifecycle.js";
-import { handleCancel, handlePrompt } from "../session/prompt.js";
+import { handleCancel, handleOptionResponse, handlePrompt } from "../session/prompt.js";
 import { handleFork, handleRename, handleRewind } from "../session/primitives.js";
 import { handleReconcileTurn } from "../session/reconcile.js";
 import { parseRelayMessage, relayWsUrl } from "../relay-http.js";
@@ -87,6 +87,10 @@ async function handleServerMessage(ws, config, message) {
         await handleCancel(ws, config, message);
         return;
     }
+    if (message.type === "machine:optionResponse") {
+        await handleOptionResponse(ws, config, message);
+        return;
+    }
     if (message.type === "machine:reconcileTurn") {
         await handleReconcileTurn(ws, config, message);
         return;

package/apps/daemon/dist/relay/register.js

@@ -22,6 +22,8 @@ function agentProfileForRegister(agent) {
         id: agent.id,
         label: agent.label,
         ...(agent.command ? { command: agent.command } : {}),
+        ...(agent.defaultModel ? { defaultModel: agent.defaultModel } : {}),
+        ...(agent.models && agent.models.length > 0 ? { models: agent.models } : {}),
         ...(agent.historyModel ? { historyModel: agent.historyModel } : {}),
         ...(agent.sessionPrimitives ? { sessionPrimitives: runtimeAgentPrimitives(agent.sessionPrimitives) } : {}),
     };

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

@@ -226,6 +226,7 @@ export function createExternalAgentRuntimeProvider(options) {
             agentSessionId: handle.sessionId,
             externalProviderId: handle.provider,
             externalHandle: handle,
+            ...(handle.model ? { model: handle.model } : {}),
         };
     }
     function sdkHandle(handle) {
@@ -282,20 +283,26 @@ export function createExternalAgentRuntimeProvider(options) {
             return options.fallback.getCapabilities();
         },
         listAgents() {
-            const externalAgents = clients.flatMap((client) => client.listAgents()).map((agent) => ({
-                id: agent.id,
-                label: agent.label,
-                command: agent.command,
-                historyModel: normalizeHistoryModel(agent.historyModel),
-                sessionPrimitives: agent.capabilities?.sessionPrimitives
-                    ? {
-                        resume: fromSdkPrimitive(agent.capabilities.sessionPrimitives.resume),
-                        rewind: fromSdkPrimitive(agent.capabilities.sessionPrimitives.rewind),
-                        fork: fromSdkPrimitive(agent.capabilities.sessionPrimitives.fork),
-                        rename: agent.capabilities.sessionPrimitives.rename ? fromSdkPrimitive(agent.capabilities.sessionPrimitives.rename) : "unsupported",
-                    }
-                    : undefined,
-            }));
+            const externalAgents = clients.flatMap((client) => client.listAgents()).map((agent) => {
+                const defaultModel = normalizedModelId(agent.defaultModel);
+                const models = normalizeModelOptions(agent.models);
+                return {
+                    id: agent.id,
+                    label: agent.label,
+                    command: agent.command,
+                    ...(defaultModel ? { defaultModel } : {}),
+                    ...(models ? { models } : {}),
+                    historyModel: normalizeHistoryModel(agent.historyModel),
+                    sessionPrimitives: agent.capabilities?.sessionPrimitives
+                        ? {
+                            resume: fromSdkPrimitive(agent.capabilities.sessionPrimitives.resume),
+                            rewind: fromSdkPrimitive(agent.capabilities.sessionPrimitives.rewind),
+                            fork: fromSdkPrimitive(agent.capabilities.sessionPrimitives.fork),
+                            rename: agent.capabilities.sessionPrimitives.rename ? fromSdkPrimitive(agent.capabilities.sessionPrimitives.rename) : "unsupported",
+                        }
+                        : undefined,
+                };
+            });
             const agentsById = new Map();
             for (const agent of externalAgents)
                 agentsById.set(agent.id, agent);
@@ -318,6 +325,7 @@ export function createExternalAgentRuntimeProvider(options) {
                 ...(input.resumeHandle ? { resumeHandle: sdkHandle(input.resumeHandle) } : {}),
                 cwd: input.cwd,
                 permissionMode: input.permissionMode,
+                model: input.model,
                 restartableEmptySession: input.restartableEmptySession,
             });
             return toRuntimeHandle(input.sessionKey, handle, input.cwd);
@@ -466,6 +474,7 @@ export function createExternalAgentRuntimeProvider(options) {
                 mode: input.mode,
                 permissionMode: input.permissionMode,
                 requestId: input.requestId,
+                model: input.model ?? input.handle.model,
             });
         },
         cancel(input) {
@@ -523,6 +532,31 @@ function emptyPageUnlessCursorStale(error) {
         throw error;
     return { sessions: [] };
 }
+function normalizedModelId(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function normalizeModelOptions(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const seen = new Set();
+    const models = value.flatMap((item) => {
+        if (!isRecord(item))
+            return [];
+        const id = normalizedModelId(item.id);
+        if (!id || seen.has(id))
+            return [];
+        seen.add(id);
+        const label = normalizedModelId(item.label);
+        const reason = normalizedModelId(item.reason);
+        return [{
+                id,
+                ...(label ? { label } : {}),
+                ...(item.unavailable === true ? { unavailable: true } : {}),
+                ...(reason ? { reason } : {}),
+            }];
+    });
+    return models.length > 0 ? models : undefined;
+}
 class ExternalProviderClient {
     config;
     id;
@@ -653,6 +687,14 @@ class ExternalProviderClient {
             cancel: async (input) => {
                 await this.request("cancel", { handle: params.handle, reason: input?.reason });
             },
+            respondOption: async (input) => {
+                await this.request("respondOption", {
+                    handle: params.handle,
+                    optionRequestId: input.optionRequestId,
+                    ...(input.selectedOptionId ? { selectedOptionId: input.selectedOptionId } : {}),
+                    ...(input.text ? { text: input.text } : {}),
+                });
+            },
             closeStream: async (input) => {
                 await this.request("cancel", { handle: params.handle, reason: input?.reason ?? "stream closed" });
             },

package/apps/daemon/dist/session/events.js

@@ -147,6 +147,16 @@ export function runtimeEventToPayload(event) {
             title: event.title,
         };
     }
+    if (event.type === "option_request") {
+        return {
+            type: "option_request",
+            optionRequestId: event.optionRequestId,
+            ...(event.title ? { title: event.title } : {}),
+            message: event.message,
+            options: event.options,
+            ...(event.allowFreeText ? { allowFreeText: true } : {}),
+        };
+    }
     if (event.type === "status") {
         if (typeof event.used === "number" && Number.isFinite(event.used)) {
             return {

package/apps/daemon/dist/session/lifecycle.js

@@ -15,6 +15,7 @@ export async function handleCreateSession(ws, config, command) {
     const cwd = command.cwd || process.cwd();
     try {
         const metadata = await commandSessionMetadata(config, command.encryptedMetadata);
+        const model = modelFromCommand(command.model ?? metadata?.model);
         const runtime = getRuntime(cwd);
         let handle = await runtime.ensureSession({
             sessionKey: command.sessionId,
@@ -22,6 +23,7 @@ export async function handleCreateSession(ws, config, command) {
             mode: "persistent",
             cwd,
             permissionMode: metadata?.permissionMode,
+            model,
         });
         let providerName;
         const requestedRuntimeName = metadata?.requestedRuntimeName;
@@ -39,6 +41,7 @@ export async function handleCreateSession(ws, config, command) {
             agent: command.agent,
             cwd,
             name: providerName ?? command.name,
+            ...(model ? { model } : {}),
             handle,
         };
         sessions.set(command.sessionId, state);
@@ -53,6 +56,7 @@ export async function handleCreateSession(ws, config, command) {
                 agent: command.agent,
                 cwd,
                 name: state.name,
+                model,
                 requestedRuntimeName: requestedRuntimeName ? true : undefined,
                 runtime: {
                     acpxRecordId: handle.acpxRecordId,
@@ -78,6 +82,9 @@ export async function handleCreateSession(ws, config, command) {
         await sendCommandResponse(ws, createSessionFailureResponse(command, error));
     }
 }
+function modelFromCommand(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 export async function handleImportHistoricalSession(ws, config, command) {
     if (command.type !== "machine:importHistoricalSession")
         return;

package/apps/daemon/dist/session/metadata.d.ts

@@ -1,6 +1,6 @@
 import { type EncryptedEnvelope, type MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig, SessionFallback, SessionMetadata, SessionState } from "../types.js";
-export declare function encryptedSessionMetadata(config: DaemonConfig, sessionId: string, state: Pick<SessionState, "agent" | "cwd" | "name" | "handle">, extra: Record<string, unknown>): Promise<EncryptedEnvelope>;
+export declare function encryptedSessionMetadata(config: DaemonConfig, sessionId: string, state: Pick<SessionState, "agent" | "cwd" | "name" | "handle" | "model">, extra: Record<string, unknown>): Promise<EncryptedEnvelope>;
 export declare function commandSessionMetadata(config: DaemonConfig, encryptedMetadata?: EncryptedEnvelope): Promise<SessionMetadata | undefined>;
 export declare function sessionFallbackFromCommand(config: DaemonConfig, command: Extract<MachineCommand, {
     type: "machine:prompt" | "machine:resume" | "machine:rewind" | "machine:fork" | "machine:renameSession" | "machine:close";

package/apps/daemon/dist/session/metadata.js

@@ -4,6 +4,7 @@ export function encryptedSessionMetadata(config, sessionId, state, extra) {
         agent: state.agent,
         cwd: state.cwd,
         name: state.name,
+        ...(state.model ? { model: state.model } : {}),
         runtime: {
             backend: state.handle.backend,
             runtimeSessionName: state.handle.runtimeSessionName,
@@ -36,6 +37,7 @@ export async function sessionFallbackFromCommand(config, command) {
             agent: metadata.agent ?? "codex",
             cwd: metadata.cwd || process.cwd(),
             name: metadata.name ?? command.sessionId,
+            ...(typeof metadata.model === "string" && metadata.model.trim() ? { model: metadata.model.trim() } : {}),
             emptyRuntimeSession: metadata.emptyRuntimeSession === true,
             historicalBackfill: historicalBackfillStateFromMetadata(metadata),
             runtime: metadata.runtime,

package/apps/daemon/dist/session/prompt.d.ts

@@ -3,8 +3,9 @@ import type { DaemonConfig } from "../types.js";
 type PromptCommand = Extract<MachineCommand, {
     type: "machine:prompt";
 }>;
-type PromptExecutionPhase = "decrypt-prompt" | "decrypt-memory-options" | "prepare-memory-context" | "emit-submitted" | "emit-memory-status" | "start-turn" | "attach-turn" | "audit-turn-start" | "stream-turn" | "await-turn-result" | "write-memory" | "refresh-runtime-metadata" | "emit-terminal" | "refresh-authoritative-transcript" | "send-turn-done" | "terminal-hooks";
+type PromptExecutionPhase = "decrypt-prompt" | "prepare-attachments" | "decrypt-memory-options" | "prepare-memory-context" | "emit-submitted" | "emit-memory-status" | "start-turn" | "attach-turn" | "audit-turn-start" | "stream-turn" | "await-turn-result" | "write-memory" | "refresh-runtime-metadata" | "emit-terminal" | "refresh-authoritative-transcript" | "send-turn-done" | "terminal-hooks";
 export declare function handlePrompt(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export declare function handleOptionResponse(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function promptFailureResponse(command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
     type: "machine:error";
     requestId: string;

package/apps/daemon/dist/session/prompt.js

@@ -56,12 +56,15 @@ export async function handlePrompt(ws, config, command) {
     try {
         const prompt = await decryptJson(config.accountSecret, command.encryptedPrompt);
         const rawText = prompt.type === "user_prompt" ? prompt.text : JSON.stringify(prompt);
+        const promptAttachments = prompt.type === "user_prompt" ? normalizePromptAttachments(prompt.attachments) : [];
+        phase = "prepare-attachments";
+        const preparedPrompt = preparePromptAttachments(rawText, promptAttachments);
         phase = "decrypt-memory-options";
         const memoryOptions = await decryptMemoryOptions(config, command);
         phase = "prepare-memory-context";
         const memoryContext = memoryOptions
-            ? await prepareMemoryContext(memoryOptions, rawText)
-            : { text: rawText, used: [], options: undefined };
+            ? await prepareMemoryContext(memoryOptions, preparedPrompt.text)
+            : { text: preparedPrompt.text, used: [], options: undefined };
         const text = memoryContext.text;
         phase = "emit-submitted";
         await emitEvent(ws, config, command.sessionId, command.turnId, {
@@ -95,12 +98,15 @@ export async function handlePrompt(ws, config, command) {
             }
         }
         const previousBackendSessionId = session.handle.backendSessionId;
+        const model = modelFromCommand(command.model) ?? session.model ?? session.handle.model;
         phase = "start-turn";
         const turn = getRuntime(session.cwd).startTurn({
             handle: session.handle,
             text,
             mode: "prompt",
             permissionMode: command.permissionMode,
+            model,
+            attachments: preparedPrompt.runtimeAttachments,
             requestId: command.requestId,
             timeoutMs: command.timeoutMs,
         });
@@ -120,7 +126,10 @@ export async function handlePrompt(ws, config, command) {
                 turnId: command.turnId,
                 promptChars: text.length,
                 rawPromptChars: rawText.length,
+                attachmentCount: promptAttachments.length,
+                runtimeAttachmentCount: preparedPrompt.runtimeAttachments.length,
                 permissionMode: command.permissionMode ?? "approve-reads",
+                model,
                 memoryMode: memoryOptions?.mode,
                 usedMemories: memoryContext.used.map((item) => ({ path: item.path, citation: item.citation })),
             },
@@ -258,6 +267,53 @@ export async function handlePrompt(ws, config, command) {
         releasePromptTurn();
     }
 }
+export async function handleOptionResponse(ws, config, command) {
+    if (command.type !== "machine:optionResponse")
+        return;
+    const activeTurnId = sessionTurns.activeTurnId(command.sessionId);
+    const activeTurn = sessionTurns.activeTurn(command.sessionId);
+    if (!activeTurn || activeTurnId !== command.turnId) {
+        await sendCommandResponse(ws, {
+            type: "machine:error",
+            requestId: command.requestId,
+            sessionId: command.sessionId,
+            code: "OPTION_REQUEST_NOT_ACTIVE",
+            message: "No matching active turn is waiting for this option response",
+        });
+        return;
+    }
+    if (!activeTurn.respondOption) {
+        await sendCommandResponse(ws, {
+            type: "machine:error",
+            requestId: command.requestId,
+            sessionId: command.sessionId,
+            code: "OPTION_RESPONSE_UNSUPPORTED",
+            message: "This runtime does not support Happy Elves option responses",
+        });
+        return;
+    }
+    await activeTurn.respondOption({
+        optionRequestId: command.optionRequestId,
+        ...(command.selectedOptionId ? { selectedOptionId: command.selectedOptionId } : {}),
+        ...(command.text ? { text: command.text } : {}),
+    });
+    await emitEvent(ws, config, command.sessionId, command.turnId, {
+        type: "option_response",
+        optionRequestId: command.optionRequestId,
+        ...(command.selectedOptionId ? { selectedOptionId: command.selectedOptionId } : {}),
+        ...(command.text ? { text: command.text } : {}),
+    });
+    await sendCommandResponse(ws, {
+        type: "machine:optionResponded",
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        turnId: command.turnId,
+        optionRequestId: command.optionRequestId,
+    });
+}
+function modelFromCommand(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 export function promptFailureResponse(command, phase, error) {
     const code = promptFailureCode(phase, error);
     return {
@@ -433,4 +489,68 @@ function truncateOutputPreview(value, maxChars) {
         return value;
     return value.slice(value.length - maxChars);
 }
+function normalizePromptAttachments(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((attachment) => {
+        if (!attachment ||
+            typeof attachment.id !== "string" ||
+            typeof attachment.name !== "string" ||
+            typeof attachment.mediaType !== "string" ||
+            typeof attachment.data !== "string" ||
+            typeof attachment.sizeBytes !== "number")
+            return [];
+        return [{
+                id: attachment.id,
+                name: attachment.name,
+                mediaType: attachment.mediaType,
+                sizeBytes: attachment.sizeBytes,
+                data: attachment.data,
+            }];
+    });
+}
+function preparePromptAttachments(text, attachments) {
+    const textBlocks = [];
+    const runtimeAttachments = [];
+    for (const attachment of attachments) {
+        const decodedText = decodeTextAttachment(attachment);
+        if (decodedText !== undefined) {
+            textBlocks.push([
+                `--- Attachment: ${attachment.name} (${attachment.mediaType}, ${attachment.sizeBytes} bytes) ---`,
+                decodedText,
+                "--- End attachment ---",
+            ].join("\n"));
+            continue;
+        }
+        runtimeAttachments.push({
+            name: attachment.name,
+            mediaType: attachment.mediaType,
+            sizeBytes: attachment.sizeBytes,
+            data: attachment.data,
+        });
+    }
+    return {
+        text: textBlocks.length > 0
+            ? `${text}\n\nAttached text files:\n\n${textBlocks.join("\n\n")}`
+            : text,
+        runtimeAttachments,
+    };
+}
+function decodeTextAttachment(attachment) {
+    const mediaType = attachment.mediaType.toLowerCase();
+    const textLike = mediaType.startsWith("text/") ||
+        mediaType.includes("json") ||
+        mediaType.includes("xml") ||
+        mediaType.includes("yaml") ||
+        mediaType.includes("csv") ||
+        /\.(txt|md|markdown|json|jsonl|yaml|yml|csv|tsv|log|xml|html|css|js|ts|tsx|jsx|vue|py|rb|go|rs|java|c|cc|cpp|h|hpp|sh|zsh|bash|ps1)$/iu.test(attachment.name);
+    if (!textLike)
+        return undefined;
+    try {
+        return Buffer.from(attachment.data, "base64").toString("utf8").slice(0, 64 * 1024);
+    }
+    catch {
+        return undefined;
+    }
+}
 //# sourceMappingURL=prompt.js.map

package/apps/daemon/dist/types.d.ts

@@ -31,6 +31,7 @@ export type SessionState = {
     agent: string;
     cwd: string;
     name: string;
+    model?: string;
     handle: RuntimeHandle;
     historicalBackfill?: HistoricalBackfillState;
 };
@@ -53,6 +54,7 @@ export type SessionMetadata = {
     cwd?: string;
     name?: string;
     providerName?: string;
+    model?: string;
     requestedRuntimeName?: string;
     permissionMode?: PermissionMode;
     importedFromRuntimeSessionId?: string;
@@ -83,6 +85,7 @@ export type SessionMetadata = {
     };
 };
 export type SessionFallback = Pick<SessionState, "agent" | "cwd" | "name"> & {
+    model?: string;
     emptyRuntimeSession?: boolean;
     historicalBackfill?: HistoricalBackfillState;
     runtime?: SessionMetadata["runtime"];

package/apps/daemon/package.json

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

package/apps/relay/dist/controller-handlers.js

@@ -106,6 +106,7 @@ export function handleControllerMessage(context, connection, message) {
             agent: message.agent,
             cwd: message.cwd,
             name: message.name,
+            model: message.model,
             encryptedMetadata: message.encryptedMetadata,
         };
         db.exec("BEGIN");
@@ -158,6 +159,7 @@ export function handleControllerMessage(context, connection, message) {
             encryptedPrompt: message.encryptedPrompt,
             encryptedMetadata: sessionRow.encrypted_metadata ? parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
             permissionMode: message.permissionMode,
+            model: message.model,
             encryptedMemoryOptions: message.encryptedMemoryOptions,
             timeoutMs: message.timeoutMs,
         };
@@ -241,6 +243,31 @@ export function handleControllerMessage(context, connection, message) {
         sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
         return;
     }
+    if (message.type === "controller:optionResponse") {
+        if (!allowControllerAction(connection, "session.run", message.requestId))
+            return;
+        const sessionRow = allowControllerSession(connection, message.sessionId, message.requestId);
+        if (!sessionRow)
+            return;
+        if (rejectDisallowedSessionCommand(sessionRow, message.requestId, "prompt"))
+            return;
+        const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
+        if (!machineConnection) {
+            sendMachineOffline(connection, message.requestId);
+            return;
+        }
+        send(machineConnection.socket, {
+            type: "machine:optionResponse",
+            requestId: message.requestId,
+            sessionId: message.sessionId,
+            turnId: message.turnId,
+            optionRequestId: message.optionRequestId,
+            selectedOptionId: message.selectedOptionId,
+            text: message.text,
+        });
+        sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
+        return;
+    }
     if (message.type === "controller:reconcileTurn") {
         if (!allowControllerAction(connection, "session.run", message.requestId))
             return;

package/apps/relay/dist/http-routes.js

@@ -273,6 +273,7 @@ export function registerHttpRoutes(app, context, controllerInviteTtlMs) {
             agent: body.agent,
             cwd: body.cwd,
             name: body.name,
+            model: body.model,
             encryptedMetadata: body.encryptedMetadata,
         };
         context.db.exec("BEGIN");
@@ -330,6 +331,7 @@ export function registerHttpRoutes(app, context, controllerInviteTtlMs) {
             encryptedPrompt: body.encryptedPrompt,
             encryptedMetadata: sessionRow.encrypted_metadata ? context.parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
             permissionMode: body.permissionMode,
+            model: body.model,
             encryptedMemoryOptions: body.encryptedMemoryOptions,
             timeoutMs: body.timeoutMs,
         };

package/apps/relay/dist/http-schemas.d.ts

@@ -134,6 +134,7 @@ export declare const machineCreateSessionAdmissionSchema: z.ZodObject<{
     agent: z.ZodString;
     cwd: z.ZodString;
     name: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
     encryptedMetadata: z.ZodOptional<z.ZodObject<{
         v: z.ZodLiteral<1>;
         alg: z.ZodLiteral<"A256GCM">;
@@ -170,6 +171,7 @@ export declare const machinePromptAdmissionSchema: z.ZodObject<{
         "approve-reads": "approve-reads";
         "deny-all": "deny-all";
     }>>;
+    model: z.ZodOptional<z.ZodString>;
     encryptedMemoryOptions: z.ZodOptional<z.ZodObject<{
         v: z.ZodLiteral<1>;
         alg: z.ZodLiteral<"A256GCM">;

package/apps/relay/dist/http-schemas.js

@@ -122,6 +122,7 @@ export const machineCreateSessionAdmissionSchema = z.object({
     agent: z.string().min(1),
     cwd: z.string(),
     name: z.string().min(1),
+    model: z.string().min(1).optional(),
     encryptedMetadata: encryptedEnvelopeSchema.optional(),
 });
 export const machinePromptAdmissionSchema = z.object({
@@ -130,6 +131,7 @@ export const machinePromptAdmissionSchema = z.object({
     turnId: z.string().min(1),
     encryptedPrompt: encryptedEnvelopeSchema,
     permissionMode: z.enum(["approve-all", "approve-reads", "deny-all"]).optional(),
+    model: z.string().min(1).optional(),
     encryptedMemoryOptions: encryptedEnvelopeSchema.optional(),
     timeoutMs: z.number().positive().optional(),
 });