@beeuni/sdk 0.1.0

package/dist/browser/stores/session-working-store.d.ts

@@ -0,0 +1,21 @@
+import { type AbortReceipt, type SendReceipt, type WorkingInboxInput } from '../../core/session/working.js';
+interface SessionWorkingState {
+    receipts: Record<string, SendReceipt | null>;
+    aborts: Record<string, AbortReceipt>;
+    inbox: Record<string, WorkingInboxInput>;
+    noteSendReceipt: (sessionId: string, receipt: {
+        messageId: string;
+        turnId?: string | null;
+        atMs: number;
+    }) => void;
+    acceptSendReceipt: (sessionId: string, messageId: string, atMs: number) => void;
+    clearSendReceipt: (sessionId: string, messageId?: string) => void;
+    noteAbortReceipt: (sessionId: string, atMs: number) => void;
+    settleAbortReceipt: (sessionId: string, atMs: number, status?: 'aborted' | 'failed' | 'timed-out' | 'skipped') => void;
+    noteInboxPending: (sessionId: string, pending: number, atMs: number, serverAtMs?: number, drainedAtMs?: number) => void;
+    notePromptAccepted: (sessionId: string, atMs: number, serverAtMs?: number) => void;
+    clearSession: (sessionId: string) => void;
+    reset: () => void;
+}
+export declare const useSessionWorkingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SessionWorkingState>>;
+export {};

package/dist/browser/stores/session-working-store.js

@@ -0,0 +1,106 @@
+'use client';
+import { create } from 'zustand';
+import { inboxObservationSupersedes, } from '../../core/session/working.js';
+export const useSessionWorkingStore = create()((set) => ({
+    receipts: {},
+    aborts: {},
+    inbox: {},
+    noteSendReceipt: (sessionId, receipt) => set((state) => {
+        if (!sessionId)
+            return state;
+        const { [sessionId]: _stopped, ...aborts } = state.aborts;
+        return {
+            receipts: {
+                ...state.receipts,
+                [sessionId]: { ...receipt, acceptedAtMs: null },
+            },
+            aborts,
+        };
+    }),
+    acceptSendReceipt: (sessionId, messageId, atMs) => set((state) => {
+        const current = state.receipts[sessionId];
+        if (!current || current.messageId !== messageId || current.acceptedAtMs != null) {
+            return state;
+        }
+        return { receipts: { ...state.receipts, [sessionId]: { ...current, acceptedAtMs: atMs } } };
+    }),
+    clearSendReceipt: (sessionId, messageId) => set((state) => {
+        const current = state.receipts[sessionId];
+        if (!(sessionId in state.receipts))
+            return state;
+        if (messageId !== undefined && current?.messageId !== messageId)
+            return state;
+        const { [sessionId]: _dropped, ...rest } = state.receipts;
+        return { receipts: rest };
+    }),
+    noteAbortReceipt: (sessionId, atMs) => set((state) => {
+        if (!sessionId)
+            return state;
+        const current = state.aborts[sessionId];
+        if (current && current.settledAtMs == null)
+            return state;
+        return { aborts: { ...state.aborts, [sessionId]: { atMs, settledAtMs: null } } };
+    }),
+    settleAbortReceipt: (sessionId, atMs, status) => set((state) => {
+        if (status === 'timed-out' || status === 'skipped')
+            return state;
+        const current = state.aborts[sessionId];
+        if (!current || current.settledAtMs != null)
+            return state;
+        return { aborts: { ...state.aborts, [sessionId]: { ...current, settledAtMs: atMs } } };
+    }),
+    noteInboxPending: (sessionId, pending, atMs, serverAtMs, drainedAtMs) => set((state) => {
+        if (!sessionId)
+            return state;
+        const current = state.inbox[sessionId];
+        const carried = pending === 0 ? (drainedAtMs ?? current?.drainedAtMs) : undefined;
+        const candidate = {
+            pending,
+            atMs,
+            ...(serverAtMs != null ? { serverAtMs } : {}),
+            ...(carried != null ? { drainedAtMs: carried } : {}),
+        };
+        if (!inboxObservationSupersedes(candidate, current))
+            return state;
+        if (current &&
+            current.atMs === atMs &&
+            current.pending === pending &&
+            current.serverAtMs === candidate.serverAtMs &&
+            current.drainedAtMs === candidate.drainedAtMs) {
+            return state;
+        }
+        return { inbox: { ...state.inbox, [sessionId]: candidate } };
+    }),
+    notePromptAccepted: (sessionId, atMs, serverAtMs) => set((state) => {
+        if (!sessionId)
+            return state;
+        const current = state.inbox[sessionId];
+        if (current && current.atMs > atMs)
+            return state;
+        if (current?.serverAtMs != null && serverAtMs != null && current.serverAtMs > serverAtMs) {
+            return state;
+        }
+        const pending = Math.max(1, current?.pending ?? 0);
+        const merged = serverAtMs != null || current?.serverAtMs != null
+            ? Math.max(serverAtMs ?? Number.NEGATIVE_INFINITY, current?.serverAtMs ?? Number.NEGATIVE_INFINITY)
+            : undefined;
+        return {
+            inbox: {
+                ...state.inbox,
+                [sessionId]: { pending, atMs, ...(merged != null ? { serverAtMs: merged } : {}) },
+            },
+        };
+    }),
+    clearSession: (sessionId) => set((state) => {
+        if (!(sessionId in state.receipts) &&
+            !(sessionId in state.aborts) &&
+            !(sessionId in state.inbox)) {
+            return state;
+        }
+        const { [sessionId]: _r, ...receipts } = state.receipts;
+        const { [sessionId]: _a, ...aborts } = state.aborts;
+        const { [sessionId]: _i, ...inbox } = state.inbox;
+        return { receipts, aborts, inbox };
+    }),
+    reset: () => set({ receipts: {}, aborts: {}, inbox: {} }),
+}));

package/dist/browser/stores/sync-store/ascending-id.d.ts

@@ -0,0 +1 @@
+export declare function ascendingId(prefix?: "msg" | "prt"): string;

package/dist/browser/stores/sync-store/ascending-id.js

@@ -0,0 +1,17 @@
+let lastTs = 0;
+let counter = 0;
+const chars62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+export function ascendingId(prefix = "msg") {
+    const now = Date.now();
+    if (now !== lastTs) {
+        lastTs = now;
+        counter = 0;
+    }
+    counter++;
+    const encoded = BigInt(now) * BigInt(0x1000) + BigInt(counter);
+    const hex = encoded.toString(16).padStart(12, "0").slice(0, 12);
+    let rand = "";
+    for (let i = 0; i < 14; i++)
+        rand += chars62[Math.floor(Math.random() * 62)];
+    return `${prefix}_${hex}${rand}`;
+}

package/dist/browser/stores/sync-store/binary.d.ts

@@ -0,0 +1,6 @@
+export declare const Binary: {
+    search<T>(array: T[], id: string, compare: (item: T) => string): {
+        found: boolean;
+        index: number;
+    };
+};

package/dist/browser/stores/sync-store/binary.js

@@ -0,0 +1,17 @@
+export const Binary = {
+    search(array, id, compare) {
+        let left = 0;
+        let right = array.length - 1;
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            const midId = compare(array[mid]);
+            if (midId === id)
+                return { found: true, index: mid };
+            if (midId < id)
+                left = mid + 1;
+            else
+                right = mid - 1;
+        }
+        return { found: false, index: left };
+    },
+};

package/dist/browser/stores/sync-store/delta-event-window.d.ts

@@ -0,0 +1 @@
+export declare const DELTA_EVENT_TAIL_LIMIT = 2048;

package/dist/browser/stores/sync-store/delta-event-window.js

@@ -0,0 +1 @@
+export const DELTA_EVENT_TAIL_LIMIT = 2048;

package/dist/browser/stores/sync-store/reconcile-parts.d.ts

@@ -0,0 +1,12 @@
+import type { Part } from "../../../core/runtime/runtime-types.js";
+export declare function reconcileHydratedParts(msgs: Array<{
+    info: {
+        id: string;
+    };
+    parts: Part[];
+}>, parts: Record<string, Part[]>, tracking: {
+    isOptimistic: (id: string) => boolean;
+    isBridged: (id: string) => boolean;
+    clearBridge: (id: string) => void;
+    isDeltaActive: (id: string) => boolean;
+}): void;

package/dist/browser/stores/sync-store/reconcile-parts.js

@@ -0,0 +1,53 @@
+import { Binary } from "./binary.js";
+function isTextLikePart(part) {
+    return part.type === "text" || part.type === "reasoning";
+}
+export function reconcileHydratedParts(msgs, parts, tracking) {
+    for (const m of msgs) {
+        if (!m?.info?.id)
+            continue;
+        const mid = m.info.id;
+        if (tracking.isOptimistic(mid))
+            continue;
+        const inParts = m.parts
+            .filter((p) => !!p?.id)
+            .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        if (tracking.isBridged(mid) && inParts.length > 0) {
+            tracking.clearBridge(mid);
+            parts[mid] = inParts;
+            continue;
+        }
+        const exParts = parts[mid];
+        if (!exParts || exParts.length === 0) {
+            parts[mid] = inParts;
+            continue;
+        }
+        const exById = new Map(exParts.map((p) => [p.id, p]));
+        const inIds = new Set(inParts.map((p) => p.id));
+        const extras = exParts.filter((p) => !inIds.has(p.id));
+        const reconciled = inParts.map((inP) => {
+            const exP = exById.get(inP.id);
+            if (exP &&
+                isTextLikePart(inP) &&
+                isTextLikePart(exP) &&
+                exP.text.length > inP.text.length)
+                return exP;
+            return inP;
+        });
+        const survivingExtras = extras.filter((extra) => {
+            if (tracking.isDeltaActive(extra.id))
+                return true;
+            if (!isTextLikePart(extra) || extra.text.length === 0)
+                return true;
+            return !inParts.some((inP) => inP.type === extra.type &&
+                isTextLikePart(inP) &&
+                inP.text.startsWith(extra.text));
+        });
+        for (const ep of survivingExtras) {
+            const r = Binary.search(reconciled, ep.id, (p) => p.id);
+            if (!r.found)
+                reconciled.splice(r.index, 0, ep);
+        }
+        parts[mid] = reconciled;
+    }
+}

package/dist/browser/stores/sync-store/types.d.ts

@@ -0,0 +1,20 @@
+import type { AssistantMessage, Message, Part, SnapshotFileDiff } from "../../../core/runtime/runtime-types.js";
+import type { AbortReason } from "../../../core/http/abort-error.js";
+export type { SessionRewindState } from "../../../core/session/rewind.js";
+export type FileDiff = Omit<SnapshotFileDiff, "patch"> & {
+    patch?: string;
+    before?: string;
+    after?: string;
+};
+export interface SyntheticAbortError {
+    name: "AbortError";
+    data: {
+        message: string;
+        reason?: AbortReason;
+    };
+}
+export type MessageError = NonNullable<AssistantMessage["error"]> | SyntheticAbortError;
+export interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}

package/dist/browser/stores/sync-store/types.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/stores/sync-store.d.ts

@@ -0,0 +1,65 @@
+import type { Message, Event as RuntimeEvent, Part, SessionStatus, Todo } from "../../core/runtime/runtime-types.js";
+import { ascendingId } from "./sync-store/ascending-id.js";
+import { Binary } from "./sync-store/binary.js";
+import type { FileDiff, MessageError, MessageWithParts, SessionRewindState } from "./sync-store/types.js";
+export { ascendingId, Binary };
+export type { MessageError, MessageWithParts, SessionRewindState };
+export declare function sameSessionStatus(a: SessionStatus | undefined, b: SessionStatus | undefined): boolean;
+interface SyncState {
+    messages: Record<string, Message[]>;
+    parts: Record<string, Part[]>;
+    sessionStatus: Record<string, SessionStatus>;
+    sessionStatusOrigin: Record<string, "wire" | "local">;
+    sessionStatusAt: Record<string, number>;
+    sessionActivityAt: Record<string, number>;
+    diffs: Record<string, FileDiff[]>;
+    todos: Record<string, Todo[]>;
+    sessionRevert: Record<string, SessionRewindState | null>;
+    sessionRevertNeedsTailReconcile: Record<string, boolean>;
+    applyEvent: (event: RuntimeEvent) => void;
+    upsertMessage: (sessionID: string, message: Message) => void;
+    removeMessage: (sessionID: string, messageID: string) => void;
+    upsertPart: (messageID: string, part: Part, sessionID?: string) => void;
+    removePart: (messageID: string, partID: string) => void;
+    applyPartDelta: (sessionID: string, messageID: string, partID: string, field: string, delta: string, eventID?: string) => void;
+    setStatus: (sessionID: string, status: SessionStatus, origin?: "wire" | "local") => void;
+    setDiff: (sessionID: string, diffs: FileDiff[]) => void;
+    setTodo: (sessionID: string, todos: Todo[]) => void;
+    stageSessionRevert: (sessionId: string, messageId: string) => void;
+    commitSessionRevert: (sessionId: string) => void;
+    clearSessionRevert: (sessionId: string) => void;
+    applyCommittedRevert: (sessionId: string, boundaryId: string, watermark: string, hiddenIds?: readonly string[]) => void;
+    markSessionRevertNeedsTailReconcile: (sessionId: string) => void;
+    clearSessionRevertNeedsTailReconcile: (sessionId: string) => void;
+    syncSessionRevertFromInfo: (sessionId: string, revert: {
+        messageID: string;
+    } | null | undefined) => void;
+    optimisticAdd: (sessionID: string, message: Message, messageParts: Part[]) => void;
+    optimisticRemove: (sessionID: string, messageID: string) => void;
+    markOptimisticDispatched: (sessionID: string, messageID: string) => void;
+    markOptimisticInboxBacked: (sessionID: string, messageID: string) => void;
+    clearOptimisticMessages: (sessionID: string) => void;
+    noteSessionActivity: (sessionID: string, atMs?: number) => void;
+    optimisticEchoOf: (sessionID: string, optimisticID: string) => string | undefined;
+    optimisticOriginOf: (sessionID: string, echoID: string) => string | undefined;
+    registerOptimisticEcho: (sessionID: string, optimisticID: string, echoID: string) => void;
+    forgetControlPlaneMessage: (sessionID: string, messageID: string) => void;
+    hasOptimisticMessages: (sessionID: string) => boolean;
+    isOptimisticMessage: (sessionID: string, messageID: string) => boolean;
+    reclaimRemovedMessage: (sessionID: string, messageID: string) => boolean;
+    clearSession: (sessionID: string) => void;
+    retainSession: (sessionID: string) => () => void;
+    wasTranscriptEvicted: (sessionID: string) => boolean;
+    buildSessionMessages: (sessionID: string, msgs: Message[] | undefined, parts: Record<string, Part[]>) => MessageWithParts[];
+    hydrate: (sessionID: string, msgs: Array<{
+        info: Message;
+        parts: Part[];
+    }>, opts?: {
+        source?: "cache" | "runtime";
+    }) => void;
+    reset: () => void;
+    getMessages: (sessionID: string) => MessageWithParts[];
+    statuses: Record<string, SessionStatus>;
+}
+export declare function hasOnlyCacheSourcedMessages(sessionID: string): boolean;
+export declare const useSyncStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SyncState>>;