@lunora/solid 1.0.0-alpha.22 → 1.0.0-alpha.24

package/dist/packem_shared/createAgent-D7EZBeql.mjs

@@ -0,0 +1,55 @@
+import { createMemo } from 'solid-js';
+import { createMutation } from './createMutation-LkrbhItI.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_MUTATION_REF = {
+  __lunoraRef: ""
+};
+const resolveMaybe = (value) => typeof value === "function" ? value() : value;
+const createAgent = (options) => {
+  const {
+    api,
+    cancel: cancelReference,
+    run: runReference,
+    runArgs,
+    threadKey
+  } = options;
+  const runMutation = createMutation(runReference);
+  const cancelMutation = createMutation(cancelReference ?? NO_MUTATION_REF);
+  const {
+    data: threadData
+  } = createSubscription(api.agents.agentThread, () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  });
+  const thread = createMemo(() => threadData());
+  const status = createMemo(() => thread()?.status);
+  const run = async (input, arguments_) => {
+    await runMutation.mutate({
+      input,
+      threadKey: resolveMaybe(threadKey),
+      ...runArgs,
+      ...arguments_
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({
+      instanceId,
+      threadKey: resolveMaybe(threadKey)
+    });
+  };
+  return {
+    cancel,
+    pending: runMutation.pending,
+    run,
+    status,
+    thread
+  };
+};
+
+export { NO_MUTATION_REF, createAgent, resolveMaybe };

package/dist/packem_shared/createAgentChat-CsoyE3RE.mjs

@@ -0,0 +1,150 @@
+import { createSignal, createMemo } from 'solid-js';
+import { resolveMaybe, NO_MUTATION_REF } from './createAgent-D7EZBeql.mjs';
+import { createMutation } from './createMutation-LkrbhItI.mjs';
+import { createStream } from './createStream-D9ONbGAw.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const reconcileOptimistic = (optimistic, durable) => {
+  const pool = durable.filter((message) => message.role === "user").map((message) => message.content);
+  return optimistic.filter((pending) => {
+    const index = pool.indexOf(pending.content);
+    if (index !== -1) {
+      pool.splice(index, 1);
+      return false;
+    }
+    return true;
+  });
+};
+const createAgentChat = (options) => {
+  const {
+    api,
+    cancel: cancelReference,
+    limit,
+    send: sendReference,
+    sendArgs,
+    stream: streamReference,
+    threadKey
+  } = options;
+  const {
+    data: history
+  } = createSubscription(api.agents.agentMessages, () => {
+    const key = resolveMaybe(threadKey);
+    return limit === void 0 ? {
+      key
+    } : {
+      key,
+      limit
+    };
+  });
+  const {
+    data: threadData
+  } = createSubscription(api.agents.agentThread, () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  });
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  };
+  const {
+    chunks
+  } = createStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const sendMutation = createMutation(sendReference);
+  const cancelMutation = createMutation(cancelReference ?? NO_MUTATION_REF);
+  const approvalMutation = createMutation(api.agents.agentResolveApproval);
+  const [optimistic, setOptimistic] = createSignal([]);
+  let nextId = 0;
+  const thread = createMemo(() => threadData());
+  const status = createMemo(() => thread()?.status);
+  const durable = createMemo(() => history() ?? []);
+  const messages = createMemo(() => {
+    const rows = durable();
+    const visible = reconcileOptimistic(optimistic(), rows);
+    if (visible.length === 0) {
+      return rows;
+    }
+    return [...rows, ...visible.map((pending, index) => {
+      return {
+        content: pending.content,
+        optimistic: true,
+        role: "user",
+        seq: rows.length + index
+      };
+    })];
+  });
+  const streamingText = createMemo(() => {
+    const key = resolveMaybe(threadKey);
+    const assistantCount = durable().filter((message) => message.role === "assistant").length;
+    return chunks().filter((event) => event.kind !== "progress" && event.threadKey === key && event.turn >= assistantCount).map((delta) => delta.text).join("");
+  });
+  const send = async (input, arguments_) => {
+    const id = nextId;
+    nextId += 1;
+    setOptimistic((previous) => [...reconcileOptimistic(previous, durable()), {
+      content: input,
+      id
+    }]);
+    await sendMutation.mutate({
+      input,
+      threadKey: resolveMaybe(threadKey),
+      ...sendArgs,
+      ...arguments_
+    });
+  };
+  const approve = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("createAgentChat: cannot approve — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({
+      decision: "approve",
+      instanceId,
+      threadKey: resolveMaybe(threadKey),
+      toolCallId,
+      ...note === void 0 ? {} : {
+        note
+      }
+    });
+  };
+  const reject = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("createAgentChat: cannot reject — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({
+      decision: "reject",
+      instanceId,
+      threadKey: resolveMaybe(threadKey),
+      toolCallId,
+      ...note === void 0 ? {} : {
+        note
+      }
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({
+      instanceId,
+      threadKey: resolveMaybe(threadKey)
+    });
+  };
+  return {
+    approve,
+    cancel,
+    messages,
+    reject,
+    send,
+    status,
+    streamingText
+  };
+};
+
+export { createAgentChat };

package/dist/packem_shared/createAgentState-DckYu3G8.mjs

@@ -0,0 +1,21 @@
+import { createMemo } from 'solid-js';
+import { resolveMaybe } from './createAgent-D7EZBeql.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const createAgentState = (options) => {
+  const {
+    data,
+    error
+  } = createSubscription(options.api.agents.agentState, () => {
+    return {
+      key: resolveMaybe(options.threadKey)
+    };
+  });
+  const state = createMemo(() => data());
+  return {
+    error,
+    state
+  };
+};
+
+export { createAgentState };

package/dist/packem_shared/createAgentToolEvents-UavTO16u.mjs

@@ -0,0 +1,99 @@
+import { createMemo } from 'solid-js';
+import { resolveMaybe } from './createAgent-D7EZBeql.mjs';
+import { createStream } from './createStream-D9ONbGAw.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const EMPTY_MESSAGES = [];
+const toDurableEvent = (message) => {
+  if (message.role === "assistant" && message.toolCalls) {
+    return message.toolCalls.map((call) => {
+      return {
+        input: call.input,
+        seq: message.seq,
+        toolCallId: call.id,
+        toolName: call.name,
+        type: "call"
+      };
+    });
+  }
+  if (message.role !== "tool") {
+    return void 0;
+  }
+  if (message.status === "awaiting_approval") {
+    return [{
+      seq: message.seq,
+      type: "awaiting-approval",
+      ...message.toolCallId === void 0 ? {} : {
+        toolCallId: message.toolCallId
+      },
+      ...message.toolName === void 0 ? {} : {
+        toolName: message.toolName
+      }
+    }];
+  }
+  return [{
+    output: message.content,
+    seq: message.seq,
+    type: "result",
+    ...message.status === "approved" || message.status === "rejected" ? {
+      status: message.status
+    } : {},
+    ...message.toolCallId === void 0 ? {} : {
+      toolCallId: message.toolCallId
+    },
+    ...message.toolName === void 0 ? {} : {
+      toolName: message.toolName
+    }
+  }];
+};
+const createAgentToolEvents = (options) => {
+  const {
+    api,
+    limit,
+    stream: streamReference,
+    threadKey
+  } = options;
+  const messagesArguments = () => {
+    const key = resolveMaybe(threadKey);
+    return limit === void 0 ? {
+      key
+    } : {
+      key,
+      limit
+    };
+  };
+  const {
+    data: history
+  } = createSubscription(api.agents.agentMessages, messagesArguments);
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  };
+  const {
+    chunks
+  } = createStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const events = createMemo(() => {
+    const key = resolveMaybe(threadKey);
+    const durable = history() ?? EMPTY_MESSAGES;
+    const derived = durable.flatMap((message) => toDurableEvent(message) ?? []);
+    for (const event of chunks()) {
+      if (event.kind === "progress" && event.threadKey === key) {
+        derived.push({
+          data: event.data,
+          toolCallId: event.toolCallId,
+          type: "progress"
+        });
+      }
+    }
+    return derived;
+  });
+  return {
+    events
+  };
+};
+
+export { createAgentToolEvents };

package/dist/packem_shared/{createFlag-DTGaIdMo.mjs → createFlag-Bu9YfzcJ.mjs}

@@ -1,43 +1,7 @@
 import { createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { s as stableStringify } from './stable-key-CGp4e2Ux.mjs';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
-const compareKeys = (a, b) => {
-  if (a < b) {
-    return -1;
-  }
-  return a > b ? 1 : 0;
-};
-const stableStringify = (value) => {
-  if (value === void 0) {
-    return "null";
-  }
-  if (typeof value === "bigint") {
-    throw new TypeError("stableStringify: cannot use a bigint in a cache key (query/subscription/shape args) — pass it as a string");
-  }
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const proto = Object.getPrototypeOf(value);
-  if (proto !== null && proto !== Object.prototype) {
-    const name = value.constructor?.name ?? "value";
-    throw new TypeError(`stableStringify: cannot use a ${name} in a cache key (query/subscription/shape args) — only plain objects, arrays, and JSON primitives are supported`);
-  }
-  const record = value;
-  const keys = Object.keys(record).toSorted(compareKeys);
-  const parts = [];
-  for (const key of keys) {
-    const raw = record[key];
-    if (raw === void 0) {
-      continue;
-    }
-    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
-  }
-  return `{${parts.join(",")}}`;
-};
-
 const FLAGS_EVAL_PATH = "__lunora_flags__:eval";
 const flagKind = (value) => {
   const kind = typeof value;

package/dist/packem_shared/{createInfiniteQuery-q2r4PSqD.mjs → createInfiniteQuery-Dy9k7Px2.mjs}

@@ -1,5 +1,6 @@
 import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
 import { createMemo, createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { s as stableStringify } from './stable-key-CGp4e2Ux.mjs';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const buildPageArgs = (page, baseArgs) => {
@@ -12,7 +13,7 @@ const buildPageArgs = (page, baseArgs) => {
     }
   };
 };
-const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${stableStringify(pageArgs)}`;
 const createPaginatedCore = (function_, args, options) => {
   const client = useLunora();
   const {
@@ -32,6 +33,22 @@ const createPaginatedCore = (function_, args, options) => {
     });
     setPageResults(updated);
   };
+  const migrateResultsForRebalance = (oldPages, newPages, baseArgs) => {
+    const keyOf = (page) => buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs));
+    for (const newPage of newPages) {
+      const newKey = keyOf(newPage);
+      if (resultsByKey.has(newKey)) {
+        continue;
+      }
+      const donor = oldPages.find((oldPage) => oldPage.lower === newPage.lower);
+      if (donor) {
+        const carried = resultsByKey.get(keyOf(donor));
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+        }
+      }
+    }
+  };
   const syncSubscriptions = (currentPages, baseArgs) => {
     const wantedKeys = /* @__PURE__ */ new Set();
     for (const page of currentPages) {
@@ -42,6 +59,7 @@ const createPaginatedCore = (function_, args, options) => {
         unsub();
         activeSubs.delete(key);
         pendingPageKeys.delete(key);
+        resultsByKey.delete(key);
       }
     }
     for (const page of currentPages) {
@@ -60,8 +78,10 @@ const createPaginatedCore = (function_, args, options) => {
         }
         rebuildPageResults(pages(), currentArgs);
         if (pendingPageKeys.size === 0) {
-          const next = rebalance(pages(), pageResults());
+          const latestPages = pages();
+          const next = rebalance(latestPages, pageResults());
           if (next) {
+            migrateResultsForRebalance(latestPages, next, currentArgs);
             setPages(next);
           }
         }

package/dist/packem_shared/{createPresence-DMiDP353.mjs → createPresence-DM2cVkiG.mjs}

@@ -1,12 +1,19 @@
 import { createSignal, onMount, onCleanup } from 'solid-js';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
-const makeSessionId = () => {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
+const randomSessionId = (prefix = "sess") => {
+  if (typeof crypto !== "undefined") {
+    if (typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    if (typeof crypto.getRandomValues === "function") {
+      const bytes = crypto.getRandomValues(new Uint8Array(16));
+      return `${prefix}-${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+    }
   }
-  return `sess-${Math.random().toString(36).slice(2)}-${String(Date.now())}`;
+  return `${prefix}-${Date.now().toString(36)}`;
 };
+
 const DEFAULT_INTERVAL_MS = 1e4;
 const createPresence = (roomId, options) => {
   const client = useLunora();
@@ -16,7 +23,7 @@ const createPresence = (roomId, options) => {
     listPresent,
     shardKey
   } = options;
-  const sessionId = options.sessionId ?? makeSessionId();
+  const sessionId = options.sessionId ?? randomSessionId();
   const [present, setPresent] = createSignal(void 0);
   let latestData = options.data;
   const sendHeartbeat = () => {

package/dist/packem_shared/createStream-D9ONbGAw.mjs

@@ -0,0 +1,70 @@
+import { createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
+
+const createStream = (function_, args, options = {}) => {
+  const client = useLunora();
+  const [chunks, setChunks] = createSignal([]);
+  const [error, setError] = createSignal(void 0);
+  const [status, setStatus] = createSignal("idle");
+  const resolveArgs = typeof args === "function" ? args : () => args;
+  let cancelCurrent;
+  const cancel = () => {
+    cancelCurrent?.();
+  };
+  createEffect(on(resolveArgs, (currentArgs) => {
+    setChunks(() => []);
+    setError(() => void 0);
+    if (currentArgs === "skip") {
+      setStatus("idle");
+      return;
+    }
+    setStatus("streaming");
+    let active = true;
+    const iterable = client.stream(function_, currentArgs, {
+      maxBuffer: options.maxBuffer,
+      shardKey: options.shardKey
+    });
+    const cancelIterable = () => {
+      iterable.cancel();
+    };
+    cancelCurrent = cancelIterable;
+    (async () => {
+      try {
+        for await (const chunk of iterable) {
+          if (!active) {
+            return;
+          }
+          setChunks((previous) => [...previous, chunk]);
+        }
+        if (active) {
+          setStatus("complete");
+        }
+      } catch (streamError) {
+        if (!active) {
+          return;
+        }
+        setError(() => streamError instanceof Error ? streamError : new Error(String(streamError)));
+        setStatus("error");
+      }
+    })().catch(() => {
+    });
+    onCleanup(() => {
+      active = false;
+      cancelIterable();
+      if (cancelCurrent === cancelIterable) {
+        cancelCurrent = void 0;
+      }
+    });
+  }));
+  onCleanup(() => {
+    cancel();
+  });
+  return {
+    cancel,
+    chunks,
+    error,
+    status
+  };
+};
+
+export { createStream };

package/dist/packem_shared/{createSubscription-C_ed4Rov.mjs → createSubscription-D3HbChGe.mjs}

@@ -1,4 +1,5 @@
 import { createQuerySubscription } from '@lunora/client/query';
+import { LunoraError } from '@lunora/errors';
 import { createSignal, createEffect, on, onCleanup } from 'solid-js';
 import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
@@ -19,7 +20,8 @@ const createSubscription = (function_, args, options = {}) => {
         setError(() => void 0);
       },
       onError: (subscriptionError) => {
-        setError(() => new Error(subscriptionError.message));
+        const normalized = subscriptionError.code ? new LunoraError(subscriptionError.code, subscriptionError.message) : new Error(subscriptionError.message);
+        setError(() => normalized);
         setData(() => void 0);
       },
       onReset: () => {