@lunora/angular 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/index.mjs

@@ -1,3 +1,7 @@
+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';
@@ -9,5 +13,7 @@ export { mutator } from './packem_shared/mutator-BHL8bakL.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/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/voiceAgent-DwbrDnB9.mjs

@@ -0,0 +1,401 @@
+import { inject, DestroyRef, signal } from '@angular/core';
+import { resolveLunoraClient } from './LUNORA_CLIENT-DHUfNu9x.mjs';
+
+const TARGET_SAMPLE_RATE = 16e3;
+const blockRms = (samples) => {
+  if (samples.length === 0) {
+    return 0;
+  }
+  let sum = 0;
+  for (const sample of samples) {
+    sum += sample * sample;
+  }
+  return Math.sqrt(sum / samples.length);
+};
+const toPcm16 = (samples, inputSampleRate) => {
+  const ratio = inputSampleRate / TARGET_SAMPLE_RATE;
+  const outLength = ratio > 1 ? Math.floor(samples.length / ratio) : samples.length;
+  const buffer = new ArrayBuffer(outLength * 2);
+  const view = new DataView(buffer);
+  for (let index = 0; index < outLength; index += 1) {
+    const sample = samples[Math.floor(index * ratio)] ?? 0;
+    const clamped = Math.max(-1, Math.min(1, sample));
+    view.setInt16(index * 2, clamped < 0 ? clamped * 32768 : clamped * 32767, true);
+  }
+  return new Uint8Array(buffer);
+};
+const createBrowserMicrophone = async (config) => {
+  const media = globalThis;
+  const getUserMedia = media.navigator?.mediaDevices?.getUserMedia.bind(media.navigator.mediaDevices);
+  const AudioContextClass = media.AudioContext ?? media.webkitAudioContext;
+  if (!getUserMedia || !AudioContextClass) {
+    throw new Error("voiceAgent: microphone capture requires getUserMedia + AudioContext (no browser audio available)");
+  }
+  const stream = await getUserMedia({ audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true } });
+  const context = new AudioContextClass();
+  const source = context.createMediaStreamSource(stream);
+  const processor = context.createScriptProcessor(4096, 1, 1);
+  let muted = false;
+  let sawSpeech = false;
+  let silentFor = 0;
+  let loudChunks = 0;
+  processor.onaudioprocess = (event) => {
+    const samples = event.inputBuffer.getChannelData(0);
+    const rms = muted ? 0 : blockRms(samples);
+    config.onLevel(rms);
+    if (muted) {
+      return;
+    }
+    config.onAudio(toPcm16(samples, context.sampleRate));
+    if (config.isSpeaking()) {
+      loudChunks = rms >= config.interruptThreshold ? loudChunks + 1 : 0;
+      if (loudChunks >= config.interruptChunks) {
+        loudChunks = 0;
+        config.onInterrupt();
+      }
+      return;
+    }
+    loudChunks = 0;
+    const chunkMs = samples.length / context.sampleRate * 1e3;
+    if (rms >= config.silenceThreshold) {
+      sawSpeech = true;
+      silentFor = 0;
+      return;
+    }
+    if (sawSpeech) {
+      silentFor += chunkMs;
+      if (silentFor >= config.silenceDurationMs) {
+        sawSpeech = false;
+        silentFor = 0;
+        config.onSilence();
+      }
+    }
+  };
+  source.connect(processor);
+  processor.connect(context.destination);
+  return {
+    setMuted: (next) => {
+      muted = next;
+    },
+    stop: () => {
+      processor.disconnect();
+      source.disconnect();
+      for (const track of stream.getTracks()) {
+        track.stop();
+      }
+      void context.close();
+    }
+  };
+};
+const createBrowserSpeaker = () => {
+  const media = globalThis;
+  const AudioContextClass = media.AudioContext ?? media.webkitAudioContext;
+  if (!AudioContextClass) {
+    throw new Error("voiceAgent: audio playback requires AudioContext (no browser audio available)");
+  }
+  const context = new AudioContextClass();
+  const sources = /* @__PURE__ */ new Set();
+  let playHead = 0;
+  let chain = Promise.resolve();
+  let generation = 0;
+  const scheduleChunk = async (bytes, scheduledGeneration) => {
+    if (scheduledGeneration !== generation) {
+      return;
+    }
+    let decoded;
+    try {
+      decoded = await context.decodeAudioData(bytes.buffer);
+    } catch {
+      return;
+    }
+    if (scheduledGeneration !== generation) {
+      return;
+    }
+    const node = context.createBufferSource();
+    node.buffer = decoded;
+    node.connect(context.destination);
+    const startAt = Math.max(context.currentTime, playHead);
+    node.start(startAt);
+    playHead = startAt + decoded.duration;
+    sources.add(node);
+    node.onended = () => {
+      sources.delete(node);
+    };
+  };
+  const enqueue = (audio) => {
+    const bytes = Uint8Array.from(audio);
+    const scheduledGeneration = generation;
+    chain = chain.then(() => scheduleChunk(bytes, scheduledGeneration));
+  };
+  const interrupt = () => {
+    generation += 1;
+    for (const node of sources) {
+      try {
+        node.stop();
+      } catch {
+      }
+    }
+    sources.clear();
+    playHead = context.currentTime;
+  };
+  return {
+    enqueue,
+    interrupt,
+    stop: () => {
+      interrupt();
+      void context.close();
+    }
+  };
+};
+
+const WS_OPEN = 1;
+const DEFAULT_SILENCE_THRESHOLD = 0.01;
+const DEFAULT_SILENCE_DURATION_MS = 1200;
+const DEFAULT_INTERRUPT_THRESHOLD = 0.15;
+const DEFAULT_INTERRUPT_CHUNKS = 3;
+const deriveWebSocketUrl = (url) => {
+  if (url.startsWith("https://")) {
+    return `wss://${url.slice("https://".length)}`;
+  }
+  if (url.startsWith("http://")) {
+    return `ws://${url.slice("http://".length)}`;
+  }
+  return url;
+};
+const agentNameFromReference = (voice) => {
+  const reference = voice["__lunoraRef"];
+  const withoutNamespace = reference.startsWith("agents:") ? reference.slice("agents:".length) : reference;
+  return withoutNamespace.endsWith("Voice") ? withoutNamespace.slice(0, -"Voice".length) : withoutNamespace;
+};
+const voiceSocketUrl = (baseUrl, agent, threadKey) => {
+  const base = deriveWebSocketUrl(baseUrl);
+  const trimmed = base.endsWith("/") ? base.slice(0, -1) : base;
+  const search = new URLSearchParams({ threadKey });
+  return `${trimmed}/_lunora/voice/${encodeURIComponent(agent)}?${search.toString()}`;
+};
+const voiceAgent = (options) => {
+  const {
+    createMicrophone = createBrowserMicrophone,
+    createSpeaker = createBrowserSpeaker,
+    createSocket,
+    interruptChunks = DEFAULT_INTERRUPT_CHUNKS,
+    interruptThreshold = DEFAULT_INTERRUPT_THRESHOLD,
+    silenceDurationMs = DEFAULT_SILENCE_DURATION_MS,
+    silenceThreshold = DEFAULT_SILENCE_THRESHOLD,
+    threadKey,
+    voice
+  } = options;
+  const client = resolveLunoraClient(options.client);
+  const destroyRef = options.destroyRef ?? inject(DestroyRef);
+  const status = signal("idle");
+  const connected = signal(false);
+  const transcript = signal("");
+  const interimTranscript = signal("");
+  const audioLevel = signal(0);
+  const isMuted = signal(false);
+  const error = signal(void 0);
+  let current;
+  let starting = false;
+  const sendFrame = (frame) => {
+    const socket = current?.socket;
+    if (socket?.readyState === WS_OPEN) {
+      socket.send(JSON.stringify(frame));
+      return true;
+    }
+    return false;
+  };
+  const teardown = () => {
+    const connection = current;
+    current = void 0;
+    if (connection) {
+      connection.microphone?.stop();
+      connection.speaker?.stop();
+      try {
+        connection.socket.close();
+      } catch {
+      }
+    }
+    starting = false;
+    connected.set(false);
+    status.set("idle");
+    audioLevel.set(0);
+  };
+  const endCall = () => {
+    teardown();
+  };
+  const handleServerFrame = (frame) => {
+    const connection = current;
+    switch (frame.type) {
+      case "assistant_delta": {
+        if (connection) {
+          connection.speaking = true;
+        }
+        status.set("speaking");
+        interimTranscript.update((current_) => current_ + frame.text);
+        break;
+      }
+      case "assistant_done": {
+        if (connection) {
+          connection.speaking = false;
+        }
+        interimTranscript.set(frame.text);
+        status.set("listening");
+        break;
+      }
+      case "error": {
+        if (connection) {
+          connection.speaking = false;
+        }
+        error.set(new Error(frame.message));
+        status.set("listening");
+        break;
+      }
+      case "interrupted": {
+        if (connection) {
+          connection.speaking = false;
+          connection.suppressAudio = false;
+        }
+        connection?.speaker?.interrupt();
+        status.set("listening");
+        break;
+      }
+      case "ready": {
+        if (connection) {
+          connection.audioFormat = frame.audioFormat;
+          connection.suppressAudio = false;
+        }
+        connected.set(true);
+        status.set("listening");
+        break;
+      }
+      case "user_transcript": {
+        if (connection) {
+          connection.suppressAudio = false;
+        }
+        transcript.set(frame.text);
+        interimTranscript.set("");
+        status.set("thinking");
+        break;
+      }
+    }
+  };
+  const handleAudioChunk = (audio) => {
+    const connection = current;
+    if (!connection || connection.suppressAudio) {
+      return;
+    }
+    connection.speaker ??= createSpeaker({ audioFormat: connection.audioFormat });
+    connection.speaking = true;
+    status.set("speaking");
+    connection.speaker.enqueue(audio);
+  };
+  const startCall = async () => {
+    if (current || starting) {
+      return;
+    }
+    starting = true;
+    error.set(void 0);
+    transcript.set("");
+    interimTranscript.set("");
+    try {
+      const url = voiceSocketUrl(client.url, agentNameFromReference(voice), threadKey);
+      const openSocket = createSocket ?? ((target) => new globalThis.WebSocket(target));
+      const socket = openSocket(url);
+      socket.binaryType = "arraybuffer";
+      const connection = {
+        audioFormat: "mp3",
+        microphone: void 0,
+        socket,
+        speaker: void 0,
+        speaking: false,
+        suppressAudio: false
+      };
+      current = connection;
+      socket.onmessage = (event) => {
+        if (typeof event.data === "string") {
+          try {
+            handleServerFrame(JSON.parse(event.data));
+          } catch {
+          }
+          return;
+        }
+        handleAudioChunk(new Uint8Array(event.data));
+      };
+      socket.onerror = () => {
+        error.set(new Error("voiceAgent: voice socket error"));
+      };
+      socket.onclose = () => {
+        if (current === connection) {
+          teardown();
+        }
+      };
+      const microphone = await createMicrophone({
+        interruptChunks,
+        interruptThreshold,
+        isSpeaking: () => current?.speaking ?? false,
+        onAudio: (pcm) => {
+          if (socket.readyState === WS_OPEN) {
+            socket.send(pcm);
+          }
+        },
+        onInterrupt: () => {
+          sendFrame({ type: "interrupt" });
+          current?.speaker?.interrupt();
+          if (current) {
+            current.speaking = false;
+            current.suppressAudio = true;
+          }
+          status.set("listening");
+        },
+        onLevel: (rms) => {
+          audioLevel.set(rms);
+        },
+        onSilence: () => {
+          sendFrame({ type: "commit" });
+          status.set("thinking");
+        },
+        silenceDurationMs,
+        silenceThreshold
+      });
+      if (current === connection) {
+        connection.microphone = microphone;
+        isMuted.set(false);
+        status.set("listening");
+      } else {
+        microphone.stop();
+      }
+    } catch (error_) {
+      error.set(error_ instanceof Error ? error_ : new Error(String(error_)));
+      teardown();
+    } finally {
+      starting = false;
+    }
+  };
+  const toggleMute = () => {
+    const next = !isMuted();
+    current?.microphone?.setMuted(next);
+    isMuted.set(next);
+    return next;
+  };
+  const sendText = (text) => {
+    if (sendFrame({ text, type: "text" })) {
+      status.set("thinking");
+    }
+  };
+  destroyRef.onDestroy(teardown);
+  return {
+    audioLevel: audioLevel.asReadonly(),
+    connected: connected.asReadonly(),
+    endCall,
+    error: error.asReadonly(),
+    interimTranscript: interimTranscript.asReadonly(),
+    isMuted: isMuted.asReadonly(),
+    sendText,
+    startCall,
+    status: status.asReadonly(),
+    toggleMute,
+    transcript: transcript.asReadonly()
+  };
+};
+
+export { voiceAgent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/angular",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.9",
   "description": "Angular reactive adapter for Lunora — signal-based live queries and mutations",
   "keywords": [
     "angular",
@@ -45,8 +45,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.21",
-    "@lunora/ratelimit": "1.0.0-alpha.7"
+    "@lunora/client": "1.0.0-alpha.23",
+    "@lunora/ratelimit": "1.0.0-alpha.8"
   },
   "peerDependencies": {
     "@angular/core": "^19.2.0 || ^20.0.0 || ^21.0.0 || ^22.0.0"