@ateam-ai-mobile/ui 0.1.8 → 0.1.9

package/dist/index.mjs

@@ -2800,6 +2800,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);
@@ -2815,7 +2820,7 @@ var IDLE = {
   muted: false,
   userSpeaking: false,
   lastUserSpeechEndedAt: null,
-  lastDeviceTool: null,
+  deviceToolCalls: [],
   mounted: false,
   webViewSource: null,
   skillSlug: void 0
@@ -2871,6 +2876,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
@@ -2900,11 +2910,11 @@ var VoiceSessionManager = class {
   async start(opts, caller = 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).");
@@ -2925,16 +2935,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",
@@ -2943,12 +2954,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 = PLATFORM_VOICE_CALLER) {
     if (this.state.callState !== "idle" && !this.canAccess(caller)) throw this.foreignError();
@@ -2962,6 +2976,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
@@ -2994,9 +3009,11 @@ var VoiceSessionManager = class {
     this.webView?.injectJavaScript?.(buildObserveScript(text));
   }
   getSnapshot(caller = 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,
@@ -3006,11 +3023,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 === 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",
@@ -3138,18 +3167,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 && 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:
@@ -3169,21 +3232,9 @@ var VoiceSessionManager = class {
     if (!this.frozenTools.has(name)) return false;
     return 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)
@@ -3200,28 +3251,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 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) {
@@ -3241,22 +3280,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) {
@@ -3277,6 +3315,7 @@ var VoiceSessionManager = class {
     this.pendingStarts.clear();
     this.frozenTools = null;
     this.frozenSessionId = null;
+    this.sessionEpoch++;
     this.listeners.clear();
     this.webView = null;
   }