@ateam-ai-mobile/ui 0.1.8 → 0.1.9

package/dist/index.d.mts

@@ -3,7 +3,7 @@ import { Message, JobProgress, UIAction, AdasSession, TenantMembership, HandoffE
 import * as React$1 from 'react';
 import React__default, { ReactNode } from 'react';
 import * as _ateam_ai_mobile_plugin_runtime from '@ateam-ai-mobile/plugin-runtime';
-import { PluginSurfaceMeta, PlatformPluginManifest, VoiceState, VoiceTranscriptEntry, VoiceSessionProvider, VoicePersona, VoiceStartOptions, VoiceCaller, VoiceSnapshot, VoiceEvent, VoiceSubscription } from '@ateam-ai-mobile/plugin-runtime';
+import { PluginSurfaceMeta, PlatformPluginManifest, VoiceState, VoiceTranscriptEntry, VoiceSessionProvider, VoiceDeviceToolCall, VoicePersona, VoiceStartOptions, VoiceCaller, VoiceSnapshot, VoiceEvent, VoiceSubscription } from '@ateam-ai-mobile/plugin-runtime';
 import * as zustand from 'zustand';
 
 interface AdasChatScreenProps {
@@ -382,6 +382,13 @@ declare function VoiceCallSheet({ visible, onClose, skillSlug }: Props): react_j
 
 type CallState = VoiceState;
 type TranscriptEntry = VoiceTranscriptEntry;
+/** 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;
+}
 interface InternalState {
     callState: CallState;
     sessionId: string | null;
@@ -394,11 +401,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,
@@ -461,6 +468,11 @@ declare class VoiceSessionManager implements VoiceSessionProvider {
      *  and the bundleManager registers a plugin's tools under that same id (never
      *  the bundle's own short `id`), so exact equality is the whole check. */
     private toolScope;
+    /** 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;
     /** 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. */
@@ -486,13 +498,30 @@ declare class VoiceSessionManager implements VoiceSessionProvider {
      */
     observe(text: string, caller?: VoiceCaller): void;
     getSnapshot(caller?: VoiceCaller): 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;
+    /**
+     * 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;
     private foreignSnapshot;
     subscribe(cb: (event: VoiceEvent) => void, caller?: VoiceCaller): VoiceSubscription;
     transcript(caller?: VoiceCaller): TranscriptEntry[];
     private buildUri;
     /** Handle a postMessage from the WebView. `event` is the RN WebView event. */
     handleMessage(event: any): void;
+    /**
+     * 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 handleDeviceToolCall;
     /**
      * Final authorization = Core's frozen allowset ∩ the current valid local
      * registry, bound to the ACTIVE session. All must hold:
@@ -506,15 +535,14 @@ declare class VoiceSessionManager implements VoiceSessionProvider {
      * No fallback to the live registry alone, ever.
      */
     private isToolAuthorized;
-    /** 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;
+    /** 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;
     /** PROPOSE the phone's available tools — this is an offer to Core, not the
      *  authorization set. Core sanitizes it and returns the accepted set in a
      *  `deviceToolAllowset` message, which is what actually gates execution. */
     private sendDeviceToolList;
-    /** Run a device tool and post the outcome back into the WebView. */
+    /** Run an authorized device tool. Never throws: every failure is an answer. */
     private runDeviceTool;
     private setState;
     private appendTranscript;

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { Message, JobProgress, UIAction, AdasSession, TenantMembership, HandoffE
 import * as React$1 from 'react';
 import React__default, { ReactNode } from 'react';
 import * as _ateam_ai_mobile_plugin_runtime from '@ateam-ai-mobile/plugin-runtime';
-import { PluginSurfaceMeta, PlatformPluginManifest, VoiceState, VoiceTranscriptEntry, VoiceSessionProvider, VoicePersona, VoiceStartOptions, VoiceCaller, VoiceSnapshot, VoiceEvent, VoiceSubscription } from '@ateam-ai-mobile/plugin-runtime';
+import { PluginSurfaceMeta, PlatformPluginManifest, VoiceState, VoiceTranscriptEntry, VoiceSessionProvider, VoiceDeviceToolCall, VoicePersona, VoiceStartOptions, VoiceCaller, VoiceSnapshot, VoiceEvent, VoiceSubscription } from '@ateam-ai-mobile/plugin-runtime';
 import * as zustand from 'zustand';
 
 interface AdasChatScreenProps {
@@ -382,6 +382,13 @@ declare function VoiceCallSheet({ visible, onClose, skillSlug }: Props): react_j
 
 type CallState = VoiceState;
 type TranscriptEntry = VoiceTranscriptEntry;
+/** 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;
+}
 interface InternalState {
     callState: CallState;
     sessionId: string | null;
@@ -394,11 +401,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,
@@ -461,6 +468,11 @@ declare class VoiceSessionManager implements VoiceSessionProvider {
      *  and the bundleManager registers a plugin's tools under that same id (never
      *  the bundle's own short `id`), so exact equality is the whole check. */
     private toolScope;
+    /** 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;
     /** 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. */
@@ -486,13 +498,30 @@ declare class VoiceSessionManager implements VoiceSessionProvider {
      */
     observe(text: string, caller?: VoiceCaller): void;
     getSnapshot(caller?: VoiceCaller): 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;
+    /**
+     * 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;
     private foreignSnapshot;
     subscribe(cb: (event: VoiceEvent) => void, caller?: VoiceCaller): VoiceSubscription;
     transcript(caller?: VoiceCaller): TranscriptEntry[];
     private buildUri;
     /** Handle a postMessage from the WebView. `event` is the RN WebView event. */
     handleMessage(event: any): void;
+    /**
+     * 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 handleDeviceToolCall;
     /**
      * Final authorization = Core's frozen allowset ∩ the current valid local
      * registry, bound to the ACTIVE session. All must hold:
@@ -506,15 +535,14 @@ declare class VoiceSessionManager implements VoiceSessionProvider {
      * No fallback to the live registry alone, ever.
      */
     private isToolAuthorized;
-    /** 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;
+    /** 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;
     /** PROPOSE the phone's available tools — this is an offer to Core, not the
      *  authorization set. Core sanitizes it and returns the accepted set in a
      *  `deviceToolAllowset` message, which is what actually gates execution. */
     private sendDeviceToolList;
-    /** Run a device tool and post the outcome back into the WebView. */
+    /** Run an authorized device tool. Never throws: every failure is an answer. */
     private runDeviceTool;
     private setState;
     private appendTranscript;

package/dist/index.js

@@ -2822,6 +2822,11 @@ var buildObserveScript = (text) => `
   }
 })(${JSON.stringify(text)}); true;
 `;
+var DEVICE_TOOL_ERROR_MAX = 200;
+function clipError(message) {
+  const chars = Array.from(message);
+  return chars.length > DEVICE_TOOL_ERROR_MAX ? chars.slice(0, DEVICE_TOOL_ERROR_MAX - 1).join("") + "\u2026" : message;
+}
 function originOf(url) {
   if (!url) return null;
   const m = /^([a-z][a-z0-9+.-]*:\/\/[^/?#]+)/i.exec(url);
@@ -2837,7 +2842,7 @@ var IDLE = {
   muted: false,
   userSpeaking: false,
   lastUserSpeechEndedAt: null,
-  lastDeviceTool: null,
+  deviceToolCalls: [],
   mounted: false,
   webViewSource: null,
   skillSlug: void 0
@@ -2893,6 +2898,11 @@ var VoiceSessionManager = class {
      *  and the bundleManager registers a plugin's tools under that same id (never
      *  the bundle's own short `id`), so exact equality is the whole check. */
     this.toolScope = 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. */
+    this.sessionEpoch = 0;
     this.injectedTrackHook = INJECT_TRACK_HOOK;
   }
   /** The platform (built-in sheet, mic indicator, session host) sees and
@@ -2922,11 +2932,11 @@ var VoiceSessionManager = class {
   async start(opts, caller = import_plugin_runtime13.PLATFORM_VOICE_CALLER) {
     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) {
       throw new Error("voice: skills:'none' (a clean call) cannot also hand the mic to a skill (skillSlug).");
@@ -2947,16 +2957,17 @@ var VoiceSessionManager = class {
     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);
     }
     this.owner = caller;
     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",
@@ -2965,12 +2976,15 @@ var VoiceSessionManager = class {
       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 = import_plugin_runtime13.PLATFORM_VOICE_CALLER) {
     if (this.state.callState !== "idle" && !this.canAccess(caller)) throw this.foreignError();
@@ -2984,6 +2998,7 @@ var VoiceSessionManager = class {
     this.rejectPending(new Error("voice: session stopped before it connected"));
     this.frozenTools = null;
     this.frozenSessionId = null;
+    this.sessionEpoch++;
     this.setState({
       ...IDLE,
       // keep the transcript of the call that just ended for any reader still up
@@ -3016,9 +3031,11 @@ var VoiceSessionManager = class {
     this.webView?.injectJavaScript?.(buildObserveScript(text));
   }
   getSnapshot(caller = import_plugin_runtime13.PLATFORM_VOICE_CALLER) {
-    return this.canAccess(caller) ? this.realSnapshot() : this.foreignSnapshot();
+    return this.canAccess(caller) ? this.realSnapshot(caller) : this.foreignSnapshot();
   }
-  realSnapshot() {
+  /** 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. */
+  realSnapshot(caller) {
     const s = this.state;
     return {
       state: s.callState,
@@ -3028,11 +3045,23 @@ var VoiceSessionManager = class {
       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.
+   */
+  lastDeviceToolFor(caller) {
+    const calls = this.state.deviceToolCalls;
+    if (caller === import_plugin_runtime13.PLATFORM_VOICE_CALLER) return calls.length ? calls[calls.length - 1].call : null;
+    return calls.find((r) => r.owner === caller)?.call ?? null;
+  }
   foreignSnapshot() {
     return {
       state: "idle",
@@ -3160,18 +3189,52 @@ var VoiceSessionManager = class {
           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() } });
-        if (!this.isToolAuthorized(data.name)) {
-          const notReady = this.frozenTools === null;
-          console.warn(`[voiceSession] REFUSED "${data.name}" \u2014 ${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.
+   */
+  async handleDeviceToolCall(data) {
+    const { correlationId, name, args, timeoutMs } = data || {};
+    const at = Date.now();
+    const epoch = this.sessionEpoch;
+    const toolName = typeof name === "string" ? name : "";
+    const sessionOwner = this.owner;
+    const owner = typeof sessionOwner === "string" && toolName && (0, import_plugin_runtime13.hasDeviceTool)(toolName, sessionOwner) ? sessionOwner : null;
+    let answer;
+    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)) {
+      const notReady = this.frozenTools === null;
+      console.warn(`[voiceSession] REFUSED "${toolName}" \u2014 ${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 \u2014 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);
+    }
+    if (correlationId) this.postDeviceToolResult({ correlationId, ...answer });
+    if (epoch !== this.sessionEpoch) return;
+    const ms = Math.max(0, Date.now() - at);
+    const call = 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:
@@ -3191,21 +3254,9 @@ var VoiceSessionManager = class {
     if (!this.frozenTools.has(name)) return false;
     return (0, import_plugin_runtime13.hasDeviceTool)(name, this.toolScope ?? void 0);
   }
-  /** 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". */
-  postDeviceToolRefusal(correlationId, name, notReady) {
-    const payload = notReady ? {
-      correlationId,
-      ok: false,
-      reason: "not_ready",
-      error: "The voice session is still starting up \u2014 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. */
+  postDeviceToolResult(payload) {
     this.webView?.injectJavaScript?.(
       `window.__adasDeviceToolResult && window.__adasDeviceToolResult(${JSON.stringify(
         JSON.stringify(payload)
@@ -3222,28 +3273,16 @@ var VoiceSessionManager = class {
       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. */
-  async runDeviceTool(data) {
-    const { correlationId, name, args, timeoutMs } = data || {};
-    if (!correlationId || typeof name !== "string") return;
-    let payload;
+  /** Run an authorized device tool. Never throws: every failure is an answer. */
+  async runDeviceTool(name, args, timeoutMs) {
     try {
       const outcome = await (0, import_plugin_runtime13.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) {
-      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 ────────────────────────────────────────────────
   setState(partial) {
@@ -3263,22 +3302,21 @@ var VoiceSessionManager = class {
       }
     }
   }
-  waitForConnect() {
+  waitForConnect(caller) {
     return new Promise((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 });
     });
   }
   resolvePending() {
-    const snap = this.realSnapshot();
     const waiting = this.pending;
     this.pending = [];
     for (const p of waiting) {
       clearTimeout(p.timer);
-      p.resolve(snap);
+      p.resolve(this.realSnapshot(p.caller));
     }
   }
   rejectPending(err) {
@@ -3299,6 +3337,7 @@ var VoiceSessionManager = class {
     this.pendingStarts.clear();
     this.frozenTools = null;
     this.frozenSessionId = null;
+    this.sessionEpoch++;
     this.listeners.clear();
     this.webView = null;
   }