@lunora/angular 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/index.mjs

@@ -1,13 +1,19 @@
+export { agent } from './packem_shared/agent-DDKvrG4u.mjs';
+export { agentChat } from './packem_shared/agentChat-C7kUEwO9.mjs';
+export { agentState } from './packem_shared/agentState-C8GWf3t3.mjs';
+export { agentToolEvents } from './packem_shared/agentToolEvents-sXgYggvi.mjs';
 export { auth } from './packem_shared/auth-Df9N87Z4.mjs';
 export { LUNORA_CLIENT, injectLunoraClient, provideLunora } from './packem_shared/LUNORA_CLIENT-DHUfNu9x.mjs';
 export { connectionStatus } from './packem_shared/connectionStatus-BlLodleK.mjs';
 export { flag, flags } from './packem_shared/flag-CGBo90HJ.mjs';
-export { hydratePreloaded } from './packem_shared/hydratePreloaded-ClRc-7rL.mjs';
-export { liveQuery } from './packem_shared/liveQuery-D5VQBOgf.mjs';
+export { hydratePreloaded } from './packem_shared/hydratePreloaded-DIpD1cAM.mjs';
+export { liveQuery } from './packem_shared/liveQuery-DVxKidjM.mjs';
 export { mutate } from './packem_shared/mutate-D3rEHwbb.mjs';
 export { mutator } from './packem_shared/mutator-BHL8bakL.mjs';
-export { infiniteQuery, paginatedQuery } from './packem_shared/infiniteQuery-DUV60k-n.mjs';
-export { presence } from './packem_shared/presence-h2xonCZM.mjs';
-export { rateLimit } from './packem_shared/rateLimit-CKcAig4M.mjs';
-export { subscription } from './packem_shared/subscription-Dd9dQiBB.mjs';
+export { infiniteQuery, paginatedQuery } from './packem_shared/infiniteQuery-nboKfr5E.mjs';
+export { presence } from './packem_shared/presence-BTuq19dS.mjs';
+export { rateLimit } from './packem_shared/rateLimit-I4kRT9qV.mjs';
+export { stream } from './packem_shared/stream-PL64AghO.mjs';
+export { subscription } from './packem_shared/subscription-oZ-WTmpp.mjs';
+export { voiceAgent } from './packem_shared/voiceAgent-DwbrDnB9.mjs';
 export { SKIP } from '@lunora/client/query';

package/dist/packem_shared/agent-DDKvrG4u.mjs

@@ -0,0 +1,31 @@
+import { inject, DestroyRef, computed, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { subscription } from './subscription-oZ-WTmpp.mjs';
+
+const agent = (options) => {
+  const { api, cancel: cancelReference, run: runReference, runArgs, threadKey } = options;
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const { data: threadData } = subscription(api.agents.agentThread, { key: threadKey }, { client, destroyRef });
+  const thread = computed(() => threadData());
+  const status = computed(() => thread()?.status);
+  const pending = signal(false);
+  const run = async (input, arguments_) => {
+    pending.set(true);
+    try {
+      await client.mutation(runReference, { input, threadKey, ...runArgs, ...arguments_ });
+    } finally {
+      pending.set(false);
+    }
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await client.mutation(cancelReference, { instanceId, threadKey });
+  };
+  return { cancel, pending: pending.asReadonly(), run, status, thread };
+};
+
+export { agent };

package/dist/packem_shared/agentChat-C7kUEwO9.mjs

@@ -0,0 +1,96 @@
+import { inject, DestroyRef, signal, computed } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { stream } from './stream-PL64AghO.mjs';
+import { subscription } from './subscription-oZ-WTmpp.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 agentChat = (options) => {
+  const { api, cancel: cancelReference, limit, send: sendReference, sendArgs, stream: streamReference, threadKey } = options;
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const messagesArguments = limit === void 0 ? { key: threadKey } : { key: threadKey, limit };
+  const { data: history } = subscription(api.agents.agentMessages, messagesArguments, { client, destroyRef });
+  const { data: threadData } = subscription(api.agents.agentThread, { key: threadKey }, { client, destroyRef });
+  const streamArguments = streamReference === void 0 ? "skip" : { key: threadKey };
+  const { chunks } = stream(streamReference ?? NO_STREAM_REF, streamArguments, { client, destroyRef });
+  const optimistic = signal([]);
+  let nextId = 0;
+  const thread = computed(() => threadData());
+  const status = computed(() => thread()?.status);
+  const durable = computed(() => history() ?? []);
+  const messages = computed(() => {
+    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 = computed(() => {
+    const assistantCount = durable().filter((message) => message.role === "assistant").length;
+    return chunks().filter((event) => event.kind !== "progress" && event.threadKey === threadKey && event.turn >= assistantCount).map((delta) => delta.text).join("");
+  });
+  const send = async (input, arguments_) => {
+    const id = nextId;
+    nextId += 1;
+    optimistic.set([...reconcileOptimistic(optimistic(), durable()), { content: input, id }]);
+    await client.mutation(sendReference, { input, threadKey, ...sendArgs, ...arguments_ });
+  };
+  const approve = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("agentChat: cannot approve — no in-flight run (thread has no instanceId)");
+    }
+    await client.mutation(api.agents.agentResolveApproval, {
+      decision: "approve",
+      instanceId,
+      threadKey,
+      toolCallId,
+      ...note === void 0 ? {} : { note }
+    });
+  };
+  const reject = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("agentChat: cannot reject — no in-flight run (thread has no instanceId)");
+    }
+    await client.mutation(api.agents.agentResolveApproval, {
+      decision: "reject",
+      instanceId,
+      threadKey,
+      toolCallId,
+      ...note === void 0 ? {} : { note }
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await client.mutation(cancelReference, { instanceId, threadKey });
+  };
+  return { approve, cancel, messages, reject, send, status, streamingText };
+};
+
+export { agentChat };

package/dist/packem_shared/agentState-C8GWf3t3.mjs

@@ -0,0 +1,10 @@
+import { computed } from '@angular/core';
+import { subscription } from './subscription-oZ-WTmpp.mjs';
+
+const agentState = (options) => {
+  const { data, error } = subscription(options.api.agents.agentState, { key: options.threadKey }, { client: options.client, destroyRef: options.destroyRef });
+  const state = computed(() => data());
+  return { error, state };
+};
+
+export { agentState };

package/dist/packem_shared/agentToolEvents-sXgYggvi.mjs

@@ -0,0 +1,59 @@
+import { inject, DestroyRef, computed } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { stream } from './stream-PL64AghO.mjs';
+import { subscription } from './subscription-oZ-WTmpp.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 agentToolEvents = (options) => {
+  const { api, limit, stream: streamReference, threadKey } = options;
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const messagesArguments = limit === void 0 ? { key: threadKey } : { key: threadKey, limit };
+  const { data: history } = subscription(api.agents.agentMessages, messagesArguments, { client, destroyRef });
+  const streamArguments = streamReference === void 0 ? "skip" : { key: threadKey };
+  const { chunks } = stream(streamReference ?? NO_STREAM_REF, streamArguments, { client, destroyRef });
+  const events = computed(() => {
+    const durable = history() ?? EMPTY_MESSAGES;
+    const derived = durable.flatMap((message) => toDurableEvent(message) ?? []);
+    for (const event of chunks()) {
+      if (event.kind === "progress" && event.threadKey === threadKey) {
+        derived.push({ data: event.data, toolCallId: event.toolCallId, type: "progress" });
+      }
+    }
+    return derived;
+  });
+  return { events };
+};
+
+export { agentToolEvents };

package/dist/packem_shared/{hydratePreloaded-ClRc-7rL.mjs → hydratePreloaded-DIpD1cAM.mjs}

@@ -1,28 +1,32 @@
 import { inject, DestroyRef, signal } from '@angular/core';
 import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription } from './platform-Dg8Bppgq.mjs';
 
 const hydratePreloaded = (preloaded, options = {}) => {
   const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
   const destroyRef = options.destroyRef ?? inject(DestroyRef);
   const { args, functionPath, shardKey, value } = preloaded;
   const data = signal(value);
   const error = signal(void 0);
   const functionReference = { __lunoraRef: functionPath };
-  const unsubscribe = client.subscribe(
-    functionReference,
-    args,
-    (next) => {
-      data.set(next);
-      error.set(void 0);
-    },
-    {
-      onError: (error_) => {
-        error.set(error_);
+  if (shouldOpenSubscription(fromInjectionContext)) {
+    const unsubscribe = client.subscribe(
+      functionReference,
+      args,
+      (next) => {
+        data.set(next);
+        error.set(void 0);
       },
-      shardKey
-    }
-  );
-  destroyRef.onDestroy(unsubscribe);
+      {
+        onError: (error_) => {
+          error.set(error_);
+        },
+        shardKey
+      }
+    );
+    destroyRef.onDestroy(unsubscribe);
+  }
   return { data: data.asReadonly(), error: error.asReadonly() };
 };
 

package/dist/packem_shared/{infiniteQuery-DUV60k-n.mjs → infiniteQuery-nboKfr5E.mjs}

@@ -1,6 +1,7 @@
 import { computed, inject, DestroyRef, signal } from '@angular/core';
-import { initialPages, rebalance, derivePaginationStatus, applyLoadMore } from '@lunora/client/pagination';
+import { initialPages, derivePaginationStatus, applyLoadMore, rebalance } from '@lunora/client/pagination';
 import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription } from './platform-Dg8Bppgq.mjs';
 
 const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
 const buildPageArgs = (page, baseArgs) => {
@@ -11,6 +12,7 @@ const buildPageArgs = (page, baseArgs) => {
 };
 const usePaginatedCore = (reference, baseArgs, options) => {
   const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
   const destroyRef = options.destroyRef ?? inject(DestroyRef);
   const { initialNumItems, shardKey } = options;
   const functionPath = reference["__lunoraRef"];
@@ -47,7 +49,7 @@ const usePaginatedCore = (reference, baseArgs, options) => {
       }
     }
   };
-  const syncSubscriptions = (currentPages) => {
+  const syncPass = (currentPages) => {
     const wantedKeys = /* @__PURE__ */ new Set();
     for (const page of currentPages) {
       wantedKeys.add(buildPageKey(functionPath, buildPageArgs(page, narrowedArgs)));
@@ -102,7 +104,26 @@ const usePaginatedCore = (reference, baseArgs, options) => {
       coveredKeys.add(key);
     }
   };
-  if (baseArgs !== "skip") {
+  let syncing = false;
+  let resyncRequested = false;
+  const syncSubscriptions = (currentPages) => {
+    if (syncing) {
+      resyncRequested = true;
+      return;
+    }
+    syncing = true;
+    try {
+      let pagesToSync = currentPages;
+      do {
+        resyncRequested = false;
+        syncPass(pagesToSync);
+        pagesToSync = pages();
+      } while (resyncRequested);
+    } finally {
+      syncing = false;
+    }
+  };
+  if (baseArgs !== "skip" && shouldOpenSubscription(fromInjectionContext)) {
     syncSubscriptions(pages());
   }
   doRebuildPageResults();

package/dist/packem_shared/liveQuery-DVxKidjM.mjs

@@ -0,0 +1,32 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { createQuerySubscription } from '@lunora/client/query';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription } from './platform-Dg8Bppgq.mjs';
+
+const liveQuery = (reference, args, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const value = signal(void 0);
+  if (shouldOpenSubscription(fromInjectionContext)) {
+    const unsubscribe = createQuerySubscription(
+      client,
+      reference,
+      args,
+      {
+        onData: (next) => {
+          value.set(next);
+        },
+        onError: options.onError,
+        onReset: () => {
+          value.set(void 0);
+        }
+      },
+      { shardKey: options.shardKey }
+    );
+    destroyRef.onDestroy(unsubscribe);
+  }
+  return value.asReadonly();
+};
+
+export { liveQuery };

package/dist/packem_shared/platform-Dg8Bppgq.mjs

@@ -0,0 +1,14 @@
+import { inject, PLATFORM_ID, NgZone } from '@angular/core';
+
+const shouldOpenSubscription = (fromInjectionContext) => {
+  if (!fromInjectionContext) {
+    return true;
+  }
+  return inject(PLATFORM_ID, { optional: true }) !== "server";
+};
+const runOutsideAngular = (fromInjectionContext, register) => {
+  const zone = fromInjectionContext ? inject(NgZone, { optional: true }) : void 0;
+  return zone ? zone.runOutsideAngular(register) : register();
+};
+
+export { runOutsideAngular as r, shouldOpenSubscription as s };

package/dist/packem_shared/presence-BTuq19dS.mjs

@@ -0,0 +1,77 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription, r as runOutsideAngular } from './platform-Dg8Bppgq.mjs';
+
+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 `${prefix}-${Date.now().toString(36)}`;
+};
+
+const DEFAULT_INTERVAL_MS = 1e4;
+const presence = (roomId, options) => {
+  const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const { heartbeat, listPresent, shardKey } = options;
+  const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const sessionId = options.sessionId ?? randomSessionId();
+  const present = signal(void 0);
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    throw new RangeError(`presence intervalMs must be a positive number, got ${String(intervalMs)}`);
+  }
+  let latestData = options.data;
+  const sendHeartbeat = () => {
+    const args = { roomId, sessionId };
+    if (latestData !== void 0) {
+      args.data = latestData;
+    }
+    client.mutation(heartbeat, args, { shardKey }).catch(() => void 0);
+  };
+  const setData = (next) => {
+    latestData = next;
+    sendHeartbeat();
+  };
+  if (shouldOpenSubscription(fromInjectionContext)) {
+    const releaseConnectionContext = client.acquireConnectionContext({ roomId, sessionId }, { shardKey });
+    sendHeartbeat();
+    const onVisible = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "visible") {
+        sendHeartbeat();
+      }
+    };
+    const intervalHandle = runOutsideAngular(fromInjectionContext, () => {
+      if (typeof document !== "undefined") {
+        document.addEventListener("visibilitychange", onVisible);
+      }
+      return setInterval(sendHeartbeat, intervalMs);
+    });
+    const listArgs = { roomId };
+    const unsubscribe = client.subscribe(
+      listPresent,
+      listArgs,
+      (value) => {
+        present.set(value);
+      },
+      { shardKey }
+    );
+    destroyRef.onDestroy(() => {
+      clearInterval(intervalHandle);
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", onVisible);
+      }
+      releaseConnectionContext();
+      unsubscribe();
+    });
+  }
+  return { present: present.asReadonly(), sessionId, setData };
+};
+
+export { presence };

package/dist/packem_shared/{rateLimit-CKcAig4M.mjs → rateLimit-I4kRT9qV.mjs}

@@ -6,11 +6,9 @@ const rateLimit = (config, options = {}) => {
   const now = options.now ?? Date.now;
   const tickMs = options.tickMs ?? 1e3;
   let value;
-  const epoch = signal(0);
   const computeStatus = () => evaluate(config, value, { consume: false, count: 1, now: now(), reserve: false }).status;
   const status = signal(computeStatus());
   const bump = () => {
-    epoch.update((v) => v + 1);
     status.set(computeStatus());
   };
   let intervalHandle;

package/dist/packem_shared/stream-PL64AghO.mjs

@@ -0,0 +1,47 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const stream = (reference, args, options = {}) => {
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const chunks = signal([]);
+  const error = signal(void 0);
+  const status = signal("idle");
+  let active = true;
+  let cancelIterable;
+  const cancel = () => {
+    active = false;
+    cancelIterable?.();
+  };
+  if (args !== "skip") {
+    status.set("streaming");
+    const iterable = client.stream(reference, args, { maxBuffer: options.maxBuffer, shardKey: options.shardKey });
+    cancelIterable = () => {
+      iterable.cancel();
+    };
+    (async () => {
+      try {
+        for await (const chunk of iterable) {
+          if (!active) {
+            return;
+          }
+          chunks.update((current) => [...current, chunk]);
+        }
+        if (active) {
+          status.set("complete");
+        }
+      } catch (streamError) {
+        if (!active) {
+          return;
+        }
+        error.set(streamError instanceof Error ? streamError : new Error(String(streamError)));
+        status.set("error");
+      }
+    })().catch(() => {
+    });
+  }
+  destroyRef.onDestroy(cancel);
+  return { cancel, chunks: chunks.asReadonly(), error: error.asReadonly(), status: status.asReadonly() };
+};
+
+export { stream };

package/dist/packem_shared/{subscription-Dd9dQiBB.mjs → subscription-oZ-WTmpp.mjs}

@@ -1,13 +1,15 @@
 import { inject, DestroyRef, signal } from '@angular/core';
 import { createQuerySubscription } from '@lunora/client/query';
 import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+import { s as shouldOpenSubscription } from './platform-Dg8Bppgq.mjs';
 
 const subscription = (reference, args, options = {}) => {
   const client = resolveLunoraClient(options.client);
+  const fromInjectionContext = options.destroyRef === void 0;
   const destroyRef = options.destroyRef ?? inject(DestroyRef);
   const data = signal(void 0);
   const error = signal(void 0);
-  if (args !== "skip") {
+  if (args !== "skip" && shouldOpenSubscription(fromInjectionContext)) {
     const userOnError = options.onError;
     const unsubscribe = createQuerySubscription(
       client,