@cydm/happy-elves 0.1.0-beta.48 → 0.1.0-beta.49

package/packages/client/dist/live.d.ts

@@ -1,103 +1,6 @@
-import { type MachineSnapshot, type SessionSnapshot } from "../../shared/dist/index.js";
 import type { ControllerClient } from "./client.js";
-import type { ControllerSnapshot, DecodedSessionEvent, MachineMetadata, PermissionMode, SessionMetadata } from "./types.js";
-export type ControllerLiveSessionPageState = {
-    error?: string;
-    hasOlderRelayEvents?: boolean;
-    hasOlderEvents: boolean;
-    initialized: boolean;
-    latestCursor?: string;
-    loadingOlderEvents: boolean;
-    olderCursor?: string;
-    olderRelayVersion?: number;
-    oldestEventId?: number;
-    projectionHeadKey?: string;
-    runtimeCanSync?: boolean;
-    runtimeHistoryChecked?: boolean;
-};
-export type ControllerLiveState = {
-    connectionState: "offline" | "connecting" | "online";
-    events: DecodedSessionEvent[];
-    lastError?: string;
-    lastSnapshotAt: number;
-    lastSnapshotMachineCount: number;
-    lastSnapshotSessionCount: number;
-    lastSnapshotSource: string;
-    machineMetadata: Record<string, MachineMetadata>;
-    machines: MachineSnapshot[];
-    selectedSessionId?: string;
-    sessionMetadata: Record<string, SessionMetadata>;
-    sessionPages: Record<string, ControllerLiveSessionPageState>;
-    sessions: SessionSnapshot[];
-    snapshotHydrating: boolean;
-    snapshotReady: boolean;
-};
-export type ControllerLiveEvent = {
-    type: "change";
-    state: ControllerLiveState;
-} | {
-    type: "connection";
-    state: ControllerLiveState["connectionState"];
-} | {
-    type: "diagnostic";
-    kind: "snapshot" | "websocket";
-    detail: Record<string, string | number | boolean>;
-} | {
-    type: "snapshot";
-    source: string;
-    snapshot: ControllerSnapshot;
-} | {
-    type: "machine";
-    machine: MachineSnapshot;
-} | {
-    type: "session";
-    session: SessionSnapshot;
-} | {
-    type: "event";
-    event: DecodedSessionEvent;
-} | {
-    type: "ack";
-    requestId: string;
-    sessionId?: string;
-} | {
-    type: "error";
-    message: string;
-    code?: string;
-    requestId?: string;
-};
-export type ControllerLiveOptions = {
-    reconnectMs?: number;
-    sessionEventPageSize?: number;
-    olderSessionEventPageSize?: number;
-    promptAckTimeoutMs?: number;
-};
-export type SendPromptInput = {
-    sessionId: string;
-    text: string;
-    permissionMode?: PermissionMode;
-    timeoutMs?: number;
-};
-export type SendPromptResult = {
-    requestId: string;
-    turnId: string;
-};
-export type RefreshSessionEventHistoryInput = {
-    mode?: "preserve" | "latest";
-};
-export interface ControllerLiveProjection {
-    start(): void;
-    stop(): void;
-    state(): ControllerLiveState;
-    subscribe(listener: (event: ControllerLiveEvent) => void): () => void;
-    refreshSnapshot(reason: string): Promise<void>;
-    selectSession(sessionId: string): Promise<void>;
-    refreshSessionEventHistory(sessionId: string, input?: RefreshSessionEventHistoryInput): Promise<void>;
-    sendPrompt(input: SendPromptInput): Promise<SendPromptResult>;
-    loadOlderSessionEvents(sessionId: string, input?: {
-        reveal?: "older" | "preserve";
-    }): Promise<void>;
-    syncRuntimeHistoryWindow(sessionId: string): Promise<boolean>;
-}
+import type { ControllerLiveEvent, ControllerLiveOptions, ControllerLiveProjection, ControllerLiveState, RefreshSessionEventHistoryInput, SendPromptInput, SendPromptResult } from "./live-types.js";
+export type { ControllerLiveEvent, ControllerLiveOptions, ControllerLiveProjection, ControllerLiveSessionPageState, ControllerLiveState, RefreshSessionEventHistoryInput, SendPromptInput, SendPromptResult, } from "./live-types.js";
 export declare class ControllerLiveProjectionImpl implements ControllerLiveProjection {
     private readonly client;
     private readonly listeners;

package/packages/client/dist/live.js

@@ -1,6 +1,8 @@
 import { encryptJson, randomId, } from "../../shared/dist/index.js";
 import { ControllerClientError, ControllerCommandError } from "./errors.js";
-import { oldestSessionEventId, shouldHoldHistoricalEventForOlderPage } from "./session-event-order.js";
+import { cloneLiveState, errorMessage, nonEmptyLiveString, sleep, upsertById, } from "./live-state.js";
+import { hasVisibleTranscriptPayload, isAuthoritativeSessionModel, isSelectedSessionHeadMaterialized, newestEventIdForSession, oldestEventIdForSession, runtimeHistoricalBackfillCanContinue, runtimeHistoricalBackfillCompleted, runtimeHistoricalBackfillKnown, selectedSessionHistoryHead, selectedSessionProjectionHead, sessionEventCount, sessionHasHistoricalBackfillEvents, sessionHasMissingHistoricalPrefix, } from "./live-session-state.js";
+import { shouldHoldHistoricalEventForOlderPage } from "./session-event-order.js";
 import { exactReplaceSessionEvents, mergeAuthoritativeSessionEventsByIdentity, mergeLatestPagePreservingLoadedOlderEvents, mergeSessionEventsById, } from "./session-event-window.js";
 import { subscribe as subscribeToRelay } from "./transport.js";
 import { wsUrl } from "./http.js";
@@ -67,7 +69,7 @@ export class ControllerLiveProjectionImpl {
         this.setState({ connectionState: "offline" });
     }
     state() {
-        return cloneState(this.stateValue);
+        return cloneLiveState(this.stateValue);
     }
     subscribe(listener) {
         this.listeners.add(listener);
@@ -136,8 +138,8 @@ export class ControllerLiveProjectionImpl {
         await this.refreshSelectedSessionEventHistory(sessionId, input);
     }
     async sendPrompt(input) {
-        const sessionId = nonEmpty(input.sessionId, "sessionId");
-        const text = nonEmpty(input.text, "text");
+        const sessionId = nonEmptyLiveString(input.sessionId, "sessionId");
+        const text = nonEmptyLiveString(input.text, "text");
         await this.ensureSocketOpen();
         const socket = this.socket;
         if (!socket || socket.readyState !== WebSocket.OPEN) {
@@ -804,15 +806,7 @@ export class ControllerLiveProjectionImpl {
         void this.loadSelectedSessionEventHistory(session, { force: true });
     }
     selectedSessionHeadMaterialized(session) {
-        const currentHead = session.currentHead || session.lastTurnId;
-        if (!currentHead)
-            return true;
-        const localEvents = this.stateValue.events.filter((event) => event.sessionId === session.id);
-        const eventIdMatch = /^event:(\d+)$/.exec(currentHead);
-        if (eventIdMatch)
-            return localEvents.some((event) => event.id === Number(eventIdMatch[1]));
-        return localEvents.some((event) => event.turnId === currentHead ||
-            (event.decoded?.type === "done" && (event.decoded.currentHead === currentHead || event.decoded.lastTurnId === currentHead)));
+        return isSelectedSessionHeadMaterialized(session, this.stateValue.events);
     }
     clearUninitializedAuthoritativeSnapshotSessions(sessions, sessionFences) {
         for (const session of sessions) {
@@ -905,7 +899,7 @@ export class ControllerLiveProjectionImpl {
         });
     }
     isAuthoritativeSession(session) {
-        return session?.historyModel === "authoritative-linear";
+        return isAuthoritativeSessionModel(session);
     }
     isAuthoritativeSnapshotSession(session) {
         return this.isAuthoritativeSession(session) ||
@@ -941,42 +935,29 @@ export class ControllerLiveProjectionImpl {
     }
     runtimeHistoricalBackfillCanContinue(sessionId) {
         const metadata = this.stateValue.sessionMetadata[sessionId];
-        const status = metadata?.historicalBackfillStatus ?? metadata?.historicalBackfill;
-        return status === "partial" || metadata?.truncatedHistoricalBackfill === true || this.sessionHasMissingHistoricalPrefix(sessionId);
+        return runtimeHistoricalBackfillCanContinue(metadata, this.sessionHasMissingHistoricalPrefix(sessionId));
     }
     runtimeHistoricalBackfillKnown(sessionId) {
-        const metadata = this.stateValue.sessionMetadata[sessionId];
-        return Boolean(metadata &&
-            (metadata.historicalBackfillStatus !== undefined ||
-                metadata.historicalBackfill !== undefined ||
-                metadata.historicalBackfillCursor !== undefined ||
-                metadata.truncatedHistoricalBackfill !== undefined));
+        return runtimeHistoricalBackfillKnown(this.stateValue.sessionMetadata[sessionId]);
     }
     runtimeHistoricalBackfillCompleted(sessionId) {
-        const metadata = this.stateValue.sessionMetadata[sessionId];
-        const status = metadata?.historicalBackfillStatus ?? metadata?.historicalBackfill;
-        return status === "completed" || metadata?.historicalBackfillCursor === 0;
+        return runtimeHistoricalBackfillCompleted(this.stateValue.sessionMetadata[sessionId]);
     }
     oldestEventIdForSession(sessionId) {
-        return oldestSessionEventId(this.stateValue.events, sessionId);
+        return oldestEventIdForSession(this.stateValue.events, sessionId);
     }
     newestEventIdForSession(sessionId) {
-        return Math.max(0, ...this.stateValue.events.filter((event) => event.sessionId === sessionId).map((event) => event.id));
+        return newestEventIdForSession(this.stateValue.events, sessionId);
     }
     sessionEventCount(sessionId) {
-        return this.stateValue.events.filter((event) => event.sessionId === sessionId).length;
+        return sessionEventCount(this.stateValue.events, sessionId);
     }
     sessionHasHistoricalBackfillEvents(sessionId) {
-        return this.stateValue.events.some((event) => event.sessionId === sessionId && event.messageId?.startsWith("hist_"));
+        return sessionHasHistoricalBackfillEvents(this.stateValue.events, sessionId);
     }
     sessionHasMissingHistoricalPrefix(sessionId) {
         const session = this.stateValue.sessions.find((item) => item.id === sessionId);
-        if (!session?.currentHead && !session?.lastTurnId)
-            return false;
-        const turnSeqs = this.stateValue.events
-            .filter((event) => event.sessionId === sessionId && event.messageId?.startsWith("hist_") && typeof event.turnSeq === "number")
-            .map((event) => event.turnSeq);
-        return turnSeqs.length > 0 && Math.min(...turnSeqs) > 0;
+        return sessionHasMissingHistoricalPrefix(session, this.stateValue.events);
     }
     captureSessionHistoryFence(sessionId, session = this.stateValue.sessions.find((item) => item.id === sessionId), options = {}) {
         return {
@@ -1073,45 +1054,3 @@ export class ControllerLiveProjectionImpl {
         this.emit({ type: "error", message: errorMessage(error), requestId });
     }
 }
-function upsertById(items, next) {
-    const copy = [...items];
-    const index = copy.findIndex((item) => item.id === next.id);
-    if (index >= 0)
-        copy[index] = next;
-    else
-        copy.unshift(next);
-    return copy;
-}
-function selectedSessionHistoryHead(session) {
-    return [session.currentHead ?? "", session.lastTurnId ?? "", session.status, String(session.updatedAt)].join(":");
-}
-function selectedSessionProjectionHead(session) {
-    return [session.currentHead ?? "", session.lastTurnId ?? ""].join(":");
-}
-function hasVisibleTranscriptPayload(event) {
-    const type = event.decoded?.type;
-    return type === "user_prompt" || type === "text_delta" || type === "tool_call";
-}
-function cloneState(state) {
-    return {
-        ...state,
-        events: [...state.events],
-        machineMetadata: { ...state.machineMetadata },
-        machines: [...state.machines],
-        sessionMetadata: { ...state.sessionMetadata },
-        sessionPages: Object.fromEntries(Object.entries(state.sessionPages).map(([key, value]) => [key, { ...value }])),
-        sessions: [...state.sessions],
-    };
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function nonEmpty(value, label) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        throw new ControllerClientError(`${label} must be a non-empty string`, "INVALID_ARGUMENT");
-    return trimmed;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/packages/client/dist/types.d.ts

@@ -143,6 +143,9 @@ export type CreateSessionInput = {
 export type RunOptions = {
     wait?: boolean;
     permissionMode?: PermissionMode;
+    requestId?: string;
+    turnId?: string;
+    promptHash?: string;
     waitTimeoutMs?: number;
     ackTimeoutMs?: number;
     runtimeTimeoutMs?: number;
@@ -204,7 +207,7 @@ export type WaitInput = {
 export type CollectInput = {
     before?: EventCursor;
     beforeCursor?: string;
-    since?: EventCursor;
+    since?: EventCursor | string;
     limit?: number;
     turnId?: string;
 };

package/packages/client/dist/validation.d.ts

@@ -9,6 +9,7 @@ export declare function requireNonEmpty(value: string, field: string): string;
 export declare function matchesWaitCondition(session: SessionSnapshot, until: WaitCondition): boolean;
 export declare function isWaitCondition(value: unknown): value is WaitCondition;
 export declare function parseEventCursor(value: EventCursor | undefined): number | undefined;
+export declare function parseSinceEventCursor(value: EventCursor | string | undefined): number | string | undefined;
 export declare function parseEventLimit(value: number | undefined): number | undefined;
 export declare function parsePositiveDuration(value: number, field: string): number;
 export declare function sleep(ms: number): Promise<void>;

package/packages/client/dist/validation.js

@@ -69,6 +69,17 @@ export function parseEventCursor(value) {
     }
     return Number(value.slice("cursor_".length));
 }
+export function parseSinceEventCursor(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "number")
+        return parseEventCursor(value);
+    if (/^cursor_\d+$/.test(value))
+        return parseEventCursor(value);
+    if (value.trim())
+        return value;
+    throw new ControllerClientError(`Invalid event cursor: ${value}`, "INVALID_ARGUMENT");
+}
 export function parseEventLimit(value) {
     if (value === undefined)
         return undefined;

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

@@ -17,6 +17,7 @@ export type ControllerClientMessage = {
     turnId: string;
     encryptedPrompt: EncryptedEnvelope;
     encryptedMetadata?: EncryptedEnvelope;
+    promptHash?: string;
     permissionMode?: PermissionMode;
     timeoutMs?: number;
 } | {
@@ -441,6 +442,7 @@ export type JsonEnvelope<T = unknown> = {
         code: string;
         message: string;
         capability?: string;
+        retryable?: boolean;
     };
     meta: {
         requestId?: string;
@@ -450,6 +452,7 @@ export type JsonEnvelope<T = unknown> = {
         activeTurnId?: string;
         latestCompletedTurnId?: string;
         commandAcked?: boolean;
+        rawStatus?: string;
     };
 };
 export declare function parseClientMessage(value: unknown): ClientMessage;

package/packages/shared/dist/protocol.js

@@ -19,6 +19,7 @@ const controllerMessageSchema = z.discriminatedUnion("type", [
         turnId: z.string().min(1),
         encryptedPrompt: encryptedEnvelopeSchema,
         encryptedMetadata: encryptedEnvelopeSchema.optional(),
+        promptHash: z.string().min(1).optional(),
         permissionMode: z.enum(["approve-all", "approve-reads", "deny-all"]).optional(),
         timeoutMs: z.number().positive().optional(),
     }),