@vellumai/assistant 0.8.0 → 0.8.2

package/src/ipc/skill-routes/events.ts

@@ -70,6 +70,30 @@ const BuildEventParams = z.object({
   conversationId: z.string().optional(),
 });
 
+// ---------------------------------------------------------------------------
+// Event-type blocklist
+// ---------------------------------------------------------------------------
+
+/**
+ * Message types that skills are NOT allowed to publish. These are
+ * daemon→client control events that trigger host-side execution (bash,
+ * file I/O, browser automation, credential prompts) or register pending
+ * interactions. Allowing a skill to publish them would bypass the
+ * trust/approval gates and escape the skill isolation boundary.
+ *
+ * Prefix-based: any event whose `type` starts with `"host_"` is blocked,
+ * covering current types (`host_bash_request`, `host_file_request`,
+ * `host_browser_request`, `host_cu_request`, `host_transfer_request`,
+ * and their `_cancel` counterparts) plus any future `host_*` additions.
+ */
+function isBlockedEventType(type: unknown): boolean {
+  if (typeof type !== "string") return true;
+  if (type.startsWith("host_")) return true;
+  if (type === "confirmation_request") return true;
+  if (type === "secret_request") return true;
+  return false;
+}
+
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -78,9 +102,12 @@ async function handlePublish(
   params?: Record<string, unknown>,
 ): Promise<{ published: true }> {
   const { event } = PublishParams.parse(params);
-  // Contract types the hub as `AssistantEvent<ServerMessage>`; the wire-level
-  // message is an opaque record that satisfies the `ServerMessage` structural
-  // shape (`{ type: string; [key: string]: unknown }`). Cast at the boundary.
+  const msgType = (event.message as Record<string, unknown>)?.type;
+  if (isBlockedEventType(msgType)) {
+    throw new Error(
+      `Skills cannot publish events of type "${String(msgType)}"`,
+    );
+  }
   await assistantEventHub.publish(event as never);
   return { published: true };
 }

package/src/live-voice/__tests__/live-voice-session-manager.test.ts

@@ -328,6 +328,52 @@ describe("LiveVoiceSessionManager", () => {
     expect(manager.activeSessionId).toBe("session-1");
   });
 
+  test("holds the session lock until close completes", async () => {
+    const sessions: TestSession[] = [];
+    let resolveClose: (() => void) | undefined;
+    const manager = new LiveVoiceSessionManager({
+      createSessionId: mock(() => `session-${sessions.length + 1}`),
+      createSession: () => {
+        const session = createTestSession({
+          close: mock(
+            (reason: LiveVoiceSessionCloseReason) =>
+              new Promise<void>((resolve) => {
+                sessions[sessions.length - 1]?.closeReasons.push(reason);
+                resolveClose = resolve;
+              }),
+          ),
+        });
+        sessions.push(session);
+        return session;
+      },
+    });
+    const first = createSink();
+    const second = createSink();
+    const third = createSink();
+
+    await manager.startSession(START_FRAME, first.sink);
+    const releasePromise = manager.releaseSession("session-1", "client_end");
+    const concurrent = await manager.startSession(START_FRAME, second.sink);
+    const concurrentDispatch = await manager.handleClientFrame("session-1", {
+      type: "interrupt",
+    });
+
+    expect(concurrent).toEqual({
+      status: "busy",
+      activeSessionId: "session-1",
+      frame: { type: "busy", seq: 1, activeSessionId: "session-1" },
+    });
+    expect(concurrentDispatch).toEqual({ status: "not_found" });
+    expect(sessions).toHaveLength(1);
+
+    resolveClose?.();
+    await releasePromise;
+
+    const next = await manager.startSession(START_FRAME, third.sink);
+    expect(next).toEqual({ status: "accepted", sessionId: "session-2" });
+    expect(manager.activeSessionId).toBe("session-2");
+  });
+
   test("does not import runtime, gateway, provider, or conversation modules", async () => {
     const source = await Bun.file(
       new URL("../live-voice-session-manager.ts", import.meta.url),

package/src/live-voice/__tests__/live-voice-stt.test.ts

@@ -229,6 +229,63 @@ describe("LiveVoiceSession STT", () => {
     ]);
   });
 
+  test("retains transcriber handle when stop() throws so close() can clean up", async () => {
+    class ThrowingStopTranscriber extends MockStreamingTranscriber {
+      stopCalls = 0;
+      override stop(): void {
+        this.stopCalls += 1;
+        if (this.stopCalls === 1) {
+          throw new Error("stop failed");
+        }
+      }
+    }
+
+    const transcriber = new ThrowingStopTranscriber();
+    const { frames, session } = createSessionWithTranscriber(transcriber);
+
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+
+    expect(transcriber.stopCalls).toBe(1);
+    expect(
+      frames.some(
+        (frame) =>
+          frame.type === "error" &&
+          frame.message.includes(
+            "Live voice transcription could not be stopped",
+          ),
+      ),
+    ).toBe(true);
+
+    await session.close("websocket_close");
+
+    expect(transcriber.stopCalls).toBe(2);
+  });
+
+  test("retains transcriber handle when stop() throws so interrupt() can clean up", async () => {
+    class ThrowingStopTranscriber extends MockStreamingTranscriber {
+      stopCalls = 0;
+      override stop(): void {
+        this.stopCalls += 1;
+        if (this.stopCalls === 1) {
+          throw new Error("stop failed");
+        }
+      }
+    }
+
+    const transcriber = new ThrowingStopTranscriber();
+    const { session } = createSessionWithTranscriber(transcriber);
+
+    await session.start();
+    await session.handleClientFrame({ type: "ptt_release" });
+
+    expect(transcriber.stopCalls).toBe(1);
+
+    await session.handleClientFrame({ type: "interrupt" });
+
+    expect(transcriber.stopCalls).toBe(2);
+  });
+
   test("uses the production streaming transcriber resolver by default", () => {
     const source = readFileSync(
       new URL("../live-voice-session.ts", import.meta.url),

package/src/live-voice/__tests__/runtime-websocket-shell.test.ts

@@ -348,6 +348,7 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
       conversationId: "conversation-after-error",
     });
     expect(typeof ready.sessionId).toBe("string");
+    expect(ready.seq as number).toBeGreaterThan(error.seq as number);
   });
 
   test("releases the session lock when the WebSocket closes", async () => {

package/src/live-voice/live-voice-session-manager.ts

@@ -85,6 +85,7 @@ export type LiveVoiceSessionReleaseResult =
 interface ActiveLiveVoiceSession {
   sessionId: string;
   session: LiveVoiceSession;
+  closing: boolean;
 }
 
 export class LiveVoiceSessionManager {
@@ -132,7 +133,7 @@ export class LiveVoiceSessionManager {
       },
     };
     const session = this.createSession(context);
-    this.activeSession = { sessionId, session };
+    this.activeSession = { sessionId, session, closing: false };
 
     try {
       await session.start();
@@ -198,14 +199,20 @@ export class LiveVoiceSessionManager {
       return { released: false };
     }
 
-    this.activeSession = null;
-    await active.session.close(reason);
+    active.closing = true;
+    try {
+      await active.session.close(reason);
+    } finally {
+      if (this.activeSession === active) {
+        this.activeSession = null;
+      }
+    }
     return { released: true, sessionId };
   }
 
   private findActiveSession(sessionId: string): ActiveLiveVoiceSession | null {
     const active = this.activeSession;
-    if (active === null || active.sessionId !== sessionId) {
+    if (active === null || active.sessionId !== sessionId || active.closing) {
       return null;
     }
 

package/src/live-voice/live-voice-session.ts

@@ -307,7 +307,6 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         )}`,
       });
       this.state = "transcriber_closed";
-      this.transcriber = null;
     }
     await this.startAssistantTurnIfReady();
     await this.drainOutboundFrames();
@@ -340,12 +339,15 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         return;
       }
       case "error":
+        // Non-terminal: providers like OpenAI Whisper emit `error` for
+        // transient poll failures and continue streaming. Let `closed` /
+        // `final` drive turn lifecycle so we don't drain audio buffers or
+        // mark the turn cancelled prematurely.
         await this.sendFrame({
           type: "error",
           code: LiveVoiceProtocolErrorCode.InvalidField,
           message: event.message,
         });
-        await this.finalizePendingTurn("stt_error");
         return;
       case "closed":
         if (!this.isClosed) {
@@ -470,16 +472,22 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
           },
         },
         onError: (message) => {
-          if (!this.isActiveAssistantTurn(token)) return;
+          const activeTurn = this.activeAssistantTurn;
+          if (
+            !this.isActiveAssistantTurn(token) ||
+            activeTurn?.assistantCompleted
+          ) {
+            return;
+          }
           void (async () => {
             await this.sendFrame({
               type: "error",
               code: LiveVoiceProtocolErrorCode.InvalidField,
               message,
             });
-            const activeTurn = this.activeAssistantTurn;
-            if (activeTurn?.token !== token) return;
-            await this.finalizeAssistantTurn(activeTurn, "cancelled", "error");
+            const currentTurn = this.activeAssistantTurn;
+            if (currentTurn?.token !== token) return;
+            await this.finalizeAssistantTurn(currentTurn, "cancelled", "error");
           })();
         },
       });

package/src/mcp/client.ts

@@ -14,6 +14,24 @@ const log = getLogger("mcp-client");
 
 const CONNECT_TIMEOUT_MS = 30_000;
 
+// MCP servers occasionally return tools with a missing or non-object
+// `inputSchema` (spec violation, but seen in the wild). Coerce to a valid
+// empty object schema so downstream code that assumes `input_schema: object`
+// (e.g. `injectActivityField`) doesn't crash.
+function normalizeInputSchema(
+  raw: unknown,
+  toolName: string,
+): Record<string, unknown> {
+  if (raw != null && typeof raw === "object" && !Array.isArray(raw)) {
+    return raw as Record<string, unknown>;
+  }
+  log.warn(
+    { toolName, received: typeof raw },
+    "MCP tool returned non-object inputSchema; defaulting to empty object schema",
+  );
+  return { type: "object", properties: {} };
+}
+
 export interface McpToolInfo {
   name: string;
   description: string;
@@ -80,9 +98,7 @@ export class McpClient {
         `mcp:${this.serverId}:tokens`,
       );
       if (cachedTokens) {
-        const callbackTransport = getIsPlatform()
-          ? "gateway"
-          : "loopback";
+        const callbackTransport = getIsPlatform() ? "gateway" : "loopback";
         this.oauthProvider = new McpOAuthProvider(
           this.serverId,
           transportConfig.url,
@@ -164,7 +180,7 @@ export class McpClient {
     return result.tools.map((tool) => ({
       name: tool.name,
       description: tool.description ?? "",
-      inputSchema: tool.inputSchema as Record<string, unknown>,
+      inputSchema: normalizeInputSchema(tool.inputSchema, tool.name),
     }));
   }
 

package/src/media/image-credentials.ts

@@ -8,8 +8,8 @@
  * credentials are unavailable.
  */
 
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
+import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import type { ImageGenCredentials, ImageGenProvider } from "./types.js";
 
@@ -33,7 +33,7 @@ export async function resolveImageGenCredentials(opts: {
     // Resolve platform URL + assistant API key from a single snapshot so
     // baseUrl and assistantApiKey can't diverge if the credential is cleared
     // between lookups.
-    const meta = MANAGED_PROVIDER_META[provider];
+    const meta = PLATFORM_PROVIDER_META[provider];
     const ctx = await resolveManagedProxyContext();
     if (
       !meta?.managed ||

package/src/memory/__tests__/bookmark-crud.test.ts

@@ -0,0 +1,264 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  createBookmark,
+  deleteBookmarkByMessageId,
+  listBookmarks,
+} from "../bookmark-crud.js";
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { migrateMessageBookmarks } from "../migrations/242-message-bookmarks.js";
+import * as schema from "../schema.js";
+
+/**
+ * Recreate just enough of the conversations + messages tables to satisfy
+ * the bookmark JOIN and FK CASCADE behavior. The PR-2 schema test uses
+ * the same lightweight bootstrap.
+ */
+function bootstrapMessageTables(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+interface SeedOptions {
+  conversationId: string;
+  messageId: string;
+  conversationTitle?: string | null;
+  messageContent?: string;
+  messageRole?: string;
+  messageCreatedAt?: number;
+}
+
+function seedConversationAndMessage(raw: Database, opts: SeedOptions): void {
+  const now = Date.now();
+  raw
+    .query(
+      `INSERT INTO conversations (id, title, created_at, updated_at) VALUES (?, ?, ?, ?)`,
+    )
+    .run(opts.conversationId, opts.conversationTitle ?? "Example", now, now);
+  raw
+    .query(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
+    )
+    .run(
+      opts.messageId,
+      opts.conversationId,
+      opts.messageRole ?? "user",
+      opts.messageContent ?? "hello",
+      opts.messageCreatedAt ?? now,
+    );
+}
+
+function setupDb(): { db: DrizzleDb; raw: Database } {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  const db = drizzle(sqlite, { schema });
+  const raw = getSqliteFrom(db);
+  bootstrapMessageTables(raw);
+  migrateMessageBookmarks(db);
+  return { db, raw };
+}
+
+describe("bookmark-crud", () => {
+  test("createBookmark is idempotent — second call returns the existing row", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-1",
+      messageId: "msg-1",
+    });
+
+    const first = createBookmark(db, { messageId: "msg-1" });
+    const second = createBookmark(db, { messageId: "msg-1" });
+
+    expect(first.inserted).toBe(true);
+    expect(second.inserted).toBe(false);
+    expect(second.bookmark.id).toBe(first.bookmark.id);
+    expect(second.bookmark.createdAt).toBe(first.bookmark.createdAt);
+
+    const all = listBookmarks(db);
+    expect(all.length).toBe(1);
+  });
+
+  test("createBookmark returns the JOIN-shaped summary directly", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-summary",
+      messageId: "msg-summary",
+      conversationTitle: "Title goes here",
+      messageContent: "summary body",
+      messageRole: "assistant",
+    });
+
+    const result = createBookmark(db, { messageId: "msg-summary" });
+
+    expect(result.inserted).toBe(true);
+    const summary = result.bookmark;
+    expect(summary.conversationTitle).toBe("Title goes here");
+    expect(summary.messagePreview).toBe("summary body");
+    expect(summary.messageRole).toBe("assistant");
+    expect(typeof summary.messageCreatedAt).toBe("number");
+  });
+
+  test("listBookmarks returns rows newest-first and includes joined fields", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-A",
+      messageId: "msg-A",
+      conversationTitle: "Older",
+      messageContent: "first message",
+      messageRole: "user",
+    });
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-B",
+      messageId: "msg-B",
+      conversationTitle: "Newer",
+      messageContent: "second message",
+      messageRole: "assistant",
+    });
+
+    // Force deterministic ordering by inserting bookmarks with explicit
+    // created_at values 1 ms apart.
+    raw
+      .query(
+        `INSERT INTO message_bookmarks (id, message_id, conversation_id, created_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("bm-A", "msg-A", "conv-A", 1000);
+    raw
+      .query(
+        `INSERT INTO message_bookmarks (id, message_id, conversation_id, created_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("bm-B", "msg-B", "conv-B", 2000);
+
+    const result = listBookmarks(db);
+    expect(result.map((r) => r.id)).toEqual(["bm-B", "bm-A"]);
+    expect(result[0]?.conversationTitle).toBe("Newer");
+    expect(result[0]?.messagePreview).toBe("second message");
+    expect(result[0]?.messageRole).toBe("assistant");
+    expect(result[1]?.conversationTitle).toBe("Older");
+    expect(result[1]?.messageRole).toBe("user");
+  });
+
+  test("listBookmarks excludes bookmarks whose conversation no longer exists (CASCADE)", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-keep",
+      messageId: "msg-keep",
+    });
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-drop",
+      messageId: "msg-drop",
+    });
+    createBookmark(db, { messageId: "msg-keep" });
+    createBookmark(db, { messageId: "msg-drop" });
+    expect(listBookmarks(db).length).toBe(2);
+
+    // Deleting the parent conversation cascades through messages → bookmarks.
+    raw.query(`DELETE FROM conversations WHERE id = ?`).run("conv-drop");
+
+    const remaining = listBookmarks(db);
+    expect(remaining.length).toBe(1);
+    expect(remaining[0]?.conversationId).toBe("conv-keep");
+  });
+
+  test("deleteBookmarkByMessageId removes the matching row", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-d",
+      messageId: "msg-d",
+    });
+    createBookmark(db, { messageId: "msg-d" });
+    expect(listBookmarks(db).length).toBe(1);
+
+    expect(deleteBookmarkByMessageId(db, "msg-d")).toBe(true);
+    expect(listBookmarks(db).length).toBe(0);
+    // Calling again with no row present returns false.
+    expect(deleteBookmarkByMessageId(db, "msg-d")).toBe(false);
+  });
+
+  test("messagePreview decodes JSON-serialized ContentBlock[] rows", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-blocks",
+      messageId: "msg-blocks",
+      messageContent: JSON.stringify([
+        { type: "text", text: "Hello, can you help with…" },
+      ]),
+      messageRole: "user",
+    });
+
+    const { bookmark: summary } = createBookmark(db, {
+      messageId: "msg-blocks",
+    });
+
+    // Without the decode step, this would render as the raw JSON literal
+    // (`[{"type":"text","text":"…"}]`) rather than the spoken text.
+    expect(summary.messagePreview).toBe("Hello, can you help with…");
+    const listed = listBookmarks(db);
+    expect(listed[0]?.messagePreview).toBe("Hello, can you help with…");
+  });
+
+  test("messagePreview concatenates multi-text blocks and drops non-text blocks", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-multi",
+      messageId: "msg-multi",
+      messageContent: JSON.stringify([
+        { type: "text", text: "first paragraph" },
+        { type: "tool_use", id: "x", name: "noop", input: {} },
+        { type: "text", text: "second paragraph" },
+      ]),
+      messageRole: "assistant",
+    });
+
+    const { bookmark: summary } = createBookmark(db, {
+      messageId: "msg-multi",
+    });
+
+    expect(summary.messagePreview).toBe("first paragraph\nsecond paragraph");
+  });
+
+  test("createBookmark derives conversationId from the message row", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-real",
+      messageId: "msg-x",
+    });
+
+    const { bookmark: summary } = createBookmark(db, { messageId: "msg-x" });
+    expect(summary.conversationId).toBe("conv-real");
+    expect(listBookmarks(db)[0]?.conversationId).toBe("conv-real");
+  });
+
+  test("createBookmark throws when the message id does not exist", () => {
+    const { db } = setupDb();
+    expect(() => createBookmark(db, { messageId: "ghost" })).toThrow(
+      /Message ghost not found/,
+    );
+  });
+});