@alia.onl/sdk 22.1.1 → 22.2.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @alia.onl/sdk
 
+## 22.2.0
+
+- **Awaited host tools.** `AliaHostToolDefinition.awaitsResult: true` declares a tool whose
+  result the model reads in the same turn ("this tab's text"). When the model calls it, the
+  runtime runs the host's `execute` once and POSTs `{ toolCallId, outcome, detail?, result? }` at
+  once to `/v1/chat/turns/:turnId/host-results` through the authenticated API (with the app
+  assertion), instead of queueing the outcome for the next request. `AliaHostOutcome.result`
+  carries a string or JSON value of at most `HOST_RESULT_MAX_CHARS` (100,000) characters as JSON;
+  a larger one is answered as `failed`. A failed POST is reported to `AliaHostTools.onUndelivered`
+  and never retried. `parseHostAction` keeps `awaitsResult` and `turnId`.
+- **Personalization off for one turn.** `AliaTurnRequest.personalization: false` (read at send
+  time from `host.turnRequest()`) sends `personalization: false`: Alia reads no memory and offers
+  no memory tools for that turn. Nothing is sent otherwise.
+- `awaitsResult` is sent only for a tool that declares it, so existing hosts send the same bytes.
+  A host that declares one needs the Alia API receiver for awaited host tools deployed first
+  (`docs/agent-embedding.md` §2); an older API refuses the field with `invalid_host`.
+
+## 22.1.2
+
+- **Every entry type-checks under `noUncheckedIndexedAccess`.** The SDK ships source, so a
+  consumer compiling with `"noUncheckedIndexedAccess": true` (Astro) type-checked the SDK under
+  it too and got errors from indexed reads in the runtime, thread, citation and catalogue-tool
+  modules (27 from `@alia.onl/sdk/runtime` alone). Each read is now narrowed where the index is
+  known to be in range, with a loop over the values where that is simpler. Behaviour is unchanged.
+- `check:entry-types` compiles every entry with `noUncheckedIndexedAccess` on, so CI keeps it so.
+
 ## 22.1.1
 
 - A delayed Stop acknowledgement cannot idle a newer turn, replace its sidebar

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alia.onl/sdk",
-  "version": "22.1.1",
+  "version": "22.2.0",
   "description": "Alia AI chat SDK — the conversation runtime, chat UI, voice calls and dictation for Oxy apps",
   "main": "src/index.ts",
   "react-native": "src/index.ts",

package/src/components/AmbientField.tsx

@@ -554,7 +554,7 @@ export const AmbientField = memo(function AmbientField({
                   key={config.w}
                   config={config}
                   index={index}
-                  color={palette[index]}
+                  color={palette[index] as string}
                   vw={vw}
                   vh={vh}
                   vmax={vmax}

package/src/components/ReplyMarkdown.tsx

@@ -121,7 +121,7 @@ function parseBlockData(type: string, match: RegExpExecArray): any {
     switch (type) {
       case 'COMPACTLIST': {
         const title = match[1];
-        const itemsText = match[2];
+        const itemsText = match[2] ?? '';
         const items = itemsText
           .split('\n')
           .filter((line) => line.trim().startsWith('-'))
@@ -140,26 +140,26 @@ function parseBlockData(type: string, match: RegExpExecArray): any {
         return {
           type: match[1],
           title: match[2],
-          content: match[3].trim(),
+          content: (match[3] ?? '').trim(),
         };
       }
       case 'COMPARISON': {
         const title = match[1];
-        const content = match[2];
+        const content = match[2] ?? '';
         const leftMatch = content.match(/LEFT:\s*({.*?})/s);
         const rightMatch = content.match(/RIGHT:\s*({.*?})/s);
         const conclusionMatch = content.match(/CONCLUSION:\s*(.*?)$/s);
 
         return {
           title,
-          left: leftMatch ? JSON.parse(leftMatch[1]) : {},
-          right: rightMatch ? JSON.parse(rightMatch[1]) : {},
-          conclusion: conclusionMatch ? conclusionMatch[1].trim() : undefined,
+          left: leftMatch ? JSON.parse(leftMatch[1] ?? '') : {},
+          right: rightMatch ? JSON.parse(rightMatch[1] ?? '') : {},
+          conclusion: conclusionMatch ? (conclusionMatch[1] ?? '').trim() : undefined,
         };
       }
       case 'TIMELINE': {
         const title = match[1];
-        const itemsText = match[2];
+        const itemsText = match[2] ?? '';
         const items = itemsText
           .split('\n')
           .filter((line) => line.trim().startsWith('-'))
@@ -183,7 +183,7 @@ function parseBlockData(type: string, match: RegExpExecArray): any {
       }
       case 'CREDIBILITY': {
         return {
-          level: parseInt(match[1], 10),
+          level: parseInt(match[1] ?? '', 10),
           source: match[2],
         };
       }

package/src/components/canvas/ChartRenderer.tsx

@@ -30,7 +30,7 @@ export function ChartRenderer({ data, title }: ChartRendererProps) {
     labels.map((label, i) => ({ label, value: values[i] || 0 }));
 
   if (chartType === 'line' && datasets.length === 1) {
-    const series = datasets[0];
+    const series = datasets[0] as (typeof datasets)[number];
     return (
       <LineChartCard
         title={series.label || title}

package/src/components/thought/ThoughtPanel.tsx

@@ -129,7 +129,7 @@ function StepsTab({ steps, lifecycle }: { steps: ThoughtStep[]; lifecycle: TurnL
     return <EmptyState variant="compact" description={t('thought.noSteps')} />;
   }
 
-  const last = steps[steps.length - 1];
+  const last = steps[steps.length - 1] as (typeof steps)[number];
   const tail = live && (last.type === 'thinking' || last.type === 'writing') ? last : null;
   const rows = tail === null ? steps : steps.slice(0, -1);
 

package/src/components/thread/AliaThread.tsx

@@ -213,7 +213,7 @@ export const AliaThread = memo(function AliaThread({
     if (index !== lastReplyIndex || index !== rows.length - 1) return false;
     if (index < history.length || failedTurn?.anchorMessageId === message.id) return false;
     for (let i = index - 1; i >= history.length; i--) {
-      if (rows[i].role === 'user') return true;
+      if (rows[i]?.role === 'user') return true;
     }
     return false;
   };
@@ -223,7 +223,7 @@ export const AliaThread = memo(function AliaThread({
    * an old message belongs to the stretch that ended, not to the one on screen.
    */
   const conversationOf = (index: number): string | undefined =>
-    index < history.length ? history[index].conversationId : conversationId;
+    index < history.length ? history[index]?.conversationId : conversationId;
 
   // ── Which rows are mounted, and the scroll that goes with them ──
   /** The row a cursor jump was aimed at, as an index into what is shown, or -1. */

package/src/hooks/useTimelineWindow.ts

@@ -169,7 +169,7 @@ export function useTimelineWindow({
         anchor: kept,
         offset: lastOffset.current ?? 0,
         atBottom: atBottom.current,
-        probeId: rows[first],
+        probeId: rows[first] as string,
       });
     };
   }, [scrollKey]);

package/src/lib/audio-level.ts

@@ -71,8 +71,8 @@ export function levelFromFrames(frames: readonly number[]): number {
   if (frames.length === 0) return 0;
 
   let sumSquares = 0;
-  for (let index = 0; index < frames.length; index += 1) {
-    sumSquares += frames[index] * frames[index];
+  for (const frame of frames) {
+    sumSquares += frame * frame;
   }
   const rms = Math.sqrt(sumSquares / frames.length);
 

package/src/lib/catalogue-tool.ts

@@ -12,7 +12,7 @@ const CANONICAL_TOOL = /^(?:oxy|self)_([a-z][a-z0-9-]{0,63})__([A-Za-z0-9_-]+)$/
 /** The app and tool of a canonical catalogue tool name, or `null` for any other name. */
 export function parseCatalogueTool(toolName: string): { app: string; tool: string } | null {
   const match = CANONICAL_TOOL.exec(toolName);
-  return match ? { app: match[1], tool: match[2] } : null;
+  return match ? { app: match[1] ?? '', tool: match[2] ?? '' } : null;
 }
 
 /** The renderer key of a tool name (`<app>:<tool>`), or `null` when it is not a catalogue tool. */

package/src/lib/citations.ts

@@ -180,7 +180,7 @@ export function splitReferences(
     const m = REFERENCE_LINE_RE.exec(line);
     if (m) {
       flush();
-      current = { id: Number(m[1]), rest: m[2] };
+      current = { id: Number(m[1]), rest: m[2] ?? '' };
     } else if (current && line.trim().length > 0) {
       // A legacy entry's URL sits on the indented line after the title.
       current.rest += ` ${line.trim()}`;

package/src/runtime/config.tsx

@@ -39,6 +39,11 @@ export interface AliaTurnRequest {
   /** Only `false` is sent: `true` is the server's default. */
   webSearch?: boolean;
   deepResearch?: boolean;
+  /**
+   * `false` turns personalization off for this turn: Alia reads no memory of the person, recalls
+   * nothing and offers no memory tools. The conversation is stored as usual. Only `false` is sent.
+   */
+  personalization?: false;
 }
 
 /** Why the thread asks its host to show the thought panel. */

package/src/runtime/conversations.ts

@@ -275,13 +275,14 @@ function upsertOnTop(
   if (moveExisting) {
     // Remove the conversation from its current position (if it is in any page)
     for (let i = 0; i < pages.length; i++) {
-      const existingIndex = pages[i].conversations.findIndex((c) => c.id === row.id);
+      const page = pages[i] as ConversationsPage;
+      const existingIndex = page.conversations.findIndex((c) => c.id === row.id);
       if (existingIndex >= 0) {
         pages[i] = {
-          ...pages[i],
+          ...page,
           conversations: [
-            ...pages[i].conversations.slice(0, existingIndex),
-            ...pages[i].conversations.slice(existingIndex + 1),
+            ...page.conversations.slice(0, existingIndex),
+            ...page.conversations.slice(existingIndex + 1),
           ],
         };
         break;
@@ -347,7 +348,10 @@ export function useSaveConversation() {
             id,
             title: offlineTitle,
             lastMessage,
-            createdAt: existingIndex >= 0 ? conversations[existingIndex].createdAt : new Date(),
+            createdAt:
+              existingIndex >= 0
+                ? (conversations[existingIndex] as Conversation).createdAt
+                : new Date(),
             updatedAt: new Date(),
             messages,
           };

package/src/runtime/host-tools.ts

@@ -7,10 +7,15 @@
  * the outcome with its NEXT request, where it becomes that call's result. A host tool is never
  * authority over data: it moves the host's own screen.
  *
- * Two rules hold here, in a queue that knows nothing of React:
+ * A tool declared with `awaitsResult: true` is read in the SAME turn instead ("this tab's text",
+ * "the open tabs"): the server waits, and this client answers it at once on the turn's
+ * `host-results` route with the outcome and the `result` its `execute` returned.
+ *
+ * Three rules hold here, in a queue that knows nothing of React:
  *  - an action is performed at most once, whatever the stream repeats;
  *  - an outcome stays queued until a request carrying it has been accepted, so a turn that ends
- *    before its outcomes are sent hands them to the next one.
+ *    before its outcomes are sent hands them to the next one;
+ *  - an awaited action's answer is sent once, never queued and never retried.
  */
 
 import type { HostAction } from './stream-events';
@@ -23,6 +28,11 @@ export interface AliaHostToolDefinition {
   description: string;
   /** A JSON Schema with an object root. */
   inputSchema: Record<string, unknown>;
+  /**
+   * The model reads this tool's result in the same turn: `execute`'s `result` goes back to it at
+   * once. Needs an Alia API with awaited host tools (`docs/agent-embedding.md` §2).
+   */
+  awaitsResult?: boolean;
 }
 
 export const HOST_OUTCOMES = ['applied', 'inline', 'rejected', 'stale', 'failed'] as const;
@@ -33,6 +43,11 @@ export interface AliaHostOutcome {
   outcome: AliaHostOutcomeKind;
   /** At most 500 characters; longer is cut. */
   detail?: string;
+  /**
+   * What an awaited tool read, for the model: a string or any JSON value, at most
+   * {@link HOST_RESULT_MAX_CHARS} characters as JSON. Ignored for a tool that does not await.
+   */
+  result?: unknown;
 }
 
 /**
@@ -48,6 +63,11 @@ export interface AliaHostTools {
   definitions: readonly AliaHostToolDefinition[];
   /** Perform `action` and say what came of it. Called once per action. */
   execute: (action: HostAction) => Promise<AliaHostOutcome>;
+  /**
+   * An awaited action's answer could not be delivered (the request failed). It is not retried:
+   * the model reads that the app did not answer in time.
+   */
+  onUndelivered?: (action: HostAction, error: unknown) => void;
 }
 
 /** An outcome as a request carries it. */
@@ -57,6 +77,11 @@ export interface HostOutcomeRecord {
   detail?: string;
 }
 
+/** An awaited action's answer, as `POST /v1/chat/turns/:turnId/host-results` carries it. */
+export interface HostResultRecord extends HostOutcomeRecord {
+  result?: unknown;
+}
+
 /** The request's `host` member. */
 export interface HostRequest {
   app: string;
@@ -68,6 +93,21 @@ export interface HostRequest {
 
 const DETAIL_LIMIT = 500;
 
+/** The server's bound on an awaited action's `result`, as JSON. */
+export const HOST_RESULT_MAX_CHARS = 100_000;
+
+function resultOf(result: unknown): { result?: unknown } | 'too_large' {
+  if (result === undefined || result === null) return {};
+  let text: string | undefined;
+  try {
+    text = JSON.stringify(result);
+  } catch {
+    return {};
+  }
+  if (text === undefined) return {};
+  return text.length > HOST_RESULT_MAX_CHARS ? 'too_large' : { result };
+}
+
 function record(toolCallId: string, outcome: AliaHostOutcome | undefined): HostOutcomeRecord {
   const kind = HOST_OUTCOMES.includes(outcome?.outcome as AliaHostOutcomeKind)
     ? (outcome?.outcome as AliaHostOutcomeKind)
@@ -92,25 +132,41 @@ export class HostOutcomeQueue {
   ): Promise<boolean> {
     if (this.performed.has(action.toolCallId)) return false;
     this.performed.add(action.toolCallId);
-    let outcome: AliaHostOutcome;
-    if (tools === undefined || app === undefined || action.app !== app) {
-      outcome = { outcome: 'rejected', detail: 'This app did not declare that tool.' };
-    } else if (!tools.definitions.some((tool) => tool.name === action.name)) {
-      outcome = { outcome: 'rejected', detail: `Unknown tool "${action.name}".` };
-    } else {
-      try {
-        outcome = await tools.execute(action);
-      } catch (error) {
-        outcome = {
-          outcome: 'failed',
-          detail: error instanceof Error ? error.message : 'The app could not do it.',
-        };
-      }
-    }
+    const outcome = await perform(action, tools, app);
     this.ready.push(record(action.toolCallId, outcome));
     return true;
   }
 
+  /**
+   * Perform an awaited `action` once and `send` its answer at once, with its result. A failed send
+   * is reported to the host's `onUndelivered` and not retried. `false` when the action had already
+   * been performed.
+   */
+  async answer(
+    action: HostAction,
+    tools: AliaHostTools | undefined,
+    app: string | undefined,
+    send: (answer: HostResultRecord) => Promise<unknown>,
+  ): Promise<boolean> {
+    if (this.performed.has(action.toolCallId)) return false;
+    this.performed.add(action.toolCallId);
+    const outcome = await perform(action, tools, app);
+    const result = resultOf((outcome as AliaHostOutcome | undefined)?.result);
+    const answer: HostResultRecord =
+      result === 'too_large'
+        ? record(action.toolCallId, {
+            outcome: 'failed',
+            detail: 'The result was too large to send.',
+          })
+        : { ...record(action.toolCallId, outcome), ...result };
+    try {
+      await send(answer);
+    } catch (error) {
+      tools?.onUndelivered?.(action, error);
+    }
+    return true;
+  }
+
   /** The outcomes ready to send, oldest first. */
   pending(): HostOutcomeRecord[] {
     return [...this.ready];
@@ -127,6 +183,27 @@ export class HostOutcomeQueue {
   }
 }
 
+async function perform(
+  action: HostAction,
+  tools: AliaHostTools | undefined,
+  app: string | undefined,
+): Promise<AliaHostOutcome> {
+  if (tools === undefined || app === undefined || action.app !== app) {
+    return { outcome: 'rejected', detail: 'This app did not declare that tool.' };
+  }
+  if (!tools.definitions.some((tool) => tool.name === action.name)) {
+    return { outcome: 'rejected', detail: `Unknown tool "${action.name}".` };
+  }
+  try {
+    return await tools.execute(action);
+  } catch (error) {
+    return {
+      outcome: 'failed',
+      detail: error instanceof Error ? error.message : 'The app could not do it.',
+    };
+  }
+}
+
 /**
  * The `host` member of a request: the chat's `app` and its host tools (none is an empty list),
  * or nothing for a chat that names no app — Alia's own.
@@ -143,10 +220,12 @@ export function hostRequest(
   return {
     app,
     version: 1,
-    tools: (tools?.definitions ?? []).map(({ name, description, inputSchema }) => ({
+    tools: (tools?.definitions ?? []).map(({ name, description, inputSchema, awaitsResult }) => ({
       name,
       description,
       inputSchema,
+      // Only when declared: an API before awaited host tools refuses the unknown field.
+      ...(awaitsResult === true ? { awaitsResult: true as const } : {}),
     })),
     ...(outcomes.length === 0 ? {} : { outcomes: [...outcomes] }),
   };

package/src/runtime/index.ts

@@ -33,13 +33,14 @@ export {
   useAgentProfile,
 } from './agents';
 export type { AliaAgentFeature, AliaAgentProfile, AliaAgentStarter, FeatureOffer } from './agents';
-export { HOST_OUTCOMES, HostOutcomeQueue, hostRequest } from './host-tools';
+export { HOST_OUTCOMES, HOST_RESULT_MAX_CHARS, HostOutcomeQueue, hostRequest } from './host-tools';
 export type {
   AliaHostAction,
   AliaHostOutcome,
   AliaHostOutcomeKind,
   AliaHostToolDefinition,
   AliaHostTools,
+  HostResultRecord as AliaHostResultRecord,
 } from './host-tools';
 export { FEATURE_ENTITLEMENT_REQUIRED, parseConsultEvent, parseHostAction } from './stream-events';
 export type { ConsultAgent, ConsultEvent } from './stream-events';

package/src/runtime/message-history.ts

@@ -102,7 +102,7 @@ export function normalizeConversationMessages(messages: readonly Message[]): Mes
   messages = messages.filter((message) => message.role !== 'system');
 
   for (let index = 0; index < messages.length; index += 1) {
-    const current = messages[index];
+    const current = messages[index] as Message;
     const placeholder = messages[index + 1];
     const duplicate = messages[index + 2];
 

package/src/runtime/routes.ts

@@ -11,6 +11,8 @@
  */
 export const API_ROUTES = {
   chat: '/v1/chat/completions',
+  /** The answer to an awaited host action, read by the turn that is waiting for it. */
+  hostResults: (turnId: string) => `/v1/chat/turns/${encodeURIComponent(turnId)}/host-results`,
   conversations: {
     list: '/v1/conversations',
     save: '/v1/conversations',

package/src/runtime/stream-events.ts

@@ -125,15 +125,29 @@ export interface HostAction {
   app: string;
   name: string;
   input: Record<string, unknown>;
+  /**
+   * The model is waiting for this action's result within the same turn: its outcome is answered
+   * at once on the turn's `host-results` route, never with the next request.
+   */
+  awaitsResult?: true;
+  /** The turn that waits, present exactly when `awaitsResult` is. */
+  turnId?: string;
 }
 
 /** The host action an `alia.host_action` frame carries, or `null` when it is not well-formed. */
 export function parseHostAction(data: unknown): HostAction | null {
   if (!isObject(data) || data.eventVersion !== 1) return null;
-  const { toolCallId, app, name, input } = data;
+  const { toolCallId, app, name, input, awaitsResult, turnId } = data;
   if (!isText(toolCallId) || !isText(app) || !isText(name)) return null;
   if (input !== undefined && !isObject(input)) return null;
-  return { toolCallId, app, name, input: (input as Record<string, unknown> | undefined) ?? {} };
+  if (awaitsResult !== undefined && (awaitsResult !== true || !isText(turnId))) return null;
+  return {
+    toolCallId,
+    app,
+    name,
+    input: (input as Record<string, unknown> | undefined) ?? {},
+    ...(awaitsResult === true ? { awaitsResult: true as const, turnId: turnId as string } : {}),
+  };
 }
 
 /** The error code that ends a turn an agent's feature gate refused (§5). */

package/src/runtime/thread/thought-utils.ts

@@ -718,8 +718,9 @@ export function turnTiming(
   const index = messages.findIndex((m) => m.id === message.id);
   let sendStamp: number | null = null;
   for (let i = index - 1; i >= 0; i -= 1) {
-    if (messages[i].role === 'user') {
-      sendStamp = stampToMs(messages[i].createdAt);
+    const earlier = messages[i];
+    if (earlier?.role === 'user') {
+      sendStamp = stampToMs(earlier.createdAt);
       break;
     }
   }

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

@@ -95,7 +95,7 @@ export function threadHistory(
 ): ThreadMessage[] {
   const history: ThreadMessage[] = [];
   for (let page = pages.length - 1; page >= 0; page -= 1) {
-    for (const message of pages[page].messages) {
+    for (const message of pages[page]?.messages ?? []) {
       if (message.conversationId === activeConversationId) continue;
       history.push({ ...message, id: message.id ?? message.cursor });
     }

package/src/runtime/thread/timeline.ts

@@ -76,7 +76,7 @@ function tailStart(count: number): number {
 /** The anchor that keeps exactly the rows mounted now, from the row at `start`. */
 export function pinAnchor(ids: readonly string[], start: number): TimelineAnchor {
   if (start <= 0 || ids.length === 0) return TOP;
-  return { kind: 'row', id: ids[start] };
+  return { kind: 'row', id: ids[start] as string };
 }
 
 /**
@@ -124,7 +124,7 @@ export function sameTimelineShape(previous: readonly Shape[], next: readonly Sha
   if (previous === next) return true;
   if (previous.length !== next.length) return false;
   for (let i = 0; i < next.length; i += 1) {
-    if (!sameShape(previous[i], next[i])) return false;
+    if (!sameShape(previous[i] as Shape, next[i] as Shape)) return false;
   }
   return true;
 }

package/src/runtime/thread/tool-cards.ts

@@ -125,8 +125,8 @@ function toPoints(series: readonly PricePoint[], intraday: boolean, locale: stri
 
 /** First-to-last change as a ratio, or none for a run that started at nothing. */
 function runDelta(series: readonly PricePoint[]): number | undefined {
-  const first = series[0][1];
-  const last = series[series.length - 1][1];
+  const first = (series[0] as PricePoint)[1];
+  const last = (series[series.length - 1] as PricePoint)[1];
   return first === 0 ? undefined : (last - first) / first;
 }
 
@@ -189,7 +189,7 @@ export function marketChart(data: MarketCardData, t: Translate, locale: string):
       id,
       label: t(`market.range.${id}`),
       data: toPoints(run, id === '1D', locale),
-      headline: quoted(data.price) ? data.price : run[run.length - 1][1],
+      headline: quoted(data.price) ? data.price : (run[run.length - 1] as PricePoint)[1],
       delta: id === '1D' && quoted(data.changePct) ? data.changePct / 100 : runDelta(run),
     });
   }
@@ -205,7 +205,7 @@ export function marketChart(data: MarketCardData, t: Translate, locale: string):
   if (intraday.length >= 2) {
     notes.push(
       [
-        `${t('market.open')} ${format(intraday[0])}`,
+        `${t('market.open')} ${format(intraday[0] as number)}`,
         `${t('market.dayHigh')} ${format(Math.max(...intraday))}`,
         `${t('market.dayLow')} ${format(Math.min(...intraday))}`,
       ].join(' · '),
@@ -220,7 +220,9 @@ export function marketChart(data: MarketCardData, t: Translate, locale: string):
   return {
     title: `${data.name} · ${data.symbol}`,
     ranges,
-    defaultRange: ranges.some((r) => r.id === '1D') ? '1D' : ranges[0].id,
+    defaultRange: ranges.some((r) => r.id === '1D')
+      ? '1D'
+      : (ranges[0] as (typeof ranges)[number]).id,
     format,
     formatAxisValue: (value) => formatAxis(value, locale),
     notes,
@@ -275,7 +277,7 @@ export function faircoinChart(
       id,
       label: t(`faircoin.range.${id}`),
       data: toPoints(run, id === '24h', locale),
-      headline: quoted(data.price) ? data.price : run[run.length - 1][1],
+      headline: quoted(data.price) ? data.price : (run[run.length - 1] as PricePoint)[1],
       delta: id === '24h' && quoted(data.changePct) ? data.changePct / 100 : runDelta(run),
     });
   }
@@ -331,7 +333,9 @@ export function faircoinChart(
     chart: {
       title: `${t('faircoin.name')} · ${t('faircoin.symbol')}`,
       ranges,
-      defaultRange: ranges.some((r) => r.id === '24h') ? '24h' : ranges[0].id,
+      defaultRange: ranges.some((r) => r.id === '24h')
+        ? '24h'
+        : (ranges[0] as (typeof ranges)[number]).id,
       format,
       formatAxisValue: (value) => formatAxis(value, locale),
       notes: [],

package/src/runtime/use-conversation-stream.ts

@@ -3,6 +3,7 @@ import { useOxy } from '@oxy.so/services/ui/client';
 import { useQueryClient } from '@tanstack/react-query';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useLabels } from '../lib/labels';
+import { useAliaApi } from './api';
 import { useAppAssertionHeaders } from './app-assertion';
 import { type AliaArtifact, useAliaRuntime } from './config';
 import {
@@ -162,6 +163,8 @@ export function useConversationStream({
   hostTools,
 }: UseConversationStreamOptions = {}) {
   const { apiUrl, streamFetch, host, app } = useAliaRuntime();
+  /** Where an awaited host action's answer goes: the same account and app assertion as the turn. */
+  const api = useAliaApi();
   /** Read at send time and when an action arrives: the host's declaration may change between turns. */
   const hostToolsRef = useRef(hostTools);
   hostToolsRef.current = hostTools;
@@ -658,7 +661,11 @@ export function useConversationStream({
          * when the callback was built would send the state the composer had
          * before the person touched it.
          */
-        const { deepResearch: deepResearchMode, webSearch } = host.turnRequest?.() ?? {};
+        const {
+          deepResearch: deepResearchMode,
+          webSearch,
+          personalization,
+        } = host.turnRequest?.() ?? {};
 
         // The host's tools, and the outcomes of the actions it performed since the last request.
         const outcomes = hostOutcomesRef.current.pending();
@@ -688,6 +695,8 @@ export function useConversationStream({
             // Only sent when OFF. `true` is the server's default and every
             // request has behaved that way, so sending it would be noise.
             ...(webSearch === false && { webSearch: false }),
+            // Only sent when OFF, like web search: absent is the server's default.
+            ...(personalization === false && { personalization: false }),
             // The power level (or a device model). Oxy picks the model of that
             // level; the client never names a hosted model.
             ...(model && { model }),
@@ -897,7 +906,7 @@ export function useConversationStream({
                           const idx = invocations.findIndex((t) => t.toolCallId === tool_call_id);
                           if (idx >= 0) {
                             invocations[idx] = {
-                              ...invocations[idx],
+                              ...(invocations[idx] as ToolInvocation),
                               state: 'result',
                               result: output,
                             };
@@ -939,13 +948,28 @@ export function useConversationStream({
                     // Performed here, by the client that declared it, once; its outcome rides
                     // the next request. The stream does not wait for it.
                     const action = parseHostAction(parsed);
-                    if (action !== null) {
-                      void hostOutcomesRef.current.dispatch(
+                    if (action === null) continue;
+                    if (action.awaitsResult && action.turnId !== undefined) {
+                      // The turn waits for this one: its answer goes back at once, through the
+                      // same authenticated API (and app assertion) the turn's account uses.
+                      const turnSignal = controller.signal;
+                      const route = API_ROUTES.hostResults(action.turnId);
+                      void hostOutcomesRef.current.answer(
                         action,
                         hostToolsRef.current,
                         appRef.current,
+                        async (answer) => {
+                          if (turnSignal.aborted) throw new Error('The turn ended');
+                          await api.post(route, answer, { signal: turnSignal });
+                        },
                       );
+                      continue;
                     }
+                    void hostOutcomesRef.current.dispatch(
+                      action,
+                      hostToolsRef.current,
+                      appRef.current,
+                    );
                     continue;
                   }
                   case 'alia.title': {
@@ -1254,7 +1278,11 @@ export function useConversationStream({
                       const idx = invocations.findIndex((t) => t.toolCallId === tool_call_id);
 
                       if (idx >= 0) {
-                        invocations[idx] = { ...invocations[idx], state: 'result', result: output };
+                        invocations[idx] = {
+                          ...(invocations[idx] as ToolInvocation),
+                          state: 'result',
+                          result: output,
+                        };
                       } else {
                         invocations.push({
                           toolCallId: tool_call_id,
@@ -1413,6 +1441,7 @@ export function useConversationStream({
       }
     },
     [
+      api,
       apiUrl,
       streamFetch,
       host,

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

@@ -435,7 +435,8 @@ export function useConversationThread({
     (assistantMessageId: string): Message | undefined => {
       const idx = messages.findIndex((msg) => msg.id === assistantMessageId);
       for (let i = idx - 1; i >= 0; i--) {
-        if (messages[i].role === 'user') return messages[i];
+        const earlier = messages[i];
+        if (earlier?.role === 'user') return earlier;
       }
       return undefined;
     },