@ateam-ai-mobile/ui 0.1.8 → 0.1.10

package/src/voice/voiceSession.ts

@@ -39,6 +39,8 @@ import {
   type VoicePersona,
   type VoiceEvent,
   type VoiceSubscription,
+  type VoiceDeviceToolCall,
+  type VoiceDeviceToolReason,
 } from '@ateam-ai-mobile/plugin-runtime';
 
 // Re-export the transcript/state shapes under their historical names so existing
@@ -220,6 +222,33 @@ const buildObserveScript = (text: string) => `
 })(${JSON.stringify(text)}); true;
 `;
 
+/** How much of a device-tool error the snapshot keeps. The model still gets the
+ *  whole message; the snapshot is a diagnostic any reader of it can see, and a
+ *  tool's error can echo the call's arguments (what the user said). */
+const DEVICE_TOOL_ERROR_MAX = 200;
+
+function clipError(message: string): string {
+  const chars = Array.from(message); // by code point, so an emoji is never split
+  return chars.length > DEVICE_TOOL_ERROR_MAX
+    ? chars.slice(0, DEVICE_TOOL_ERROR_MAX - 1).join('') + '…'
+    : message;
+}
+
+/** A device-tool call's answer — what the mini-app gets back (plus its
+ *  correlationId) and what `lastDeviceTool` is built from. ONE object for both,
+ *  so the model's answer and the snapshot can never disagree. */
+type DeviceToolAnswer =
+  | { ok: true; result: any }
+  | { ok: false; reason: VoiceDeviceToolReason; error: string };
+
+/** A finished call, tagged with the session owner's pluginId when the tool is
+ *  that plugin's own; null when it is not (another solution's tool, the
+ *  platform's, an unregistered name, no name) — then only the platform sees it. */
+interface DeviceToolRecord {
+  owner: string | null;
+  call: VoiceDeviceToolCall;
+}
+
 /** Origin of a URL, or null if it can't be parsed. */
 function originOf(url?: string | null): string | null {
   if (!url) return null;
@@ -239,8 +268,11 @@ interface InternalState {
   userSpeaking: boolean;
   /** Epoch ms of the last speaking:false, or null before the first utterance. */
   lastUserSpeechEndedAt: number | null;
-  /** The last device-tool call the model made (name + when), or null. */
-  lastDeviceTool: { name: string; at: number } | null;
+  /** This session's finished device-tool calls: the LATEST per owner tag (see
+   *  DeviceToolRecord), in the order they finished. The platform reads the last
+   *  one; the owning plugin reads its own (lastDeviceToolFor) — one store, both
+   *  views derived from it. */
+  deviceToolCalls: DeviceToolRecord[];
   /** The WebView should be mounted (a session is wanted / live). */
   mounted: boolean;
   /** The WebView source, computed ONCE at start() so state changes (transcript,
@@ -262,13 +294,13 @@ const IDLE: InternalState = {
   muted: false,
   userSpeaking: false,
   lastUserSpeechEndedAt: null,
-  lastDeviceTool: null,
+  deviceToolCalls: [],
   mounted: false,
   webViewSource: null,
   skillSlug: undefined,
 };
 
-type Pending = { resolve: (s: VoiceSnapshot) => void; reject: (e: Error) => void; timer: any };
+type Pending = { caller: VoiceCaller; resolve: (s: VoiceSnapshot) => void; reject: (e: Error) => void; timer: any };
 
 class VoiceSessionManager implements VoiceSessionProvider {
   private state: InternalState = { ...IDLE };
@@ -325,6 +357,12 @@ class VoiceSessionManager implements VoiceSessionProvider {
    *  the bundle's own short `id`), so exact equality is the whole check. */
   private toolScope: string | null = null;
 
+  /** Bumped whenever a session begins or ends. A device-tool call remembers the
+   *  epoch it arrived in, and its outcome is recorded only if that session is
+   *  still the current one — a tool that finishes after hang-up (or after a new
+   *  call started) must not show up as the new session's last call. */
+  private sessionEpoch = 0;
+
   /** The platform (built-in sheet, mic indicator, session host) sees and
    *  controls any session — it is the user's own surface. A plugin caller may
    *  only touch a session it owns. */
@@ -365,11 +403,11 @@ class VoiceSessionManager implements VoiceSessionProvider {
     // different skillSlug does NOT restart it.
     if (this.state.callState === 'connected') {
       if (!this.canAccess(caller)) throw this.foreignError();
-      return this.realSnapshot();
+      return this.realSnapshot(caller);
     }
     if (this.state.callState === 'connecting') {
       if (!this.canAccess(caller)) throw this.foreignError();
-      return this.waitForConnect();
+      return this.waitForConnect(caller);
     }
 
     if (opts?.skills === 'none' && opts?.skillSlug) {
@@ -404,11 +442,11 @@ class VoiceSessionManager implements VoiceSessionProvider {
     const after = this.getInternal().callState;
     if (after === 'connected') {
       if (!this.canAccess(caller)) throw this.foreignError();
-      return this.realSnapshot();
+      return this.realSnapshot(caller);
     }
     if (after === 'connecting') {
       if (!this.canAccess(caller)) throw this.foreignError();
-      return this.waitForConnect();
+      return this.waitForConnect(caller);
     }
 
     // Idle → this caller becomes the owner of the new session. A NEW session
@@ -417,6 +455,7 @@ class VoiceSessionManager implements VoiceSessionProvider {
     this.toolScope = opts?.skills === 'none' && typeof caller === 'string' ? caller : null;
     this.frozenTools = null;
     this.frozenSessionId = null;
+    this.sessionEpoch++;
     const skillSlug = opts?.skillSlug;
     this.setState({
       callState: 'connecting',
@@ -425,12 +464,15 @@ class VoiceSessionManager implements VoiceSessionProvider {
       aiPartial: '',
       userPartial: '',
       muted: false,
+      // A session that ended from inside the voice page (not via stop()) left
+      // its calls here; the new session starts with none.
+      deviceToolCalls: [],
       mounted: true,
       skillSlug,
       persona: opts?.persona,
       webViewSource: { uri: this.buildUri(skillSlug, opts?.persona, opts?.skills) },
     });
-    return this.waitForConnect();
+    return this.waitForConnect(caller);
   }
 
   stop(caller: VoiceCaller = PLATFORM_VOICE_CALLER): void {
@@ -449,6 +491,7 @@ class VoiceSessionManager implements VoiceSessionProvider {
     this.rejectPending(new Error('voice: session stopped before it connected'));
     this.frozenTools = null; // the session's authorized set ends with the session
     this.frozenSessionId = null;
+    this.sessionEpoch++; // a tool still running for this session records nothing
     this.setState({
       ...IDLE,
       // keep the transcript of the call that just ended for any reader still up
@@ -492,10 +535,12 @@ class VoiceSessionManager implements VoiceSessionProvider {
     // nothing about the conversation another solution is holding. This is not a
     // fake idle (invariant 6 is about an UNDECLARED plugin): a declared plugin
     // that does not own the live session genuinely has none of its own.
-    return this.canAccess(caller) ? this.realSnapshot() : this.foreignSnapshot();
+    return this.canAccess(caller) ? this.realSnapshot(caller) : this.foreignSnapshot();
   }
 
-  private realSnapshot(): VoiceSnapshot {
+  /** The snapshot for a caller that may access the session. Everything is the
+   *  session's, except `lastDeviceTool`, which is scoped to the caller's tools. */
+  private realSnapshot(caller: VoiceCaller): VoiceSnapshot {
     const s = this.state;
     return {
       state: s.callState,
@@ -505,12 +550,25 @@ class VoiceSessionManager implements VoiceSessionProvider {
       listening: !!s.userPartial,
       userSpeaking: s.userSpeaking,
       lastUserSpeechEndedAt: s.lastUserSpeechEndedAt,
-      lastDeviceTool: s.lastDeviceTool,
+      lastDeviceTool: this.lastDeviceToolFor(caller),
       authorizedSessionId: this.frozenSessionId,
       lastError: s.error,
     };
   }
 
+  /**
+   * The last finished device-tool call THIS caller may see. The platform (the
+   * user's own surface) sees every call. A plugin sees only calls to tools it
+   * registered — even on a session it owns, the model can call another
+   * solution's tool (a normal call offers every registered tool), and that
+   * tool's name and error are not this plugin's to read.
+   */
+  private lastDeviceToolFor(caller: VoiceCaller): VoiceDeviceToolCall | null {
+    const calls = this.state.deviceToolCalls;
+    if (caller === PLATFORM_VOICE_CALLER) return calls.length ? calls[calls.length - 1].call : null;
+    return calls.find(r => r.owner === caller)?.call ?? null;
+  }
+
   private foreignSnapshot(): VoiceSnapshot {
     return {
       state: 'idle', sessionId: null, muted: false, speaking: false, listening: false,
@@ -648,26 +706,75 @@ class VoiceSessionManager implements VoiceSessionProvider {
           console.warn(`[voiceSession] REFUSED device tool call from "${sender || 'unknown origin'}" (expected "${expected}")`);
           break;
         }
-        if (data.name) this.setState({ lastDeviceTool: { name: data.name, at: Date.now() } });
-        // AUTHORIZATION against the FROZEN session set, not the live registry
-        // (GPT gate 1). A tool that appeared after connect — the drift case — is
-        // refused here, before execution, even if it is registered right now.
-        if (!this.isToolAuthorized(data.name)) {
-          // Both refuse (fail closed), but they are DIFFERENT answers to the model:
-          // NOT-YET-TOLD (Core's allowset hasn't arrived) is transient — retry;
-          // TOLD-AND-DENIED (allowset present, tool not in it / wrong session /
-          // unregistered) is final. Same refusal, different sentence.
-          const notReady = this.frozenTools === null;
-          console.warn(`[voiceSession] REFUSED "${data.name}" — ${notReady ? 'allowset not received yet' : 'not authorized for this session'}`);
-          this.postDeviceToolRefusal(data.correlationId, data.name, notReady);
-          break;
-        }
-        void this.runDeviceTool(data);
+        void this.handleDeviceToolCall(data);
         break;
       }
     }
   }
 
+  /**
+   * One device-tool call, arrival to outcome: validate → authorize → run. The
+   * answer goes back to the mini-app (the model reads it) AND becomes
+   * `lastDeviceTool` — the same object, recorded only once it is known, so a
+   * refused call never looks like one that ran.
+   */
+  private async handleDeviceToolCall(data: any): Promise<void> {
+    const { correlationId, name, args, timeoutMs } = data || {};
+    const at = Date.now();
+    const epoch = this.sessionEpoch;
+    const toolName = typeof name === 'string' ? name : '';
+    // Which plugin may later read this call. The only plugin that can read this
+    // session's snapshot at all is its owner (any other gets the foreign one), so
+    // the call is tagged with the owner only if the tool is registered BY it, as
+    // of arrival — the same check a clean call's scope uses. Anything else
+    // (another solution's tool, the platform's, an unregistered name) is null:
+    // the platform's to see, no plugin's.
+    const sessionOwner = this.owner;
+    const owner = typeof sessionOwner === 'string' && toolName && hasDeviceTool(toolName, sessionOwner)
+      ? sessionOwner
+      : null;
+
+    let answer: DeviceToolAnswer;
+    if (!toolName) {
+      answer = { ok: false, reason: 'invalid', error: 'The device tool call named no tool.' };
+    } else if (!correlationId) {
+      answer = {
+        ok: false, reason: 'invalid',
+        error: `The call to "${toolName}" carried no correlationId, so it could not be answered.`,
+      };
+    } else if (!this.isToolAuthorized(toolName)) {
+      // AUTHORIZATION against the FROZEN session set, not the live registry
+      // (GPT gate 1). A tool that appeared after connect — the drift case — is
+      // refused here, before execution, even if it is registered right now.
+      // Both refusals fail closed, but they are DIFFERENT answers to the model:
+      // NOT-YET-TOLD (Core's allowset hasn't arrived) is transient — retry;
+      // TOLD-AND-DENIED (allowset present, tool not in it / wrong session /
+      // unregistered) is final. Same refusal, different sentence.
+      const notReady = this.frozenTools === null;
+      console.warn(`[voiceSession] REFUSED "${toolName}" — ${notReady ? 'allowset not received yet' : 'not authorized for this session'}`);
+      answer = notReady
+        ? {
+            ok: false, reason: 'not_ready',
+            error: 'The voice session is still starting up — its tool allowset has not arrived yet. Try again in a moment.',
+          }
+        : { ok: false, reason: 'not_authorized', error: `"${toolName}" is not available in this voice session.` };
+    } else {
+      answer = await this.runDeviceTool(toolName, args, timeoutMs);
+    }
+
+    // A call without a correlationId cannot be answered — nothing is waiting on it.
+    if (correlationId) this.postDeviceToolResult({ correlationId, ...answer });
+
+    if (epoch !== this.sessionEpoch) return; // its session ended while it ran
+    const ms = Math.max(0, Date.now() - at);
+    const call: VoiceDeviceToolCall = answer.ok
+      ? { name: toolName, at, ms, ok: true, reason: null, error: null }
+      : { name: toolName, at, ms, ok: false, reason: answer.reason, error: clipError(answer.error) };
+    this.setState({
+      deviceToolCalls: [...this.state.deviceToolCalls.filter(r => r.owner !== owner), { owner, call }],
+    });
+  }
+
   /**
    * Final authorization = Core's frozen allowset ∩ the current valid local
    * registry, bound to the ACTIVE session. All must hold:
@@ -688,19 +795,9 @@ class VoiceSessionManager implements VoiceSessionProvider {
     return hasDeviceTool(name, this.toolScope ?? undefined); // still registered locally right now
   }
 
-  /** Tell the mini-app the call was refused — a stated reason, never a silent drop.
-   *  `notReady` distinguishes a transient "allowset not here yet" (retry) from a
-   *  final "not allowed in this session". */
-  private postDeviceToolRefusal(correlationId: string, name: string, notReady: boolean): void {
-    const payload = notReady
-      ? {
-          correlationId, ok: false, reason: 'not_ready',
-          error: 'The voice session is still starting up — its tool allowset has not arrived yet. Try again in a moment.',
-        }
-      : {
-          correlationId, ok: false, reason: 'not_authorized',
-          error: `"${name}" is not available in this voice session.`,
-        };
+  /** Answer the mini-app's pending device-tool request (a call's outcome, or the
+   *  tool list) — it resolves the request with this payload by correlationId. */
+  private postDeviceToolResult(payload: { correlationId: string } & Record<string, unknown>): void {
     this.webView?.injectJavaScript?.(
       `window.__adasDeviceToolResult && window.__adasDeviceToolResult(${JSON.stringify(
         JSON.stringify(payload),
@@ -718,31 +815,19 @@ class VoiceSessionManager implements VoiceSessionProvider {
       description: t.description,
       input_schema: t.input_schema,
     }));
-    this.webView?.injectJavaScript?.(
-      `window.__adasDeviceToolResult && window.__adasDeviceToolResult(${JSON.stringify(
-        JSON.stringify({ correlationId, ok: true, tools }),
-      )}); true;`,
-    );
+    this.postDeviceToolResult({ correlationId, ok: true, tools });
   }
 
-  /** Run a device tool and post the outcome back into the WebView. */
-  private async runDeviceTool(data: any): Promise<void> {
-    const { correlationId, name, args, timeoutMs } = data || {};
-    if (!correlationId || typeof name !== 'string') return;
-    let payload: any;
+  /** Run an authorized device tool. Never throws: every failure is an answer. */
+  private async runDeviceTool(name: string, args: any, timeoutMs: number | undefined): Promise<DeviceToolAnswer> {
     try {
       const outcome = await callDeviceTool(name, args || {}, { timeoutMs });
-      payload = outcome.ok
-        ? { correlationId, ok: true, result: outcome.result }
-        : { correlationId, ok: false, error: outcome.error, reason: outcome.reason };
+      return outcome.ok
+        ? { ok: true, result: outcome.result }
+        : { ok: false, reason: outcome.reason, error: outcome.error };
     } catch (err: any) {
-      payload = { correlationId, ok: false, reason: 'failed', error: err?.message || String(err) };
+      return { ok: false, reason: 'failed', error: err?.message || String(err) };
     }
-    this.webView?.injectJavaScript?.(
-      `window.__adasDeviceToolResult && window.__adasDeviceToolResult(${JSON.stringify(
-        JSON.stringify(payload),
-      )}); true;`,
-    );
   }
 
   // ── internals ────────────────────────────────────────────────
@@ -763,23 +848,23 @@ class VoiceSessionManager implements VoiceSessionProvider {
     }
   }
 
-  private waitForConnect(): Promise<VoiceSnapshot> {
+  private waitForConnect(caller: VoiceCaller): Promise<VoiceSnapshot> {
     return new Promise<VoiceSnapshot>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending = this.pending.filter(p => p.timer !== timer);
         reject(new Error('voice: timed out waiting to connect (is VoiceSessionHost mounted?)'));
       }, CONNECT_TIMEOUT_MS);
-      this.pending.push({ resolve, reject, timer });
+      this.pending.push({ caller, resolve, reject, timer });
     });
   }
 
   private resolvePending(): void {
     // Everyone still waiting on connect already passed the access check in
-    // start(), so they get the real snapshot.
-    const snap = this.realSnapshot();
+    // start(), so each gets the real snapshot — as ITS caller (lastDeviceTool
+    // is scoped per caller).
     const waiting = this.pending;
     this.pending = [];
-    for (const p of waiting) { clearTimeout(p.timer); p.resolve(snap); }
+    for (const p of waiting) { clearTimeout(p.timer); p.resolve(this.realSnapshot(p.caller)); }
   }
 
   private rejectPending(err: Error): void {
@@ -798,6 +883,7 @@ class VoiceSessionManager implements VoiceSessionProvider {
     this.pendingStarts.clear();
     this.frozenTools = null;
     this.frozenSessionId = null;
+    this.sessionEpoch++;
     this.listeners.clear();
     this.webView = null;
   }