@vellumai/assistant 0.7.0 → 0.7.2

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

@@ -7,7 +7,7 @@
  * - `host.events.publish` — publishes an event and verifies it reaches the
  *   daemon's `assistantEventHub` exactly as an in-process publish would.
  * - `host.events.buildEvent` — verifies deterministic envelope construction
- *   under `DAEMON_INTERNAL_ASSISTANT_ID`.
+ *   with the expected shape.
  * - `host.events.subscribe` — long-lived stream: confirms open ack, filtered
  *   delivery (match vs. mismatch), explicit close, and cleanup on client
  *   disconnect (including that the hub releases its subscription slot).
@@ -21,7 +21,6 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import type { AssistantEvent } from "../../../runtime/assistant-event.js";
 import { assistantEventHub } from "../../../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../../runtime/assistant-scope.js";
 import { SkillIpcServer } from "../../skill-server.js";
 
 // ---------------------------------------------------------------------------
@@ -144,18 +143,17 @@ async function waitForSubscriberCount(
 describe("host.events.publish", () => {
   test("publish round-trip reaches assistantEventHub subscribers", async () => {
     const received: AssistantEvent[] = [];
-    const subscription = assistantEventHub.subscribe(
-      { assistantId: "test-asst" },
-      (evt) => {
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (evt) => {
         received.push(evt);
       },
-    );
+    });
 
     try {
       const client = await openClient();
       const event = {
         id: "evt-1",
-        assistantId: "test-asst",
         conversationId: "conv-1",
         emittedAt: new Date().toISOString(),
         message: { type: "test_message", foo: "bar" },
@@ -171,7 +169,6 @@ describe("host.events.publish", () => {
 
       expect(received).toHaveLength(1);
       expect(received[0]?.id).toBe("evt-1");
-      expect(received[0]?.assistantId).toBe("test-asst");
       expect((received[0]?.message as unknown as { foo: string }).foo).toBe(
         "bar",
       );
@@ -198,7 +195,7 @@ describe("host.events.publish", () => {
 });
 
 describe("host.events.buildEvent", () => {
-  test("returns an envelope attributed to DAEMON_INTERNAL_ASSISTANT_ID", async () => {
+  test("returns a well-formed event envelope", async () => {
     const client = await openClient();
     const conversationId = "conv-xyz";
     const message = { type: "assistant_text_delta", text: "hi" };
@@ -211,7 +208,6 @@ describe("host.events.buildEvent", () => {
     const frame = await client.nextFrame();
     expect("result" in frame).toBe(true);
     const built = (frame as { result: AssistantEvent }).result;
-    expect(built.assistantId).toBe(DAEMON_INTERNAL_ASSISTANT_ID);
     expect(built.conversationId).toBe(conversationId);
     expect(typeof built.id).toBe("string");
     expect(typeof built.emittedAt).toBe("string");
@@ -222,7 +218,7 @@ describe("host.events.buildEvent", () => {
 });
 
 describe("host.events.subscribe", () => {
-  test("opens ack, delivers matching events, filters non-matching", async () => {
+  test("opens ack, delivers matching events, filters non-matching conversations", async () => {
     const baseSubscribers = assistantEventHub.subscriberCount();
     const client = await openClient();
     client.send({
@@ -230,7 +226,6 @@ describe("host.events.subscribe", () => {
       method: "host.events.subscribe",
       params: {
         filter: {
-          assistantId: "asst-a",
           conversationId: "conv-a",
         },
       },
@@ -265,16 +260,7 @@ describe("host.events.subscribe", () => {
       message: { type: "t2" },
     } as never);
 
-    // Non-matching event on a different assistant.
-    await assistantEventHub.publish({
-      id: "e3",
-      assistantId: "asst-b",
-      conversationId: "conv-a",
-      emittedAt: new Date().toISOString(),
-      message: { type: "t3" },
-    } as never);
-
-    // Confirm no delivery frame arrives for the non-matching events by
+    // Confirm no delivery frame arrives for the non-matching event by
     // publishing another matching event and asserting ordering.
     await assistantEventHub.publish({
       id: "e4",
@@ -300,7 +286,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-2",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-close" } },
+      params: { filter: {} },
     });
     await client.nextFrame(); // ack
     expect(assistantEventHub.subscriberCount()).toBe(baseSubscribers + 1);
@@ -324,7 +310,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-3",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-leak" } },
+      params: { filter: {} },
     });
     await client.nextFrame(); // ack
     expect(assistantEventHub.subscriberCount()).toBe(baseSubscribers + 1);
@@ -352,7 +338,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-4",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-stop" } },
+      params: { filter: {} },
     });
     await client.nextFrame(); // ack
     expect(assistantEventHub.subscriberCount()).toBe(baseSubscribers + 1);
@@ -371,7 +357,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-dup",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-dup" } },
+      params: { filter: {} },
     });
     const ack = await client.nextFrame();
     expect("result" in ack && ack.result).toEqual({ subscribed: true });
@@ -379,7 +365,7 @@ describe("host.events.subscribe", () => {
     client.send({
       id: "sub-dup",
       method: "host.events.subscribe",
-      params: { filter: { assistantId: "asst-dup" } },
+      params: { filter: {} },
     });
     const err = await client.nextFrame();
     expect("error" in err && err.error).toContain("sub-dup");

package/src/ipc/skill-routes/__tests__/identity.test.ts

@@ -1,8 +1,7 @@
 /**
  * Unit tests for the `host.identity.*` skill IPC routes. Mocks
  * `getAssistantName()` so we can assert both the resolved-name and
- * missing-name paths, and pins the internal assistant ID to the
- * canonical "self" constant.
+ * missing-name paths.
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -17,11 +16,8 @@ mock.module("../../../daemon/identity-helpers.js", () => ({
   getAssistantName: () => mockName,
 }));
 
-const {
-  hostIdentityGetAssistantNameRoute,
-  hostIdentityGetInternalAssistantIdRoute,
-  identityRoutes,
-} = await import("../identity.js");
+const { hostIdentityGetAssistantNameRoute, identityRoutes } =
+  await import("../identity.js");
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -59,23 +55,8 @@ describe("host.identity.getAssistantName IPC route", () => {
   });
 });
 
-describe("host.identity.getInternalAssistantId IPC route", () => {
-  test("method is host.identity.getInternalAssistantId", () => {
-    expect(hostIdentityGetInternalAssistantIdRoute.method).toBe(
-      "host.identity.getInternalAssistantId",
-    );
-  });
-
-  test("returns the daemon internal assistant id constant", async () => {
-    const result = await hostIdentityGetInternalAssistantIdRoute.handler();
-
-    expect(result).toBe("self");
-  });
-});
-
 describe("identityRoutes", () => {
-  test("exports both identity routes", () => {
+  test("exports the identity route", () => {
     expect(identityRoutes).toContain(hostIdentityGetAssistantNameRoute);
-    expect(identityRoutes).toContain(hostIdentityGetInternalAssistantIdRoute);
   });
 });

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

@@ -23,8 +23,8 @@
  *
  * - `host.events.buildEvent` — deterministic helper. Params
  *   `{ message, conversationId? }`. Returns the `AssistantEvent` envelope a
- *   skill would otherwise construct via `DAEMON_INTERNAL_ASSISTANT_ID` —
- *   keeping event-id allocation and timestamp generation on the daemon side
+ *   skill would otherwise construct locally — keeping event-id allocation
+ *   and timestamp generation on the daemon side
  *   so skill processes do not drift on UUID / clock sources.
  */
 
@@ -32,9 +32,8 @@ import { z } from "zod";
 
 import { buildAssistantEvent } from "../../runtime/assistant-event.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
-import type { SkillIpcStreamingRoute } from "../skill-server.js";
+import type { SkillIpcStreamingRoute } from "../skill-ipc-types.js";
 
 // ---------------------------------------------------------------------------
 // Param schemas
@@ -42,14 +41,13 @@ import type { SkillIpcStreamingRoute } from "../skill-server.js";
 
 /**
  * `AssistantEvent` wire shape accepted by `host.events.publish`. The
- * envelope fields (`id`, `assistantId`, `emittedAt`, `message`) are
- * required; `conversationId` is optional. The `message` payload is an
- * opaque JSON object — the daemon does not narrow it before handing it to
+ * envelope fields (`id`, `emittedAt`, `message`) are required;
+ * `conversationId` is optional. The `message` payload is an opaque JSON
+ * object — the daemon does not narrow it before handing it to
  * `assistantEventHub.publish`, matching the in-process hub contract.
  */
 const AssistantEventSchema = z.object({
   id: z.string().min(1),
-  assistantId: z.string().min(1),
   conversationId: z.string().optional(),
   emittedAt: z.string().min(1),
   message: z.record(z.string(), z.unknown()),
@@ -60,7 +58,6 @@ const PublishParams = z.object({
 });
 
 const FilterSchema = z.object({
-  assistantId: z.string().min(1),
   conversationId: z.string().optional(),
 });
 
@@ -90,11 +87,7 @@ async function handlePublish(
 
 function handleBuildEvent(params?: Record<string, unknown>): unknown {
   const { message, conversationId } = BuildEventParams.parse(params);
-  return buildAssistantEvent(
-    DAEMON_INTERNAL_ASSISTANT_ID,
-    message as never,
-    conversationId,
-  );
+  return buildAssistantEvent(message as never, conversationId);
 }
 
 // ---------------------------------------------------------------------------
@@ -111,18 +104,14 @@ export const eventsStreamingRoutes: SkillIpcStreamingRoute[] = [
     method: "host.events.subscribe",
     handler: (stream, params) => {
       const { filter } = SubscribeParams.parse(params);
-      const subscription = assistantEventHub.subscribe(
+      const subscription = assistantEventHub.subscribe({
+        type: "process",
         filter,
-        (event) => {
+        callback: (event) => {
           stream.send(event);
         },
-        // The hub evicts the oldest subscriber when its cap fills. Without
-        // this callback the IPC stream would silently stop receiving events
-        // while the client still believed it was subscribed. Mirror the SSE
-        // route's behavior by tearing the stream down with a terminal error
-        // frame so the client can resubscribe.
-        { onEvict: () => stream.close("subscription evicted by hub cap") },
-      );
+        onEvict: () => stream.close("subscription evicted by hub cap"),
+      });
       return () => {
         subscription.dispose();
       };

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

@@ -1,17 +1,12 @@
 /**
- * Skill IPC routes: `host.identity.getAssistantName` and
- * `host.identity.getInternalAssistantId`.
+ * Skill IPC route: `host.identity.getAssistantName`.
  *
- * Match the `IdentityFacet` surface exposed by `DaemonSkillHost`:
- * - `getAssistantName` reads the assistant's display name from IDENTITY.md,
- *   normalizing the daemon helper's `null` to `undefined` (serialized as
- *   `null` over JSON, which clients translate back to `undefined`).
- * - `getInternalAssistantId` returns the `DAEMON_INTERNAL_ASSISTANT_ID`
- *   constant (`"self"`) so skill-side code uses the same internal scope.
+ * Reads the assistant's display name from IDENTITY.md, normalizing the
+ * daemon helper's `null` to `undefined` (serialized as `null` over JSON,
+ * which clients translate back to `undefined`).
  */
 
 import { getAssistantName } from "../../daemon/identity-helpers.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
 
 export const hostIdentityGetAssistantNameRoute: SkillIpcRoute = {
@@ -21,14 +16,6 @@ export const hostIdentityGetAssistantNameRoute: SkillIpcRoute = {
   },
 };
 
-export const hostIdentityGetInternalAssistantIdRoute: SkillIpcRoute = {
-  method: "host.identity.getInternalAssistantId",
-  handler: () => {
-    return DAEMON_INTERNAL_ASSISTANT_ID;
-  },
-};
-
 export const identityRoutes: SkillIpcRoute[] = [
   hostIdentityGetAssistantNameRoute,
-  hostIdentityGetInternalAssistantIdRoute,
 ];

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

@@ -1,5 +1,5 @@
 import type { SkillIpcRoute } from "../skill-ipc-types.js";
-import type { SkillIpcStreamingRoute } from "../skill-server.js";
+import type { SkillIpcStreamingRoute } from "../skill-ipc-types.js";
 import { configRoutes } from "./config.js";
 import { eventsRoutes, eventsStreamingRoutes } from "./events.js";
 import { identityRoutes } from "./identity.js";

package/src/ipc/skill-server.ts

@@ -50,7 +50,11 @@ import { getLogger } from "../util/logger.js";
 import type { IpcRequest, IpcResponse } from "./assistant-server.js";
 
 export type { SkillIpcRoute, SkillMethodHandler } from "./skill-ipc-types.js";
-import type { SkillMethodHandler } from "./skill-ipc-types.js";
+import type {
+  SkillIpcStream,
+  SkillIpcStreamingHandler,
+  SkillMethodHandler,
+} from "./skill-ipc-types.js";
 import {
   skillIpcRoutes,
   skillIpcStreamingRoutes,
@@ -82,28 +86,6 @@ const DEFAULT_SEND_REQUEST_TIMEOUT_MS = 30_000;
 const SKILL_IPC_SUBSCRIBE_CLOSE_METHOD = "host.events.subscribe.close" as const;
 
 /** Stream handle passed to streaming-handler implementations. */
-export interface SkillIpcStream {
-  /** The original request id that opened this stream (used as the stream id). */
-  readonly id: string;
-  /**
-   * Send a delivery frame to the client. No-op after the stream has been
-   * closed (client disconnect, explicit close, or server shutdown).
-   */
-  send(payload: unknown): void;
-  /**
-   * Terminate the stream from the server side. Sends a final error frame to
-   * the client (if `errorMessage` is provided and the socket is still
-   * writable), invokes the handler-returned dispose, and unregisters the
-   * stream from the per-socket subscription map. Idempotent — subsequent
-   * calls are no-ops. Use from `onEvict`-style callbacks where the upstream
-   * source has decided to terminate the subscription, or to surface
-   * unrecoverable conditions like backpressure.
-   */
-  close(errorMessage?: string): void;
-  /** True until the stream has been disposed. */
-  readonly active: boolean;
-}
-
 /**
  * Maximum bytes Node may have queued in the socket's outbound buffer before
  * the next streaming `send` will close the stream with a backpressure error.
@@ -115,22 +97,7 @@ export interface SkillIpcStream {
  */
 const STREAM_BACKPRESSURE_BYTES = 1024 * 1024;
 
-/**
- * Handler signature for long-lived streaming methods (e.g.
- * `host.events.subscribe`). Runs synchronously with the opening request and
- * returns a dispose callback that the server invokes on client disconnect,
- * explicit close, or server shutdown.
- */
-export type SkillIpcStreamingHandler = (
-  stream: SkillIpcStream,
-  params?: Record<string, unknown>,
-) => () => void;
-
-/** Long-lived streaming route — method name + handler function. */
-export type SkillIpcStreamingRoute = {
-  method: string;
-  handler: SkillIpcStreamingHandler;
-};
+
 
 // ---------------------------------------------------------------------------
 // Per-connection context

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

@@ -97,7 +97,6 @@ type JsonFrame = Record<string, unknown>;
 
 const savedAuthEnv = {
   DISABLE_HTTP_AUTH: process.env.DISABLE_HTTP_AUTH,
-  VELLUM_UNSAFE_AUTH_BYPASS: process.env.VELLUM_UNSAFE_AUTH_BYPASS,
 };
 
 function mintGatewayToken(): string {
@@ -238,7 +237,6 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
 
   beforeEach(async () => {
     delete process.env.DISABLE_HTTP_AUTH;
-    delete process.env.VELLUM_UNSAFE_AUTH_BYPASS;
     resolveStreamingTranscriberImpl = async () => createResolvedTranscriber();
     resolveStreamingTranscriberMock.mockClear();
     resolvedTranscribers.length = 0;
@@ -260,12 +258,6 @@ describe("RuntimeHttpServer live voice WebSocket shell", () => {
     } else {
       process.env.DISABLE_HTTP_AUTH = savedAuthEnv.DISABLE_HTTP_AUTH;
     }
-    if (savedAuthEnv.VELLUM_UNSAFE_AUTH_BYPASS === undefined) {
-      delete process.env.VELLUM_UNSAFE_AUTH_BYPASS;
-    } else {
-      process.env.VELLUM_UNSAFE_AUTH_BYPASS =
-        savedAuthEnv.VELLUM_UNSAFE_AUTH_BYPASS;
-    }
   });
 
   function openLiveVoiceClient(token = mintGatewayToken()): WebSocket {

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

@@ -14,9 +14,9 @@ export type LiveVoiceMetricsEvent =
   | "turn_cancelled"
   | "session_ended";
 
-export type LiveVoiceTurnStatus = "active" | "completed" | "cancelled";
+type LiveVoiceTurnStatus = "active" | "completed" | "cancelled";
 
-export interface LiveVoiceMetricsCollectorOptions {
+interface LiveVoiceMetricsCollectorOptions {
   sessionId: string;
   conversationId?: string;
   clock?: LiveVoiceMetricsClock;
@@ -24,7 +24,7 @@ export interface LiveVoiceMetricsCollectorOptions {
   recentTurnLimit?: number;
 }
 
-export interface LiveVoiceSessionMetrics {
+interface LiveVoiceSessionMetrics {
   sessionId: string;
   conversationId?: string;
   startedAtMs: number;
@@ -32,7 +32,7 @@ export interface LiveVoiceSessionMetrics {
   startToReadyMs: number | null;
 }
 
-export interface LiveVoiceTurnTimestamps {
+interface LiveVoiceTurnTimestamps {
   startedAtMs: number;
   firstAudioAtMs: number | null;
   firstPartialAtMs: number | null;
@@ -44,7 +44,7 @@ export interface LiveVoiceTurnTimestamps {
   cancelledAtMs: number | null;
 }
 
-export interface LiveVoiceTurnDurations {
+interface LiveVoiceTurnDurations {
   firstAudioToFirstPartialMs: number | null;
   pttReleaseToFinalTranscriptMs: number | null;
   finalTranscriptToFirstAssistantDeltaMs: number | null;
@@ -52,7 +52,7 @@ export interface LiveVoiceTurnDurations {
   totalTurnDurationMs: number | null;
 }
 
-export interface LiveVoiceTurnMetrics {
+interface LiveVoiceTurnMetrics {
   turnId: string;
   status: LiveVoiceTurnStatus;
   cancellationReason: string | null;
@@ -60,13 +60,13 @@ export interface LiveVoiceTurnMetrics {
   durations: LiveVoiceTurnDurations;
 }
 
-export interface LiveVoiceDurationSummary {
+interface LiveVoiceDurationSummary {
   count: number;
   p50Ms: number | null;
   p95Ms: number | null;
 }
 
-export interface LiveVoiceMetricsSummary {
+interface LiveVoiceMetricsSummary {
   retainedTurnCount: number;
   completedTurnCount: number;
   cancelledTurnCount: number;
@@ -79,14 +79,14 @@ export interface LiveVoiceMetricsSummary {
   };
 }
 
-export interface LiveVoiceMetricsSnapshot {
+interface LiveVoiceMetricsSnapshot {
   session: LiveVoiceSessionMetrics;
   activeTurn: LiveVoiceTurnMetrics | null;
   recentTurns: LiveVoiceTurnMetrics[];
   summary: LiveVoiceMetricsSummary;
 }
 
-export interface LiveVoiceMetricsAggregateFields {
+interface LiveVoiceMetricsAggregateFields {
   sttMs: number | null;
   llmFirstDeltaMs: number | null;
   ttsFirstAudioMs: number | null;

package/src/live-voice/protocol.ts

@@ -1,4 +1,4 @@
-export const LIVE_VOICE_CLIENT_FRAME_TYPES = [
+const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "start",
   "audio",
   "ptt_release",
@@ -9,7 +9,7 @@ export const LIVE_VOICE_CLIENT_FRAME_TYPES = [
 export type LiveVoiceClientFrameType =
   (typeof LIVE_VOICE_CLIENT_FRAME_TYPES)[number];
 
-export const LIVE_VOICE_SERVER_FRAME_TYPES = [
+const _LIVE_VOICE_SERVER_FRAME_TYPES = [
   "ready",
   "busy",
   "stt_partial",
@@ -24,7 +24,7 @@ export const LIVE_VOICE_SERVER_FRAME_TYPES = [
 ] as const;
 
 export type LiveVoiceServerFrameType =
-  (typeof LIVE_VOICE_SERVER_FRAME_TYPES)[number];
+  (typeof _LIVE_VOICE_SERVER_FRAME_TYPES)[number];
 
 export const LiveVoiceProtocolErrorCode = {
   InvalidJson: "invalid_json",
@@ -38,15 +38,6 @@ export const LiveVoiceProtocolErrorCode = {
 export type LiveVoiceProtocolErrorCode =
   (typeof LiveVoiceProtocolErrorCode)[keyof typeof LiveVoiceProtocolErrorCode];
 
-export const LIVE_VOICE_PROTOCOL_ERROR_CODES = [
-  LiveVoiceProtocolErrorCode.InvalidJson,
-  LiveVoiceProtocolErrorCode.InvalidFrame,
-  LiveVoiceProtocolErrorCode.UnknownType,
-  LiveVoiceProtocolErrorCode.MissingRequiredField,
-  LiveVoiceProtocolErrorCode.InvalidField,
-  LiveVoiceProtocolErrorCode.InvalidAudioPayload,
-] as const satisfies readonly LiveVoiceProtocolErrorCode[];
-
 export interface LiveVoiceProtocolError {
   readonly code: LiveVoiceProtocolErrorCode;
   readonly message: string;
@@ -208,7 +199,7 @@ export type LiveVoiceServerFramePayload =
   | WithoutSeq<LiveVoiceArchivedServerFrame>
   | WithoutSeq<LiveVoiceErrorServerFrame>;
 
-export class LiveVoiceServerFrameSequencer {
+class LiveVoiceServerFrameSequencer {
   private seq: number;
 
   constructor(initialSeq = 0) {