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

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

@@ -176,7 +176,13 @@ export function createExternalAgentRuntimeProvider(options) {
         }));
     }
     function clientForAgent(agent) {
-        return clientsByAgent.get(agent);
+        const client = clientsByAgent.get(agent);
+        if (!client)
+            return undefined;
+        if (client.isAvailable() && client.listAgents().some((profile) => profile.id === agent))
+            return client;
+        clientsByAgent.delete(agent);
+        return undefined;
     }
     function clientForHandle(handle) {
         return handle.externalProviderId ? clients.find((client) => client.id === handle.externalProviderId) : undefined;
@@ -220,6 +226,7 @@ export function createExternalAgentRuntimeProvider(options) {
             agentSessionId: handle.sessionId,
             externalProviderId: handle.provider,
             externalHandle: handle,
+            ...(handle.model ? { model: handle.model } : {}),
         };
     }
     function sdkHandle(handle) {
@@ -248,7 +255,7 @@ export function createExternalAgentRuntimeProvider(options) {
                     id: "fallback",
                     load: (cursor, pageLimit) => filterHistoricalSessionPage(fallbackHistoricalSessionPage({ ...input, cursor, limit: pageLimit }), input.cwdMode),
                 },
-                ...clients.map((client) => ({
+                ...clients.filter((client) => client.isAvailable()).map((client) => ({
                     id: `external:${client.id}`,
                     load: (cursor, pageLimit) => filterHistoricalSessionPage(client.request("listHistoricalSessions", { ...input, cursor, limit: pageLimit }).catch(emptyPageUnlessCursorStale), input.cwdMode),
                 })),
@@ -276,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);
@@ -312,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);
@@ -372,6 +386,83 @@ export function createExternalAgentRuntimeProvider(options) {
             }
             throw new Error(`External provider ${client.id} exceeded the historical event page safety limit`);
         },
+        async inspectTurn(input) {
+            const client = requireClientForHandle(input.handle);
+            if (!client) {
+                if (options.fallback.inspectTurn)
+                    return await options.fallback.inspectTurn(input);
+                return {
+                    status: "uninspectable",
+                    providerTurnId: input.providerTurnId ?? input.handle.backendSessionId,
+                    reason: "Fallback runtime does not expose inspectTurn",
+                    evidence: "unsupported",
+                };
+            }
+            const runtimeSessionId = input.handle.backendSessionId;
+            if (!runtimeSessionId) {
+                return {
+                    status: "uninspectable",
+                    providerTurnId: input.providerTurnId,
+                    reason: "External provider handle is missing backendSessionId",
+                    evidence: "missing-backend-session-id",
+                };
+            }
+            try {
+                return await client.request("inspectTurn", {
+                    handle: sdkHandle(input.handle),
+                    turnId: input.turnId,
+                    providerTurnId: input.providerTurnId,
+                    requestId: input.requestId,
+                });
+            }
+            catch (error) {
+                if (!isUnsupportedProviderError(error)) {
+                    return {
+                        status: "unknown",
+                        providerTurnId: input.providerTurnId ?? runtimeSessionId,
+                        reason: error instanceof Error ? error.message : String(error),
+                        evidence: "provider-inspect-error",
+                    };
+                }
+            }
+            try {
+                const events = [];
+                let before;
+                const seenCursors = new Set();
+                for (let pageCount = 0; pageCount < historicalEventPageSafetyLimit; pageCount += 1) {
+                    const page = await client.request("readHistoricalEvents", {
+                        agent: input.handle.runtimeSessionName,
+                        cwd: input.handle.cwd ?? "",
+                        runtimeSessionId,
+                        handle: sdkHandle(input.handle),
+                        before,
+                        limit: historicalEventPageLimit,
+                    });
+                    events.unshift(...page.events);
+                    if (!page.hasMoreBefore)
+                        break;
+                    if (!page.nextBefore)
+                        throw new Error(`External provider ${client.id} returned more history without a nextBefore cursor`);
+                    if (seenCursors.has(page.nextBefore))
+                        throw new Error(`External provider ${client.id} returned a repeated history cursor`);
+                    seenCursors.add(page.nextBefore);
+                    before = page.nextBefore;
+                }
+                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) {
             const client = requireClientForHandle(input.handle);
             if (!client)
@@ -383,7 +474,7 @@ export function createExternalAgentRuntimeProvider(options) {
                 mode: input.mode,
                 permissionMode: input.permissionMode,
                 requestId: input.requestId,
-                timeoutMs: input.timeoutMs,
+                model: input.model ?? input.handle.model,
             });
         },
         cancel(input) {
@@ -441,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;
@@ -470,6 +586,9 @@ class ExternalProviderClient {
     listAgents() {
         return this.agents;
     }
+    isAvailable() {
+        return this.ready && !!this.child && !this.child.killed && !this.exited;
+    }
     diagnostics() {
         const processAvailable = !!this.child && !this.child.killed && !this.exited;
         return {
@@ -568,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" });
             },
@@ -648,6 +775,7 @@ class ExternalProviderClient {
         this.ready = false;
         this.exited = true;
         this.lastError = error.message;
+        this.agents = [];
         for (const [id, pending] of this.pending) {
             clearTimeout(pending.timer);
             pending.reject(error);
@@ -733,12 +861,54 @@ function fromSdkEvent(event) {
 function fromSdkResult(result) {
     return result;
 }
+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 providerResponseError(message) {
     const error = new Error(message.error.message);
     error.name = message.error.code;
     error.code = message.error.code;
     return error;
 }
+function isUnsupportedProviderError(error) {
+    return error instanceof Error && (error.name === "UNSUPPORTED" || error.code === "UNSUPPORTED");
+}
 function requiredString(value, label) {
     if (typeof value !== "string" || !value.trim())
         throw new Error(`${label} must be a non-empty string.`);

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

@@ -1,8 +1,7 @@
-import type { HappyElvesRuntime } from "@happy-elves/runtime";
+import type { HappyElvesRuntime } from "../../../packages/runtime/dist/index.js";
 import type { PrimitiveSupport } from "./types.js";
 export declare function getRuntime(defaultCwd: string): HappyElvesRuntime;
 export declare function initializeRuntime(defaultCwd: string): Promise<void>;
-export declare function runtimeDiagnostics(): Array<Record<string, unknown>>;
 export declare function disposeRuntime(): void;
 export declare function setRuntimeForTests(runtimeOverride: HappyElvesRuntime | null): void;
 export declare function runtimePrimitiveSupport(runtimeInstance: HappyElvesRuntime): {

package/apps/daemon/dist/runtime.js

@@ -57,9 +57,6 @@ export async function initializeRuntime(defaultCwd) {
         await runtimeInstance.initialize();
     }
 }
-export function runtimeDiagnostics() {
-    return runtime?.diagnostics?.() ?? [];
-}
 export function disposeRuntime() {
     runtime?.dispose?.();
     runtime = null;

package/apps/daemon/dist/schedule/handler.d.ts

@@ -0,0 +1,9 @@
+import { type MachineCommand, type ScheduleRecord } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+type ScheduleCommand = Extract<MachineCommand, {
+    type: "machine:schedule";
+}>;
+export declare function handleScheduleCommand(ws: WebSocket, config: DaemonConfig, command: ScheduleCommand): Promise<void>;
+declare function withSchedulePreview(schedule: ScheduleRecord): ScheduleRecord;
+export declare const __testWithSchedulePreview: typeof withSchedulePreview;
+export {};

package/apps/daemon/dist/schedule/handler.js

@@ -0,0 +1,148 @@
+import { randomId } from "../../../../packages/shared/dist/index.js";
+import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
+import { nextRunAtForSchedule, nextRunPreviewForSchedule, occurrenceIdFor, runDueSchedulesNow, runMissedScheduleOccurrence, runScheduleNow } from "./runner.js";
+import { compactSchedules, normalizeScheduleRecord, readScheduleStore, updateScheduleStore } from "./store.js";
+export async function handleScheduleCommand(ws, config, command) {
+    if (!claimCommandRequest(ws, command.requestId))
+        return;
+    const result = await executeScheduleCommand(config, command);
+    await sendCommandResponse(ws, {
+        type: "machine:scheduleResult",
+        requestId: command.requestId,
+        machineId: config.machineId,
+        result,
+    });
+}
+async function executeScheduleCommand(config, command) {
+    if (command.action === "list") {
+        const store = await readScheduleStore();
+        return { action: "list", schedules: compactSchedules(store).map(withSchedulePreview) };
+    }
+    if (command.action === "show") {
+        const store = await readScheduleStore();
+        return { action: "show", schedule: withSchedulePreview(requireSchedule(store, command.scheduleId)) };
+    }
+    if (command.action === "create") {
+        if (!command.schedule)
+            throw new Error("schedule create requires schedule input");
+        const scheduleInput = normalizeCreateInput(command.schedule);
+        const now = new Date().toISOString();
+        const schedule = normalizeScheduleRecord({
+            id: scheduleInput.id ?? randomId("sched"),
+            ...(scheduleInput.name ? { name: scheduleInput.name } : {}),
+            ...(scheduleInput.sessionId ? { sessionId: scheduleInput.sessionId } : {}),
+            ...(scheduleInput.sourceSessionId ? { sourceSessionId: scheduleInput.sourceSessionId } : {}),
+            target: scheduleInput.target,
+            prompt: scheduleInput.prompt,
+            dueAt: scheduleInput.dueAt,
+            schedule: scheduleInput.schedule,
+            execution: scheduleInput.execution ?? "continue",
+            memoryMode: scheduleInput.memoryMode ?? "inherit",
+            stopOn: scheduleInput.stopOn ?? ["blocked", "failed", "permission"],
+            status: "active",
+            createdAt: now,
+            updatedAt: now,
+            runs: [],
+        });
+        if (!schedule)
+            throw new Error("schedule create input is invalid");
+        schedule.nextRunAt = nextRunAtForSchedule(schedule, Date.now());
+        const store = await updateScheduleStore((current) => ({
+            ...current,
+            schedules: [schedule, ...current.schedules.filter((item) => item.id !== schedule.id)],
+        }));
+        return { action: "create", schedule: withSchedulePreview(requireSchedule(store, schedule.id)) };
+    }
+    if (command.action === "pause" || command.action === "resume" || command.action === "delete") {
+        const nextStatus = command.action === "pause" ? "paused" : command.action === "resume" ? "active" : "deleted";
+        const nowMs = Date.now();
+        const store = await updateScheduleStore((current) => ({
+            ...current,
+            schedules: current.schedules.map((schedule) => schedule.id === command.scheduleId
+                ? {
+                    ...schedule,
+                    status: nextStatus,
+                    ...(nextStatus === "active" ? { nextRunAt: nextRunAtForSchedule(schedule, nowMs) } : { nextRunAt: undefined }),
+                    updatedAt: new Date(nowMs).toISOString(),
+                }
+                : schedule),
+        }));
+        return {
+            action: command.action,
+            schedule: command.action === "delete" ? undefined : withSchedulePreview(requireSchedule(store, command.scheduleId)),
+            scheduleId: command.scheduleId,
+        };
+    }
+    if (command.action === "history") {
+        const store = await readScheduleStore();
+        const schedule = requireSchedule(store, command.scheduleId);
+        return { action: "history", scheduleId: schedule.id, history: schedule.runs };
+    }
+    if (command.action === "run") {
+        const store = await readScheduleStore();
+        const schedule = requireSchedule(store, command.scheduleId);
+        const run = await runScheduleNow(config, schedule);
+        return { action: "run", scheduleId: schedule.id, run };
+    }
+    if (command.action === "runDue") {
+        const runs = await runDueSchedulesNow(config);
+        return { action: "runDue", runs };
+    }
+    if (command.action === "runMissed") {
+        const store = await readScheduleStore();
+        const schedule = requireSchedule(store, command.scheduleId);
+        const occurrenceId = command.occurrenceId ?? occurrenceIdFor(schedule);
+        const run = await runMissedScheduleOccurrence(config, schedule, occurrenceId);
+        return { action: "runMissed", scheduleId: schedule.id, run };
+    }
+    throw new Error(`Unsupported schedule action: ${command.action}`);
+}
+function requireSchedule(store, scheduleId) {
+    if (!scheduleId)
+        throw new Error("scheduleId is required");
+    const schedule = store.schedules.find((item) => item.id === scheduleId && item.status !== "deleted");
+    if (!schedule)
+        throw new Error("Schedule not found");
+    return schedule;
+}
+function withSchedulePreview(schedule) {
+    if (schedule.status !== "active") {
+        return {
+            ...schedule,
+            nextRunAt: undefined,
+            previewRunAt: [],
+        };
+    }
+    return {
+        ...schedule,
+        nextRunAt: schedule.nextRunAt ?? nextRunAtForSchedule(schedule, Date.now()),
+        previewRunAt: nextRunPreviewForSchedule(schedule, 3, Date.now()),
+    };
+}
+export const __testWithSchedulePreview = withSchedulePreview;
+function normalizeCreateInput(input) {
+    const prompt = input.prompt?.trim();
+    if (!prompt)
+        throw new Error("schedule prompt is required");
+    const schedule = input.schedule ?? (input.dueAt ? { type: "oneshot", runAt: parseScheduleDate(input.dueAt) } : { type: "manual" });
+    const dueAt = schedule.type === "oneshot" ? parseScheduleDate(schedule.runAt) : input.dueAt ? parseScheduleDate(input.dueAt) : undefined;
+    const sourceSessionId = input.sourceSessionId ?? input.sessionId ?? (input.target?.type === "sourceSession" ? input.target.sourceSessionId : undefined);
+    const target = input.target ?? (sourceSessionId ? { type: "sourceSession", sourceSessionId } : undefined);
+    if (!target)
+        throw new Error("schedule target is required");
+    return {
+        ...input,
+        prompt,
+        ...(sourceSessionId ? { sourceSessionId, sessionId: input.sessionId ?? sourceSessionId } : {}),
+        target,
+        schedule,
+        ...(dueAt ? { dueAt } : {}),
+    };
+}
+function parseScheduleDate(value) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        throw new Error("Invalid schedule date");
+    return date.toISOString();
+}
+//# sourceMappingURL=handler.js.map

package/apps/daemon/dist/schedule/runner.d.ts

@@ -0,0 +1,21 @@
+import { type ScheduleRecord, type ScheduleRunRecord } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+export declare function tickSchedules(config: DaemonConfig, onlineSinceMs: number): Promise<void>;
+export declare function runMissedScheduleOccurrence(config: DaemonConfig, schedule: ScheduleRecord, occurrenceId: string): Promise<ScheduleRunRecord>;
+export declare function runScheduleNow(config: DaemonConfig, schedule: ScheduleRecord): Promise<ScheduleRunRecord>;
+export declare function runDueSchedulesNow(config: DaemonConfig): Promise<Array<{
+    scheduleId: string;
+    run: ScheduleRunRecord;
+}>>;
+export declare function occurrenceIdFor(schedule: Pick<ScheduleRecord, "id" | "dueAt" | "nextRunAt">, dueAt?: string): string;
+export declare function __testWithActiveScheduleOccurrence<T>(scheduleId: string, occurrenceId: string, action: () => Promise<T> | T): Promise<T>;
+export declare function nextRunAtForSchedule(schedule: Pick<ScheduleRecord, "schedule" | "dueAt" | "runs">, afterMs?: number): string | undefined;
+export declare function nextRunPreviewForSchedule(schedule: Pick<ScheduleRecord, "id" | "schedule" | "dueAt" | "runs">, count?: number, afterMs?: number): string[];
+export declare function settleScheduleTurnTerminal(input: {
+    requestId: string;
+    turnId: string;
+    status: "completed" | "failed" | "cancelled";
+    outputPreview?: string;
+    error?: string;
+    finishedAt?: string;
+}): Promise<ScheduleRunRecord | undefined>;