@alia.onl/sdk 15.7.0 → 19.0.0

package/src/runtime/use-thread-history.ts

@@ -0,0 +1,64 @@
+import { useInfiniteQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { useAliaApi } from './api';
+import { errorStatus } from './error-utils';
+import { aliaQueryKeys } from './query-keys';
+import { AGENT_ROUTES } from './routes';
+import { type ThreadPage, threadHistory } from './thread/thread-history';
+
+/**
+ * Everything said in this thread before the conversation on screen, a page at a time, going back.
+ *
+ * The screen streams into the most recent conversation of the thread and knows nothing older;
+ * the thread's messages route is what crosses the seams into the stretches before it. Pages are
+ * pulled as the reader approaches the top, never eagerly — a thread has no end going backwards,
+ * and the first page is already everything a reader who does not scroll will see.
+ *
+ * `nextCursor` is what says whether anything older remains, and it is the server's answer rather
+ * than a count: a page that comes back empty after its live messages are dropped is ordinary, and
+ * treating that as the end would stop the history dead on any thread whose current conversation
+ * is long.
+ */
+
+/** How many messages a page carries. The server clamps its own maximum. */
+const PAGE_SIZE = 50;
+
+/** A 404 is the answer — the agent does not exist or is not the person's, and asking again does not change it. */
+export function retryThreadRead(failureCount: number, error: unknown): boolean {
+  return errorStatus(error) !== 404 && failureCount < 2;
+}
+
+export function useThreadHistory(
+  handle: string | undefined,
+  activeConversationId: string | undefined,
+) {
+  const api = useAliaApi();
+  const query = useInfiniteQuery({
+    queryKey: aliaQueryKeys.threads.messages(handle ?? ''),
+    queryFn: async ({ pageParam }): Promise<ThreadPage> => {
+      const { data } = await api.get<ThreadPage>(AGENT_ROUTES.threadMessages(handle ?? ''), {
+        params: { limit: PAGE_SIZE, before: pageParam },
+      });
+      return data;
+    },
+    initialPageParam: undefined as string | undefined,
+    getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
+    // Nothing to page through until the thread has answered which conversation is the live one:
+    // without it every message would be history, including the ones already on screen.
+    enabled: (handle?.length ?? 0) > 0 && activeConversationId !== undefined,
+    retry: retryThreadRead,
+  });
+
+  const messages = useMemo(
+    () => threadHistory(query.data?.pages ?? [], activeConversationId ?? ''),
+    [query.data?.pages, activeConversationId],
+  );
+
+  return {
+    messages,
+    /** Whether a page older than the ones held remains to be asked for. */
+    hasMore: query.hasNextPage,
+    isLoadingMore: query.isFetchingNextPage,
+    loadMore: query.fetchNextPage,
+  };
+}

package/src/runtime/use-thread-search.ts

@@ -0,0 +1,95 @@
+import { useInfiniteQuery, useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { useAliaApi } from './api';
+import { aliaQueryKeys } from './query-keys';
+import { AGENT_ROUTES } from './routes';
+import {
+  type ThreadMessage,
+  type ThreadPage,
+  type ThreadSearchHit,
+  threadHistory,
+} from './thread/thread-history';
+import { retryThreadRead } from './use-thread-history';
+
+/**
+ * Finding something said earlier in a thread, and getting back to it.
+ *
+ * Two halves, and the second is why the first is worth anything: a hit tells you the message
+ * exists, and its CURSOR is what opens the stretch of thread around it — however many
+ * conversations back it lives. Without that, a result list is a wall you can read and not reach.
+ */
+
+/** How many hits to ask for. The server clamps its own maximum. */
+const HIT_LIMIT = 30;
+
+export function useThreadSearch(handle: string | undefined, query: string) {
+  const api = useAliaApi();
+  const trimmed = query.trim();
+
+  return useQuery({
+    queryKey: aliaQueryKeys.threads.search(handle ?? '', trimmed),
+    queryFn: async (): Promise<ThreadSearchHit[]> => {
+      const { data } = await api.get<{ hits: ThreadSearchHit[] }>(
+        AGENT_ROUTES.threadSearch(handle ?? ''),
+        { params: { q: trimmed, limit: HIT_LIMIT } },
+      );
+      return data.hits;
+    },
+    // An empty query is not a search, and asking for one would return the thread's most recent
+    // everything under the guise of a result.
+    enabled: (handle?.length ?? 0) > 0 && trimmed.length > 0,
+    // What was said cannot change, so a query already asked is answered from the cache.
+    staleTime: 1000 * 60 * 5,
+    retry: retryThreadRead,
+  });
+}
+
+/** How many messages a window carries, half of them before the hit. */
+const WINDOW_SIZE = 40;
+
+/**
+ * The stretch of thread around one message, opened from a search hit.
+ *
+ * `at=` rather than `before=`: `before` is exclusive, so the one message the window exists to
+ * reveal would be the one missing from it.
+ *
+ * Reading further back from here is the same paging as anywhere else — the window's own oldest
+ * cursor continues it — so this is an infinite query too, and only its first page is addressed
+ * differently. There is no paging FORWARD: the way back to the present is leaving the window, not
+ * walking to it.
+ */
+export function useThreadWindow(handle: string | undefined, cursor: string | null) {
+  const api = useAliaApi();
+  const query = useInfiniteQuery({
+    queryKey: aliaQueryKeys.threads.window(handle ?? '', cursor ?? ''),
+    queryFn: async ({ pageParam }): Promise<ThreadPage> => {
+      const { data } = await api.get<ThreadPage>(AGENT_ROUTES.threadMessages(handle ?? ''), {
+        params:
+          pageParam === undefined
+            ? { limit: WINDOW_SIZE, at: cursor ?? undefined }
+            : { limit: WINDOW_SIZE, before: pageParam },
+      });
+      return data;
+    },
+    initialPageParam: undefined as string | undefined,
+    getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
+    enabled: (handle?.length ?? 0) > 0 && cursor !== null,
+    retry: retryThreadRead,
+  });
+
+  // Nothing is dropped here, unlike the tail: a window is a view of the PAST, and the live
+  // conversation is not on screen underneath it to be duplicated. The empty string is a
+  // conversation id no message has.
+  const messages: ThreadMessage[] = useMemo(
+    () => threadHistory(query.data?.pages ?? [], ''),
+    [query.data?.pages],
+  );
+
+  return {
+    messages,
+    hasMore: query.hasNextPage,
+    isLoadingMore: query.isFetchingNextPage,
+    loadMore: query.fetchNextPage,
+    isLoading: query.isPending && cursor !== null,
+  };
+}

package/src/runtime/use-turn-edit.ts

@@ -0,0 +1,99 @@
+import { useCallback, useRef } from 'react';
+import { getTextFromContent } from '../lib/content-utils';
+import type { Message, SendOptions } from './types';
+import type { AliaAttachment } from '../types';
+import { useComposerDraft, useComposerDraftStore, type DraftTarget } from './composer-draft-store';
+
+export interface TurnEditOptions {
+  /** The composer the edit happens in: this chat's draft. */
+  target: DraftTarget;
+  messages: readonly Message[];
+  /** The options a question was sent with, when this screen sent it. */
+  turnOptionsOf?: (userMessageId: string) => SendOptions | undefined;
+  /** Send the rewrite in place of the question (`useChatConversation.editMessage`). */
+  onEditMessage?: (
+    messageId: string,
+    text: string,
+    options?: SendOptions,
+    attachments?: AliaAttachment[],
+  ) => Promise<boolean>;
+}
+
+/**
+ * Rewriting a question already sent, in the composer (#608 §7).
+ *
+ * Before the template this was an "Editing message" strip over the input, with
+ * the id in the screen's own `useState` — so leaving the chat and coming back
+ * forgot the edit and the next send became a new turn. The edit lives in the
+ * chat's draft now (`composer-draft-store.ts`), like the text it is made of:
+ * per account and per conversation, and gone when the draft is.
+ *
+ * - `start` loads the question's words and the connector and skills it was sent
+ *   with into the composer, keeping aside what the composer held. A question
+ *   this screen did not send has no record of its options, so the composer's
+ *   own choice stays.
+ * - `cancel` gives the composer back what it held.
+ * - `submit` sends the rewrite; a failure leaves the composer still editing,
+ *   with the words back in it (the send path restores those).
+ *
+ * `editing` is the edit only while its question is still in the thread: a
+ * conversation cleared, or cut back by another edit, takes it away, and the
+ * composer goes back to writing a new turn.
+ */
+export function useTurnEdit({ target, messages, turnOptionsOf, onEditMessage }: TurnEditOptions) {
+  const draftEdit = useComposerDraft(target).editing;
+  const editing =
+    draftEdit !== undefined && messages.some((m) => m.id === draftEdit.messageId)
+      ? draftEdit
+      : undefined;
+
+  // Read through a ref: `start` is a prop of every row in the thread, and an
+  // identity that changed per streamed token would re-render all of them.
+  const latestMessages = useRef(messages);
+  latestMessages.current = messages;
+
+  const start = useCallback(
+    (messageId: string) => {
+      const message = latestMessages.current.find((m) => m.id === messageId);
+      if (message === undefined) return;
+      const store = useComposerDraftStore.getState();
+      const current = store.drafts[target ?? ''];
+      const sentWith = turnOptionsOf?.(messageId);
+      store.startEdit(store.address(target), {
+        messageId,
+        text: getTextFromContent(message.content),
+        mcpServerId: sentWith?.mcpServerId ?? current?.mcpServerId ?? null,
+        skillNames: sentWith?.skillNames ?? current?.skillNames ?? [],
+      });
+    },
+    [target, turnOptionsOf],
+  );
+
+  const cancel = useCallback(() => {
+    const store = useComposerDraftStore.getState();
+    store.cancelEdit(store.address(target));
+  }, [target]);
+
+  /** Send `text` in place of the question being edited. The caller has cleared the draft. */
+  const submit = useCallback(
+    async (
+      text: string,
+      options?: SendOptions,
+      attachments?: AliaAttachment[],
+    ): Promise<boolean> => {
+      if (editing === undefined || onEditMessage === undefined) return false;
+      const address = useComposerDraftStore.getState().address(target);
+      const sent = await onEditMessage(editing.messageId, text, options, attachments);
+      if (!sent) useComposerDraftStore.getState().restore(address, { editing });
+      return sent;
+    },
+    [editing, onEditMessage, target],
+  );
+
+  return {
+    editing: onEditMessage === undefined ? undefined : editing,
+    start: onEditMessage === undefined ? undefined : start,
+    cancel,
+    submit,
+  };
+}

package/src/tools.ts

@@ -22,5 +22,5 @@ export type { AskedOption, AskedQuestion, QuestionAnswer } from './lib/questions
 export { classifyIntake, MAX_ATTACHMENT_BYTES } from './lib/attachment-intake';
 export { toolCallStatus } from './lib/tool-call-status';
 export type { ToolCallStatus } from './lib/tool-call-status';
-export { englishWorkLog } from './lib/work-log-copy';
-export type { Translate } from './lib/work-log-copy';
+export { englishCopy } from './lib/copy';
+export type { Translate } from './lib/copy';

package/src/types.ts

@@ -1,4 +1,3 @@
-import type { ComponentType } from 'react';
 import type { SharedValue } from 'react-native-reanimated';
 import type { VoiceErrorCode } from './lib/speech-messages';
 import type { VoiceCloseReason } from './lib/voice-protocol';
@@ -9,6 +8,8 @@ import type { VoiceCloseReason } from './lib/voice-protocol';
 export interface AliaSuggestion {
   id: string;
   text: string;
+  /** It has blanks to fill: picking it puts it in the composer for the person to finish, instead of sending it. */
+  template?: boolean;
 }
 
 // ── Composer Types ──
@@ -51,43 +52,10 @@ export interface PlanStep {
   toolName?: string;
 }
 
-export interface PendingPlan {
+/** A plan the agent shows before it works (`alia.plan_preview`). Shown only: nothing waits on it. */
+export interface MessagePlan {
   planId: string;
   steps: PlanStep[];
-  approved: boolean;
-  rejected: boolean;
-}
-
-export interface ChatMessage {
-  id: string;
-  role: 'user' | 'assistant' | 'system';
-  content: string | Array<{ type: string; [key: string]: unknown }>;
-  toolInvocations?: ToolInvocation[];
-  createdAt: number;
-  /** Extended thinking / reasoning content */
-  thinking?: string;
-  /** Deep research progress metadata */
-  researchProgress?: ResearchProgress;
-  /** Plan preview data (pending approval) */
-  pendingPlan?: PendingPlan;
-  /** Message origin: text chat or voice */
-  source?: 'text' | 'voice';
-  /** Speaker identity in voice mode */
-  speaker?: 'primary';
-  /** Whether a voice transcript is still streaming */
-  isStreaming?: boolean;
-  /** Delegated agent identity */
-  /** `character` is the agent's look as the server stores it (JSON), parsed where it is drawn. */
-  agentInfo?: { id: string; name: string; character?: unknown };
-}
-
-export interface ToolInvocation {
-  toolName: string;
-  state: 'call' | 'partial-call' | 'result';
-  args?: Record<string, unknown>;
-  result?: unknown;
-  /** OpenAI-format tool call ID for matching calls to results */
-  toolCallId?: string;
 }
 
 // ── Voice Types ──
@@ -173,18 +141,21 @@ export interface VoiceSessionProps {
   locale?: string;
   /** Which of the product's two voices answers. */
   voice?: 'male' | 'female';
-  /** Called on every room, agent, or transcript change. */
-  onStateChange: (state: VoiceSessionState) => void;
+  /** Alia stored messages of the call in the conversation: refresh the thread. */
+  onMessagesSaved?: (conversationId: string, messageIds: readonly string[]) => void;
   /**
-   * The call is over — the user ended it, it errored, or the room dropped. When it
-   * failed, say why, so the shell can tell the person instead of silently going back.
+   * What the call tells the person, in the chat's language (`labels`): a failure, a call moved
+   * to another device, the time limit near. Omitted, Bloom's toast.
    */
-  onEnd: (error?: string) => void;
+  onNotice?: (notice: VoiceNotice) => void;
+  /** Called on every room, agent, or transcript change. */
+  onStateChange: (state: VoiceSessionState) => void;
+  /** The call is over: hung up, failed, ended by the server or dropped. The person was told why. */
+  onEnd: () => void;
 }
 
-/**
- * The voice capability handed to `AliaChatScreen` / `AliaChatSheet`. Pass
- * `VoiceSession` from `@alia.onl/sdk/voice` to enable voice calls; leave it out
- * and the chat is text-only, with the audio engine absent from the module graph.
- */
-export type VoiceSessionComponent = ComponentType<VoiceSessionProps>;
+/** Something the call tells the person: a failure, how it ended, or that it is about to end. */
+export interface VoiceNotice {
+  kind: 'error' | 'info' | 'warning';
+  text: string;
+}

package/worklets/voice-processors.js

@@ -0,0 +1,152 @@
+// The web voice call's two AudioWorklet processors (`src/lib/voice-audio-engine.ts`).
+//
+// Served from Alia's web origin, content-addressed (`/sdk/voice-worklets/<revision>.js`,
+// `src/lib/voice-worklets.ts`), so a host page loads it under `script-src https://alia.onl`
+// instead of a `blob:` URL its CSP would have to allow. Plain JavaScript with no imports: a
+// worklet module runs in the AudioWorkletGlobalScope. Every number it needs arrives in
+// `processorOptions`, so the bytes stay the same while the engine's settings change.
+
+class AliaVoiceCapture extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const { streamSampleRate, frameSamples } = options.processorOptions;
+    this.ratio = sampleRate / streamSampleRate;
+    this.frameSamples = frameSamples;
+    this.t = 0;
+    this.prev = 0;
+    this.frame = new Int16Array(frameSamples);
+    this.filled = 0;
+  }
+  process(inputs) {
+    const input = inputs[0]?.[0];
+    if (!input || input.length === 0) return true;
+    const n = input.length;
+    while (this.t < n - 1) {
+      const i = Math.floor(this.t);
+      const f = this.t - i;
+      const a = i < 0 ? this.prev : input[i];
+      const b = input[i + 1];
+      let s = a + (b - a) * f;
+      s = s < -1 ? -1 : s > 1 ? 1 : s;
+      this.frame[this.filled++] = s < 0 ? s * 0x8000 : s * 0x7fff;
+      if (this.filled === this.frame.length) {
+        const out = this.frame;
+        this.port.postMessage(out.buffer, [out.buffer]);
+        this.frame = new Int16Array(this.frameSamples);
+        this.filled = 0;
+      }
+      this.t += this.ratio;
+    }
+    this.t -= n;
+    this.prev = input[n - 1];
+    return true;
+  }
+}
+registerProcessor('alia-voice-capture', AliaVoiceCapture);
+
+class AliaVoicePlayback extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const { streamSampleRate, prebufferMs, prebufferIdleMs } = options.processorOptions;
+    this.streamSampleRate = streamSampleRate;
+    this.prebufferSamples = (streamSampleRate * prebufferMs) / 1000;
+    this.prebufferIdleSeconds = prebufferIdleMs / 1000;
+    this.step = streamSampleRate / sampleRate;
+    this.queue = [];
+    this.queued = 0;
+    this.pos = 0;
+    this.buffering = true;
+    this.lastChunkAt = 0;
+    this.item = null;
+    this.played = 0;
+    this.sinceReport = 0;
+    this.sumSquares = 0;
+    this.count = 0;
+    this.port.onmessage = (event) => {
+      const message = event.data;
+      if (message.type === 'chunk') {
+        this.queue.push({ itemId: message.itemId, samples: message.samples });
+        this.queued += message.samples.length;
+        this.lastChunkAt = currentTime;
+      } else if (message.type === 'flush') {
+        const playedMs = this.item === null ? null : this.playedMs();
+        this.port.postMessage({ type: 'flushed', itemId: this.item, playedMs });
+        this.queue = [];
+        this.queued = 0;
+        this.pos = 0;
+        this.buffering = true;
+        this.item = null;
+        this.played = 0;
+      }
+    };
+  }
+  playedMs() {
+    return (this.played / this.streamSampleRate) * 1000;
+  }
+  report(force) {
+    if (!force && this.sinceReport < sampleRate / 20) return;
+    const rms = this.count === 0 ? 0 : Math.sqrt(this.sumSquares / this.count);
+    this.port.postMessage({ type: 'progress', itemId: this.item, playedMs: this.playedMs(), rms });
+    this.sinceReport = 0;
+    this.sumSquares = 0;
+    this.count = 0;
+  }
+  process(_inputs, outputs) {
+    const out = outputs[0][0];
+    if (this.buffering) {
+      const ready =
+        this.queued >= this.prebufferSamples ||
+        (this.queued > 0 && currentTime - this.lastChunkAt > this.prebufferIdleSeconds);
+      if (!ready) {
+        out.fill(0);
+        for (let c = 1; c < outputs[0].length; c++) outputs[0][c].fill(0);
+        return true;
+      }
+      this.buffering = false;
+    }
+    for (let k = 0; k < out.length; k++) {
+      const head = this.queue[0];
+      if (!head) {
+        out[k] = 0;
+        if (!this.buffering) {
+          this.buffering = true;
+          this.report(true);
+          this.port.postMessage({ type: 'idle' });
+        }
+        continue;
+      }
+      if (head.itemId !== this.item) {
+        this.item = head.itemId;
+        this.played = 0;
+        this.port.postMessage({ type: 'started', itemId: head.itemId });
+      }
+      const i = Math.floor(this.pos);
+      const f = this.pos - i;
+      const a = head.samples[i];
+      const b = i + 1 < head.samples.length ? head.samples[i + 1] : a;
+      const s = a + (b - a) * f;
+      out[k] = s;
+      this.sumSquares += s * s;
+      this.count++;
+      this.pos += this.step;
+      const consumed = Math.floor(this.pos);
+      if (consumed > 0) {
+        const taken = Math.min(consumed, head.samples.length);
+        this.played += taken;
+        this.queued -= taken;
+        if (consumed >= head.samples.length) {
+          this.queue.shift();
+          this.pos = 0;
+        } else {
+          head.samples = head.samples.subarray(consumed);
+          this.pos -= consumed;
+        }
+      }
+    }
+    for (let c = 1; c < outputs[0].length; c++) outputs[0][c].set(out);
+    this.sinceReport += out.length;
+    this.report(false);
+    return true;
+  }
+}
+registerProcessor('alia-voice-playback', AliaVoicePlayback);