@vellumai/assistant 0.8.6 → 0.8.7

package/src/daemon/external-plugins-bootstrap.ts

@@ -65,6 +65,7 @@ import { getConfig } from "../config/loader.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { HOOKS } from "../plugin-api/constants.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
+import { installPluginRuntime } from "../plugins/external-api.js";
 import { buildExternalPlugin } from "../plugins/external-plugin-loader.js";
 import {
   registerPluginSkills,
@@ -82,6 +83,7 @@ import {
   type PluginShutdownContext,
   type PluginSkillRegistration,
 } from "../plugins/types.js";
+import { loadUserPlugins } from "../plugins/user-loader.js";
 import {
   registerSkillRoute,
   type SkillRouteHandle,
@@ -99,16 +101,6 @@ import { registerShutdownHook } from "./shutdown-registry.js";
 
 const log = getLogger("plugins-bootstrap");
 
-/**
- * Minimal context required to bootstrap the plugin layer. Kept intentionally
- * small so the call site in `lifecycle.ts` can construct it from whatever
- * state is already available at that point in startup.
- */
-export interface DaemonContext {
-  config: AssistantConfig;
-  assistantVersion: string;
-}
-
 /**
  * Resolve one credential value. Returns the raw secret string or throws a
  * {@link PluginExecutionError} tagged with the plugin name so the caller can
@@ -191,6 +183,37 @@ function getDisabledPluginFlag(
   return undefined;
 }
 
+/**
+ * Bring the plugin layer up during daemon startup. Runs the full sequence in
+ * the one order the rest of the system depends on:
+ *
+ * 1. Install the `globalThis.__vellumPluginRuntime` bridge so plugins can touch
+ *    it from their module body (see `plugins/external-api.ts` — compiled-binary
+ *    module identity).
+ * 2. Register the first-party defaults so their middleware and injectors
+ *    compose innermost, ahead of any user plugins.
+ * 3. Load user plugins from `<workspaceDir>/plugins/*`. A failing user plugin is
+ *    logged and skipped; `loadUserPlugins()` closes the registration window
+ *    when it returns, so the defaults must already be registered by then.
+ * 4. Run every registered plugin's `init()` via {@link bootstrapPlugins}.
+ *
+ * Plugin bootstrap is wrapped so a failing plugin cannot block daemon startup —
+ * the daemon comes up with degraded plugin functionality instead.
+ */
+export async function initializePlugins(): Promise<void> {
+  installPluginRuntime();
+  registerDefaultPlugins();
+  await loadUserPlugins();
+  try {
+    await bootstrapPlugins();
+  } catch (err) {
+    log.warn(
+      { err },
+      "Plugin bootstrap failed — continuing startup with degraded plugin functionality",
+    );
+  }
+}
+
 /**
  * Run every registered plugin's `init()` hook sequentially and install a
  * reverse-order shutdown hook. See the module docstring for full semantics.
@@ -203,7 +226,7 @@ function getDisabledPluginFlag(
  * and before the first conversation is served. First-party defaults are
  * registered inline via {@link registerDefaultPlugins}.
  */
-export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
+export async function bootstrapPlugins(): Promise<void> {
   // Register first-party default plugins. Each default wraps one of the
   // assistant's canonical pipelines (`toolExecute`, `llmCall`, ...) with a
   // passthrough so the pipeline shape is explicit at boot even when no
@@ -223,6 +246,8 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
   log.info({ count: plugins.length }, "bootstrapPlugins: initializing plugins");
 
+  const assistantConfig = getConfig();
+
   // Plugins that passed `requiresFlag` gating and therefore need the full
   // init → contribute → shutdown lifecycle. Plugins skipped by the flag gate
   // are omitted from this list so the shutdown hook below never tears down
@@ -245,7 +270,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
   // shutdown hook below. Only `assistantVersion` is exposed today; future
   // additions live on {@link PluginShutdownContext}.
   const shutdownContext: PluginShutdownContext = {
-    assistantVersion: ctx.assistantVersion,
+    assistantVersion: APP_VERSION,
   };
 
   async function rollbackPlugin(active: ActivePlugin): Promise<void> {
@@ -266,7 +291,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
   for (const plugin of plugins) {
     const name = plugin.manifest.name;
-    const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
+    const disabledFlag = getDisabledPluginFlag(plugin, assistantConfig);
     if (disabledFlag !== undefined) {
       log.info(
         { plugin: name, flag: disabledFlag },
@@ -277,7 +302,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
     }
 
     try {
-      activePlugins.push(await initializePlugin(plugin, ctx));
+      activePlugins.push(await initializePlugin(plugin, assistantConfig));
     } catch (err) {
       unregisterPlugin(name);
       await teardownPartialInit();
@@ -326,7 +351,7 @@ interface ActivePlugin {
 
 async function initializePlugin(
   plugin: Plugin,
-  ctx: DaemonContext,
+  assistantConfig: AssistantConfig,
 ): Promise<ActivePlugin> {
   const name = plugin.manifest.name;
   const routeHandles: SkillRouteHandle[] = [];
@@ -341,7 +366,7 @@ async function initializePlugin(
     const config = validatePluginConfig(
       name,
       plugin.manifest.config,
-      getPluginConfigRaw(ctx.config, name),
+      getPluginConfigRaw(assistantConfig, name),
     );
 
     const initContext = {
@@ -349,7 +374,7 @@ async function initializePlugin(
       credentials,
       logger: log.child({ plugin: name }),
       pluginStorageDir: ensurePluginStorageDir(name),
-      assistantVersion: ctx.assistantVersion,
+      assistantVersion: APP_VERSION,
     };
 
     if (plugin.tools && plugin.tools.length > 0) {
@@ -417,7 +442,7 @@ async function initializePlugin(
   } catch (err) {
     if (initCompleted) {
       await teardownPlugin({ plugin, routeHandles }, "bootstrap-failed", {
-        assistantVersion: ctx.assistantVersion,
+        assistantVersion: APP_VERSION,
       });
     } else {
       for (const handle of routeHandles) {
@@ -519,11 +544,8 @@ export async function reregisterExternalPlugin(
     return;
   }
 
-  const ctx: DaemonContext = {
-    config: getConfig(),
-    assistantVersion: APP_VERSION,
-  };
-  const disabledFlag = getDisabledPluginFlag(plugin, ctx.config);
+  const assistantConfig = getConfig();
+  const disabledFlag = getDisabledPluginFlag(plugin, assistantConfig);
   if (disabledFlag !== undefined) {
     log.info(
       { plugin: pluginName, flag: disabledFlag },
@@ -535,7 +557,7 @@ export async function reregisterExternalPlugin(
   const existing = getRegisteredPlugin(pluginName);
   if (existing === undefined) {
     try {
-      await initializePlugin(plugin, ctx);
+      await initializePlugin(plugin, assistantConfig);
       setRegisteredPlugin(plugin);
       log.info({ plugin: pluginName }, "external plugin registered post-boot");
     } catch (err) {

package/src/daemon/first-greeting.ts

@@ -43,6 +43,28 @@ export function getCannedFirstGreeting(
   return CANNED_FIRST_GREETING;
 }
 
+/**
+ * Builds a natural self-introduction to send *on behalf of the user* in place
+ * of the wake-up greeting, so the assistant generates a real response instead
+ * of replaying canned copy. Names come from the onboarding context; missing
+ * names are dropped so the line stays natural:
+ *   - both:           "Hi Vela, I'm alex. Nice to meet you."
+ *   - assistant only: "Hi Vela. Nice to meet you."
+ *   - user only:      "Hi, I'm alex. Nice to meet you."
+ * When neither name is known there is nothing personal to say, so this returns
+ * `undefined` and the caller falls back to the canned greeting.
+ */
+export function buildSelfIntroMessage(
+  onboarding?: OnboardingGreetingContext,
+): string | undefined {
+  const assistant = onboarding?.assistantName?.trim();
+  const user = onboarding?.userName?.trim();
+  if (!assistant && !user) return undefined;
+  const hi = assistant ? `Hi ${assistant}` : "Hi";
+  const intro = user ? `, I'm ${user}` : "";
+  return `${hi}${intro}. Nice to meet you.`;
+}
+
 const TONE_INTRO_CLOSE: Record<Tone, string> = {
   grounded: "",
   warm: "Good to meet you.",
@@ -79,12 +101,12 @@ const TONE_INVITE_OPENER: Record<Tone, string> = {
 
 const TONE_MIGRATION_OFFER: Record<Tone, string> = {
   grounded:
-    "If you have context or workflows from another assistant or harness, bring them over early and I'll help port them.",
-  warm: "If you have context or workflows from another assistant or harness, bring them over early and I can help port them.",
+    "And you don't have to start me from scratch — if you've built up a ChatGPT or Claude, bring it over and I'll learn from it fast. Best head start you can give me.",
+  warm: "And you don't have to start me from scratch — if there's a ChatGPT or Claude that already knows you, bring it over and I'll get up to speed fast. Honestly, it's the best head start you could give me.",
   energetic:
-    "If you've got context or workflows from another assistant or harness, bring them over early and I'll port them with you. What sounds right?",
+    "And you don't have to start me from scratch — if you've built up a ChatGPT or Claude, bring it over and I'll get up to speed fast. Best head start you can give me — want to start there?",
   poetic:
-    "If there's old context or workflows from another assistant or harness, bring them over early and I'll help port them.",
+    "And you don't have to start me from nothing — if there's a ChatGPT or Claude that already knows you, bring it over and I'll learn from it. The best head start you could give me.",
 };
 
 const TONE_GOOGLE_SCAN: Record<Tone, string> = {

package/src/daemon/guardian-action-generators.ts

@@ -44,9 +44,9 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
 
     const response = await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: prompt }] }],
-      [],
-      GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
       {
+        tools: [],
+        systemPrompt: GUARDIAN_ACTION_COPY_SYSTEM_PROMPT,
         config: {
           max_tokens: options.maxTokens ?? GUARDIAN_ACTION_COPY_MAX_TOKENS,
           callSite: "guardianQuestionCopy",

package/src/daemon/handlers/conversations.ts

@@ -3,7 +3,6 @@ import { v4 as uuid } from "uuid";
 import { clearAll, getConversation } from "../../memory/conversation-crud.js";
 import { resolveConversationId } from "../../memory/conversation-key-store.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
-import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { createAbortReason } from "../../util/abort-reasons.js";
 import { truncate } from "../../util/truncate.js";
@@ -28,23 +27,11 @@ export function handleConfirmationResponse(msg: ConfirmationResponse): void {
   for (const [conversationId, conversation] of conversationEntries()) {
     if (conversation.hasPendingConfirmation(msg.requestId)) {
       touchConversation(conversationId);
-      conversation.handleConfirmationResponse(
-        msg.requestId,
-        decision,
-        msg.selectedPattern,
-        msg.selectedScope,
-        undefined,
-        { source: "button" },
-      );
-      // Idempotent cleanup: the prompter's `resolveConfirmation` already
-      // resolved the interaction with the correct approved/rejected state
-      // before we reach here, so the entry is typically gone. This call is
-      // a safety net for paths where the prompter no-ops; map decision to
-      // state to keep the emitted event accurate when it does fire.
-      pendingInteractions.resolve(
-        msg.requestId,
-        decision === "allow" ? "approved" : "rejected",
-      );
+      conversation.handleConfirmationResponse(msg.requestId, decision, {
+        selectedPattern: msg.selectedPattern,
+        selectedScope: msg.selectedScope,
+        emissionContext: { source: "button" },
+      });
       return;
     }
   }
@@ -225,10 +212,7 @@ export function steerToMessage(
   | { steered: true }
   | {
       steered: false;
-      reason:
-        | "conversation_not_found"
-        | "message_not_found"
-        | "not_processing";
+      reason: "conversation_not_found" | "message_not_found" | "not_processing";
     } {
   const conversation = findConversation(conversationId);
   if (!conversation) {

package/src/daemon/handlers/shared.ts

@@ -95,6 +95,8 @@ export interface HistorySurface {
   persistent?: boolean;
   completed?: boolean;
   completionSummary?: string;
+  /** Id of the tool call that produced this surface (the `ui_show` proxy tool). Lets the client gate app previews on the tool result's arrival rather than whole-turn streaming state. */
+  toolCallId?: string;
 }
 
 /**
@@ -376,6 +378,8 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
           typeof block.completionSummary === "string"
             ? block.completionSummary
             : undefined,
+        toolCallId:
+          typeof block.toolCallId === "string" ? block.toolCallId : undefined,
       };
       surfaces.push(surface);
       contentOrder.push(`surface:${surfaces.length - 1}`);

package/src/daemon/handlers/skills.ts

@@ -328,6 +328,7 @@ function toSlimSkillResponse(
   const origin = deriveOrigin(kind, summary.directoryPath, installMeta);
   const status: SlimSkillResponse["status"] = state;
 
+  const category = inferCategory(summary.displayName, summary.description);
   const base = {
     id: summary.id,
     name: summary.displayName,
@@ -335,6 +336,7 @@ function toSlimSkillResponse(
     emoji: summary.emoji,
     kind,
     status,
+    category,
   } as const;
 
   switch (origin) {
@@ -511,16 +513,13 @@ export async function listSkillsFiltered(filter: SkillListFilter): Promise<{
   // Compute category counts BEFORE applying the category filter
   const categoryCounts: Record<string, number> = {};
   for (const s of skills) {
-    const cat = inferCategory(s.name, s.description);
-    categoryCounts[cat] = (categoryCounts[cat] ?? 0) + 1;
+    categoryCounts[s.category] = (categoryCounts[s.category] ?? 0) + 1;
   }
   const totalCount = skills.length;
 
   // Apply category filter
   if (filter.category) {
-    skills = skills.filter(
-      (s) => inferCategory(s.name, s.description) === filter.category,
-    );
+    skills = skills.filter((s) => s.category === filter.category);
   }
 
   // Sort: installed first, community origins before core within installed,
@@ -610,6 +609,7 @@ export async function getSkill(
       kind: slim.kind,
       origin: slim.origin,
       status: slim.status,
+      category: slim.category,
       slug: slim.slug,
       author: slim.author,
       stars: slim.stars,
@@ -649,6 +649,7 @@ export async function getSkill(
       kind: slim.kind,
       origin: slim.origin,
       status: slim.status,
+      category: slim.category,
       slug: slim.slug,
       sourceRepo: slim.sourceRepo,
       installs: slim.installs,
@@ -679,6 +680,7 @@ export async function getSkill(
     kind: slim.kind,
     origin: slim.origin,
     status: slim.status,
+    category: slim.category,
   };
   return { skill: detail };
 }
@@ -1367,6 +1369,7 @@ export async function searchSkills(
         kind: "catalog" as const,
         origin: "vellum" as const,
         status: "available" as const,
+        category: inferCategory(s.displayName, s.description),
       };
     });
 
@@ -1385,6 +1388,7 @@ export async function searchSkills(
         kind: "catalog" as const,
         origin: "clawhub" as const,
         status: "available" as const,
+        category: inferCategory(s.name, s.description),
         slug: s.slug,
         author: s.author,
         stars: s.stars,
@@ -1411,6 +1415,7 @@ export async function searchSkills(
         kind: "catalog" as const,
         origin: "skillssh" as const,
         status: "available" as const,
+        category: inferCategory(r.name, ""),
         slug: r.id,
         sourceRepo: r.source,
         installs: r.installs,
@@ -1562,15 +1567,11 @@ export async function draftSkill(params: {
               body.slice(0, 2000),
             ].join("\n");
 
-            const response = await provider.sendMessage(
-              [userMessage(prompt)],
-              [],
-              undefined,
-              {
-                config: { callSite: "skillCategoryInference", max_tokens: 256 },
-                signal,
-              },
-            );
+            const response = await provider.sendMessage([userMessage(prompt)], {
+              tools: [],
+              config: { callSite: "skillCategoryInference", max_tokens: 256 },
+              signal,
+            });
             cleanup();
 
             const responseText = extractText(response);

package/src/daemon/host-app-control-proxy.ts

@@ -47,6 +47,11 @@
 import { createHash } from "node:crypto";
 
 import type { ContentBlock } from "../providers/types.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  enforceSameActorOrErrorResult,
+  pickSameUserAutoResolve,
+} from "../runtime/auth/same-actor.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { HostProxyBase, HostProxyRequestError } from "./host-proxy-base.js";
@@ -322,6 +327,54 @@ export class HostAppControlProxy extends HostProxyBase<
       }
     }
 
+    let resolvedTargetClientId = targetClientId;
+    if (resolvedTargetClientId == null) {
+      const resolved = pickSameUserAutoResolve({
+        hub: assistantEventHub,
+        capability: "host_app_control",
+        sourceActorPrincipalId,
+      });
+      if (resolved.kind === "ambiguous") {
+        if (input.tool === "start") {
+          this.rollbackStartIfCurrent(attemptedSession);
+        }
+        return {
+          content:
+            "Multiple host_app_control clients are connected for this user. Specify target_client_id to disambiguate.",
+          isError: true,
+        };
+      }
+      if (resolved.kind === "match") {
+        resolvedTargetClientId = resolved.clientId;
+      } else if (
+        assistantEventHub.listClientsByCapability("host_app_control").length > 0
+      ) {
+        if (input.tool === "start") {
+          this.rollbackStartIfCurrent(attemptedSession);
+        }
+        return {
+          content:
+            "App control is not available for the current actor. Connect a host_app_control-capable client as the same user.",
+          isError: true,
+        };
+      }
+    }
+
+    if (resolvedTargetClientId != null) {
+      const rejection = enforceSameActorOrErrorResult({
+        hub: assistantEventHub,
+        sourceActorPrincipalId,
+        targetClientId: resolvedTargetClientId,
+        op: "host_app_control",
+      });
+      if (rejection) {
+        if (input.tool === "start") {
+          this.rollbackStartIfCurrent(attemptedSession);
+        }
+        return rejection;
+      }
+    }
+
     try {
       const payload = await this.dispatchRequest(
         toolName,
@@ -329,7 +382,7 @@ export class HostAppControlProxy extends HostProxyBase<
         conversationId,
         signal,
         undefined,
-        targetClientId,
+        resolvedTargetClientId,
       );
       if (input.tool === "start") {
         if (payload.state === "running") {

package/src/daemon/host-cu-proxy.ts

@@ -23,7 +23,11 @@ import {
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
-import { enforceSameActorOrErrorResult } from "../runtime/auth/same-actor.js";
+import {
+  ambiguousSameUserError,
+  enforceSameActorOrErrorResult,
+  pickSameUserAutoResolve,
+} from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -156,33 +160,48 @@ export class HostCuProxy {
       });
     }
 
-    // Existence + capability validation for explicit targets. Mirrors
-    // HostFileProxy's resolver-side guard so that the proxy is safe even
-    // when called outside the conversation-surfaces dispatch (which has
-    // its own validation layer).
-    if (targetClientId != null) {
-      const client = assistantEventHub.getClientById(targetClientId);
+    let resolvedTargetClientId = targetClientId;
+    if (resolvedTargetClientId == null) {
+      const resolved = pickSameUserAutoResolve({
+        hub: assistantEventHub,
+        capability: "host_cu",
+        sourceActorPrincipalId,
+      });
+      if (resolved.kind === "ambiguous") {
+        return Promise.resolve(ambiguousSameUserError("host_cu"));
+      }
+      if (resolved.kind === "match") {
+        resolvedTargetClientId = resolved.clientId;
+      } else if (
+        assistantEventHub.listClientsByCapability("host_cu").length > 0
+      ) {
+        return Promise.resolve({
+          content:
+            "Computer use is not available for the current actor. Connect a host_cu-capable client as the same user.",
+          isError: true,
+        });
+      }
+    }
+
+    if (resolvedTargetClientId != null) {
+      const client = assistantEventHub.getClientById(resolvedTargetClientId);
       if (!client) {
         return Promise.resolve({
-          content: `No connected client with id '${targetClientId}' supports host_cu. Run \`assistant clients list --capability host_cu\` to see available clients.`,
+          content: `No connected client with id '${resolvedTargetClientId}' supports host_cu. Run \`assistant clients list --capability host_cu\` to see available clients.`,
           isError: true,
         });
       }
       if (!client.capabilities.includes("host_cu")) {
         return Promise.resolve({
-          content: `Client '${targetClientId}' does not support host_cu. Run \`assistant clients list --capability host_cu\` to see available clients.`,
+          content: `Client '${resolvedTargetClientId}' does not support host_cu. Run \`assistant clients list --capability host_cu\` to see available clients.`,
           isError: true,
         });
       }
 
-      // Same-user enforcement: targeted CU dispatch must be owned by the
-      // same actor on both sides. This is the authoritative gate — the
-      // dispatch layer (conversation-surfaces.ts) skips its own check
-      // and relies on the proxy.
       const rejection = enforceSameActorOrErrorResult({
         hub: assistantEventHub,
         sourceActorPrincipalId,
-        targetClientId,
+        targetClientId: resolvedTargetClientId,
         op: "host_cu",
       });
       if (rejection) return Promise.resolve(rejection);
@@ -214,10 +233,12 @@ export class HostCuProxy {
                   type: "host_cu_cancel",
                   requestId,
                   conversationId,
-                  ...(targetClientId != null ? { targetClientId } : {}),
+                  ...(resolvedTargetClientId != null
+                    ? { targetClientId: resolvedTargetClientId }
+                    : {}),
                 },
                 conversationId,
-                { targetClientId },
+                { targetClientId: resolvedTargetClientId },
               );
             } catch {
               // Best-effort cancel notification
@@ -234,10 +255,12 @@ export class HostCuProxy {
       pendingInteractions.register(requestId, {
         conversationId,
         kind: "host_cu",
-        targetClientId,
+        targetClientId: resolvedTargetClientId,
         targetActorPrincipalId:
-          targetClientId != null
-            ? assistantEventHub.getActorPrincipalIdForClient(targetClientId)
+          resolvedTargetClientId != null
+            ? assistantEventHub.getActorPrincipalIdForClient(
+                resolvedTargetClientId,
+              )
             : undefined,
         rpcResolve: resolve as (v: unknown) => void,
         rpcReject: reject,
@@ -255,11 +278,12 @@ export class HostCuProxy {
             input,
             stepNumber,
             reasoning,
-            // Include in body so receiving client can verify targeted endpoint.
-            ...(targetClientId != null ? { targetClientId } : {}),
+            ...(resolvedTargetClientId != null
+              ? { targetClientId: resolvedTargetClientId }
+              : {}),
           },
           conversationId,
-          { targetClientId },
+          { targetClientId: resolvedTargetClientId },
         );
       } catch (err) {
         this._ownedRequests.delete(requestId);

package/src/daemon/host-file-proxy.ts

@@ -10,6 +10,7 @@ import {
   pickSameUserAutoResolve,
 } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { readAudioBase64 } from "../tools/shared/filesystem/audio-read.js";
 import { readImageBase64 } from "../tools/shared/filesystem/image-read.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -225,7 +226,13 @@ export class HostFileProxy {
    */
   resolve(
     requestId: string,
-    response: { content: string; isError: boolean; imageData?: string },
+    response: {
+      content: string;
+      isError: boolean;
+      imageData?: string;
+      audioData?: string;
+      audioMimeType?: string;
+    },
   ): void {
     const interaction = pendingInteractions.resolve(requestId, "answered");
     if (!interaction?.rpcResolve) {
@@ -244,6 +251,23 @@ export class HostFileProxy {
       );
       return;
     }
+    if (
+      meta.operation === "read" &&
+      !response.isError &&
+      typeof response.audioData === "string" &&
+      response.audioData.length > 0 &&
+      typeof response.audioMimeType === "string" &&
+      response.audioMimeType.length > 0
+    ) {
+      interaction.rpcResolve(
+        readAudioBase64(
+          response.audioData,
+          meta.path as string,
+          response.audioMimeType,
+        ),
+      );
+      return;
+    }
     interaction.rpcResolve({
       content: response.content,
       isError: response.isError,