@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/home/__tests__/suggested-prompts.test.ts

@@ -61,6 +61,7 @@ mock.module("../../runtime/assistant-event.js", () => ({
 
 mock.module("../../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: { publish: async () => {} },
+  broadcastMessage: () => {},
 }));
 
 const { getSuggestedPrompts, refreshAssistantSuggestedPrompts } =

package/src/home/feed-writer.ts

@@ -37,8 +37,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
 import { getDataDir } from "../util/platform.js";
 import {
@@ -523,15 +522,9 @@ function compareFeedItems(a: FeedItem, b: FeedItem): number {
  * writer coalescing loop.
  */
 function publishHomeFeedUpdated(updatedAt: string, newItemCount: number): void {
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "home_feed_updated",
-        updatedAt,
-        newItemCount,
-      }),
-    )
-    .catch((err) => {
-      log.warn({ err }, "Failed to publish home_feed_updated event");
-    });
+  broadcastMessage({
+    type: "home_feed_updated",
+    updatedAt,
+    newItemCount,
+  });
 }

package/src/home/home-content-refresh.ts

@@ -14,8 +14,7 @@
  * (4 hours each) bound how often a regeneration can happen.
  */
 
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getLogger } from "../util/logger.js";
 import { refreshPersonalizedGreeting } from "./home-greeting.js";
 import { refreshAssistantSuggestedPrompts } from "./suggested-prompts.js";
@@ -34,13 +33,11 @@ async function revalidateAll(): Promise<void> {
     return;
   }
 
-  await assistantEventHub.publish(
-    buildAssistantEvent({
-      type: "home_feed_updated",
-      updatedAt: new Date().toISOString(),
-      newItemCount: 0,
-    }),
-  );
+  broadcastMessage({
+    type: "home_feed_updated",
+    updatedAt: new Date().toISOString(),
+    newItemCount: 0,
+  });
 }
 
 /**

package/src/home/relationship-state-writer.ts

@@ -25,8 +25,7 @@ import { getGuardianDelivery } from "../contacts/guardian-delivery-reader.js";
 import { listConnections } from "../oauth/oauth-store.js";
 import { countConversations as countConversationsDb } from "../persistence/conversation-queries.js";
 import { resolveGuardianPersonaPath } from "../prompts/persona-resolver.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -316,16 +315,10 @@ export async function writeRelationshipState(): Promise<void> {
  * just landed on disk.
  */
 function publishRelationshipStateUpdated(updatedAt: string): void {
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "relationship_state_updated",
-        updatedAt,
-      }),
-    )
-    .catch((err) => {
-      log.warn({ err }, "Failed to publish relationship_state_updated event");
-    });
+  broadcastMessage({
+    type: "relationship_state_updated",
+    updatedAt,
+  });
 }
 
 /**

package/src/home/suggested-prompts-cache.ts

@@ -16,13 +16,9 @@ import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
 } from "../persistence/checkpoints.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { getLogger } from "../util/logger.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { SuggestedPrompt } from "./feed-types.js";
 
-const log = getLogger("suggested-prompts-cache");
-
 const LLM_CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
 
 const CHECKPOINT_KEY_JSON = "home:suggested_prompts:json";
@@ -74,18 +70,9 @@ export function invalidateAssistantSuggestedPromptsCache(): void {
   } catch {
     // Invalidation failure is non-fatal — the TTL still bounds staleness.
   }
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "home_feed_updated",
-        updatedAt: new Date().toISOString(),
-        newItemCount: 0,
-      }),
-    )
-    .catch((err) => {
-      log.warn(
-        { err },
-        "Failed to publish home_feed_updated after prompt cache invalidation",
-      );
-    });
+  broadcastMessage({
+    type: "home_feed_updated",
+    updatedAt: new Date().toISOString(),
+    newItemCount: 0,
+  });
 }

package/src/ipc/__tests__/events-publish-client.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Tests the side-process → daemon publish forwarder. It calls the daemon's
+ * `/events/publish` IPC route with the event envelope, and is best-effort: a
+ * transport failure is logged, never thrown.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { AssistantEventEnvelope } from "../../api/index.js";
+
+interface IpcCall {
+  method: string;
+  params?: Record<string, unknown>;
+}
+const ipcCalls: IpcCall[] = [];
+let ipcResult: { ok: boolean; error?: string } = { ok: true };
+
+mock.module("../cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    ipcCalls.push({ method, params });
+    return ipcResult;
+  },
+}));
+
+const { EVENTS_PUBLISH_IPC_METHOD, forwardEventPublishToDaemon } =
+  await import("../events-publish-client.js");
+
+function event(): AssistantEventEnvelope {
+  return {
+    id: "e1",
+    conversationId: "c1",
+    emittedAt: "2026-01-01T00:00:00.000Z",
+    message: {
+      type: "sync_changed",
+    } as unknown as AssistantEventEnvelope["message"],
+  };
+}
+
+beforeEach(() => {
+  ipcCalls.length = 0;
+  ipcResult = { ok: true };
+});
+
+describe("forwardEventPublishToDaemon", () => {
+  test("calls the /events/publish route with the event (and options when present)", async () => {
+    await forwardEventPublishToDaemon(event(), { excludeClientId: "tab-1" });
+    expect(ipcCalls).toHaveLength(1);
+    expect(ipcCalls[0].method).toBe(EVENTS_PUBLISH_IPC_METHOD);
+    expect(ipcCalls[0].params).toEqual({
+      body: { event: event(), options: { excludeClientId: "tab-1" } },
+    });
+  });
+
+  test("passes undefined options through when none are given", async () => {
+    await forwardEventPublishToDaemon(event(), undefined);
+    expect(ipcCalls[0].params).toEqual({
+      body: { event: event(), options: undefined },
+    });
+  });
+
+  test("does not throw when the IPC transport fails", async () => {
+    ipcResult = { ok: false, error: "connect failed" };
+    await expect(
+      forwardEventPublishToDaemon(event(), undefined),
+    ).resolves.toBeUndefined();
+  });
+});

package/src/ipc/events-publish-client.ts

@@ -0,0 +1,44 @@
+/**
+ * Client transport for forwarding an event publish to the daemon.
+ *
+ * The daemon owns the event hub and the client connections it fans out to. A
+ * side process (a sidecar worker, the route host) that publishes to its *own*
+ * in-process hub reaches no SSE subscriber, so it must hand the event to the
+ * daemon instead. This module is that hand-off: it calls the daemon's
+ * `/events/publish` IPC route ({@link EVENTS_PUBLISH_IPC_METHOD}), which
+ * republishes the event on the daemon's real hub.
+ *
+ * The method-name constant lives here (not in the route module) so callers can
+ * import it without pulling in the route handler's dependency graph.
+ */
+
+import type { AssistantEventEnvelope } from "../api/index.js";
+import type { AssistantEventPublishOptions } from "../runtime/assistant-event-publish-options.js";
+import { getLogger } from "../util/logger.js";
+import { cliIpcCall } from "./cli-client.js";
+
+const log = getLogger("events-publish-client");
+
+/** IPC method name — the raw publish transport other processes call. */
+export const EVENTS_PUBLISH_IPC_METHOD = "/events/publish";
+
+/**
+ * Forward an event publish to the daemon over IPC. Best-effort: a transport
+ * failure is logged, not thrown — a dropped UI-invalidation must never surface
+ * as a handler error (mirroring the local hub, whose subscriber failures are
+ * isolated from the publisher).
+ */
+export async function forwardEventPublishToDaemon(
+  event: AssistantEventEnvelope,
+  options: AssistantEventPublishOptions | undefined,
+): Promise<void> {
+  const result = await cliIpcCall(EVENTS_PUBLISH_IPC_METHOD, {
+    body: { event, options },
+  });
+  if (!result.ok) {
+    log.warn(
+      { err: result.error, eventType: event.message?.type },
+      "Failed to forward event publish to the daemon",
+    );
+  }
+}

package/src/ipc/routes/__tests__/conversation-sync-ipc-routes.test.ts

@@ -29,13 +29,13 @@ mock.module("../../../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
+import type { AssistantEventEnvelope } from "../../../api/index.js";
 import type { EventHandlerState } from "../../../daemon/conversation-agent-loop-handlers.js";
 import { DB_MIGRATION_READINESS_EXEMPT_OPERATIONS } from "../../../daemon/daemon-readiness.js";
 import {
   registerInflightTurn,
   unregisterInflightTurn,
 } from "../../../daemon/inflight-turn-registry.js";
-import type { AssistantEvent } from "../../../runtime/assistant-event.js";
 import {
   _resetStreamStateForTesting,
   stampAndBuffer,
@@ -50,7 +50,7 @@ function stampEvent(): void {
   stampAndBuffer({
     conversationId: "conv-x",
     message: { type: "assistant_text_delta", text: "x" },
-  } as unknown as AssistantEvent);
+  } as unknown as AssistantEventEnvelope);
 }
 
 describe("conversation-sync IPC route", () => {

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

@@ -1,10 +1,8 @@
 import { afterEach, describe, expect, test } from "bun:test";
 
+import { EVENTS_PUBLISH_IPC_METHOD } from "../../../ipc/events-publish-client.js";
 import { assistantEventHub } from "../../../runtime/assistant-event-hub.js";
-import {
-  EVENTS_PUBLISH_IPC_METHOD,
-  handleEventsPublish,
-} from "../events-ipc-routes.js";
+import { handleEventsPublish } from "../events-ipc-routes.js";
 
 describe(`${EVENTS_PUBLISH_IPC_METHOD} IPC route`, () => {
   const disposers: Array<() => void> = [];
@@ -39,17 +37,48 @@ describe(`${EVENTS_PUBLISH_IPC_METHOD} IPC route`, () => {
   test("publishes a full event envelope onto the daemon hub", async () => {
     const received = subscribe();
 
+    const message = {
+      type: "generation_cancelled",
+      conversationId: "conv-events-test",
+    };
     const result = await handleEventsPublish({
-      body: { event: fullEvent({ type: "test_event", value: 42 }) },
+      body: { event: fullEvent(message) },
     });
 
     expect(result).toEqual({ ok: true });
     expect(received).toHaveLength(1);
     expect((received[0] as { id: string }).id).toBe("evt-1");
-    expect((received[0] as { message: unknown }).message).toEqual({
-      type: "test_event",
-      value: 42,
+    expect((received[0] as { message: unknown }).message).toEqual(message);
+  });
+
+  test("stamps a forwarded conversation-scoped event with a seq for replay", async () => {
+    const received = subscribe();
+
+    // A forwarded event arrives unstamped (the worker that produced it has seq
+    // stamping disabled). The daemon boundary must assign a `seq` so the event
+    // takes a slot in the SSE replay ring and reconnecting clients see it in
+    // order, rather than a gap.
+    const event = fullEvent({
+      type: "generation_cancelled",
+      conversationId: "conv-events-test",
     });
+    expect((event as { seq?: number }).seq).toBeUndefined();
+
+    await handleEventsPublish({ body: { event } });
+
+    expect(received).toHaveLength(1);
+    expect(typeof (received[0] as { seq?: unknown }).seq).toBe("number");
+  });
+
+  test("rejects a message that is not a known event type", async () => {
+    const received = subscribe();
+
+    await expect(
+      handleEventsPublish({
+        body: { event: fullEvent({ type: "not_a_real_event" }) },
+      }),
+    ).rejects.toThrow();
+    expect(received).toHaveLength(0);
   });
 
   test("rejects an incomplete envelope (missing id)", async () => {
@@ -60,7 +89,7 @@ describe(`${EVENTS_PUBLISH_IPC_METHOD} IPC route`, () => {
         body: {
           event: {
             emittedAt: "2026-07-21T00:00:00.000Z",
-            message: { type: "test_event" },
+            message: { type: "generation_cancelled" },
           },
         },
       }),

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

@@ -23,47 +23,27 @@
 import { z } from "zod";
 
 import { AssistantEventEnvelopeSchema } from "../../api/index.js";
-import {
-  HOST_PROXY_CAPABILITIES,
-  INTERFACE_IDS,
-} from "../../channels/types.js";
-import type { ServerMessage } from "../../daemon/message-protocol.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
+import { AssistantEventPublishOptionsSchema } from "../../runtime/assistant-event-publish-options.js";
+import { stampAndBuffer } from "../../runtime/assistant-stream-state.js";
 import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
-
-/** IPC method name — the raw publish transport other processes call. */
-export const EVENTS_PUBLISH_IPC_METHOD = "/events/publish";
-
-/**
- * The event envelope reuses the shared wire schema's transport fields (`id`,
- * `emittedAt`, `conversationId`, `seq`) and overrides only `message`: the hub
- * publishes runtime `ServerMessage`-typed events, whose union is defined
- * separately from the api schema's message union, so the override yields a
- * value assignable to `assistantEventHub.publish` without a cast.
- */
-const EventEnvelopeSchema = AssistantEventEnvelopeSchema.extend({
-  message: z.custom<ServerMessage>(
-    (value) => value != null && typeof value === "object",
-  ),
-});
-
-/** Publish targeting/suppression options — see the hub's `publish`. */
-const PublishOptionsSchema = z.object({
-  targetCapability: z.enum(HOST_PROXY_CAPABILITIES).optional(),
-  targetClientId: z.string().optional(),
-  targetInterfaceId: z.enum(INTERFACE_IDS).optional(),
-  excludeClientId: z.string().optional(),
-});
+import { EVENTS_PUBLISH_IPC_METHOD } from "../events-publish-client.js";
 
 const EventsPublishParamsSchema = z.object({
-  event: EventEnvelopeSchema,
-  options: PublishOptionsSchema.optional(),
+  event: AssistantEventEnvelopeSchema,
+  options: AssistantEventPublishOptionsSchema.optional(),
 });
 
 export async function handleEventsPublish({
   body = {},
 }: RouteHandlerArgs): Promise<{ ok: true }> {
   const { event, options } = EventsPublishParamsSchema.parse(body);
+  // A forwarded event comes from a process where seq stamping is disabled
+  // (a worker), so it arrives with no `seq` and was never buffered for SSE
+  // replay. The daemon is the seq authority, so stamp + buffer here — at the
+  // transport boundary, before fanout — exactly as `broadcastMessage` does on
+  // the in-daemon path, so reconnecting clients replay it in order.
+  stampAndBuffer(event, { targeting: options });
   await assistantEventHub.publish(event, options);
   return { ok: true };
 }

package/src/live-voice/__tests__/front-decision.test.ts

@@ -1,10 +1,11 @@
 /**
- * Tests for the VoiceFrontDecider endpoint-decision service.
+ * Tests for the VoiceFrontDecider spoken-text service.
  *
  * The provider is injected via the `getProvider` seam (live-voice DI
- * convention), so no module mocking is needed. The tests pin the fail-open
+ * convention), so no module mocking is needed. The tests pin the fail-soft
  * contract: every failure mode (null provider, timeout, thrown error, caller
- * abort) resolves to "release" within the configured budget.
+ * abort) resolves to `null` within the configured budget, and the caller
+ * speaks nothing.
  *
  * generateAckText and generateProgressText share one implementation
  * (`generateBoundedSpokenText`), so their common failure modes are pinned in
@@ -19,20 +20,12 @@ import type { Provider, ProviderResponse } from "../../providers/types.js";
 import {
   createVoiceFrontDecider,
   type VoiceAckTextInput,
-  type VoiceEndpointDecisionInput,
   type VoiceFrontDecider,
   type VoiceProgressTextInput,
 } from "../front-decision.js";
 
 const config = LiveVoiceFrontModelConfigSchema.parse({});
 
-const input: VoiceEndpointDecisionInput = {
-  transcriptSoFar: "so what I was thinking is",
-  latestPartial: null,
-  silenceThresholdMs: 1200,
-  extensionCount: 0,
-};
-
 const ackInput: VoiceAckTextInput = {
   transcriptSoFar: "can you check my calendar for tomorrow",
 };
@@ -71,171 +64,6 @@ function toolResponse(
   };
 }
 
-function textResponse(text: string): ProviderResponse {
-  return {
-    content: [{ type: "text", text }],
-    model: "stub-model",
-    usage: { inputTokens: 1, outputTokens: 1 },
-    stopReason: "end_turn",
-  };
-}
-
-describe("createVoiceFrontDecider — decideEndpoint", () => {
-  test('answer "0" → hold', async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse("0")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "hold" });
-  });
-
-  test('answer "1" → release', async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse("1")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test('answer "0" with trailing delimiter → hold', async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse(" 0\n")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "hold" });
-  });
-
-  test("sends transcript, tight token budget, no tools, and call-site config", async () => {
-    let captured: Parameters<Provider["sendMessage"]> | undefined;
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async (...args) => {
-          captured = args;
-          return textResponse("1");
-        }),
-    });
-    await decider.decideEndpoint({ ...input, latestPartial: "and then" });
-
-    const [messages, options] = captured!;
-    expect(messages).toHaveLength(1);
-    const text = (messages[0].content[0] as { text: string }).text;
-    expect(text).toContain("so what I was thinking is");
-    expect(text).toContain("and then");
-    expect(options?.config).toMatchObject({
-      max_tokens: 4,
-      callSite: "voiceFrontDecision",
-      disableCache: true,
-    });
-    // Single-token text protocol: no tool schema in the prompt, no forced
-    // tool call in the output — the latency-critical path stays minimal.
-    expect(options?.tools).toBeUndefined();
-    expect(options?.config?.tool_choice).toBeUndefined();
-    expect(options?.systemPrompt).toContain("finished");
-  });
-
-  test("null provider → release (fail-open)", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => null,
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("provider resolution throws → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => {
-        throw new Error("resolution boom");
-      },
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("getProvider that never resolves → release after endpointDecisionTimeoutMs", async () => {
-    const decider = createVoiceFrontDecider({
-      config: LiveVoiceFrontModelConfigSchema.parse({
-        endpointDecisionTimeoutMs: 20,
-      }),
-      // Stalled lazy provider initialization — the timeout must bound the
-      // whole call including resolution, not just sendMessage.
-      getProvider: () => new Promise<Provider | null>(() => {}),
-    });
-    const start = Date.now();
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-    expect(Date.now() - start).toBeLessThan(1000);
-  });
-
-  test("sendMessage that never resolves → release after endpointDecisionTimeoutMs", async () => {
-    const decider = createVoiceFrontDecider({
-      config: LiveVoiceFrontModelConfigSchema.parse({
-        endpointDecisionTimeoutMs: 20,
-      }),
-      // Never settles and ignores the abort signal entirely — the decider's
-      // own timeout race must still bound the call.
-      getProvider: async () =>
-        stubProvider(() => new Promise<ProviderResponse>(() => {})),
-    });
-    const start = Date.now();
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-    expect(Date.now() - start).toBeLessThan(1000);
-  });
-
-  test("sendMessage throws → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async () => {
-          throw new Error("provider boom");
-        }),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("caller-signal abort → release promptly", async () => {
-    const decider = createVoiceFrontDecider({
-      // Long timeout so only the caller's abort can end the call early.
-      config: LiveVoiceFrontModelConfigSchema.parse({
-        endpointDecisionTimeoutMs: 60_000,
-      }),
-      getProvider: async () =>
-        stubProvider(() => new Promise<ProviderResponse>(() => {})),
-    });
-    const controller = new AbortController();
-    const pending = decider.decideEndpoint(input, controller.signal);
-    controller.abort();
-    const start = Date.now();
-    expect(await pending).toEqual({ action: "release" });
-    expect(Date.now() - start).toBeLessThan(1000);
-  });
-
-  test("response without a text block → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async () => toolResponse({ complete: false })),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("empty text answer → release", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () => stubProvider(async () => textResponse("   ")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-
-  test("non-protocol prose answer → release (fail-open)", async () => {
-    const decider = createVoiceFrontDecider({
-      config,
-      getProvider: async () =>
-        stubProvider(async () => textResponse("The speaker seems unsure")),
-    });
-    expect(await decider.decideEndpoint(input)).toEqual({ action: "release" });
-  });
-});
-
 /**
  * One case per spoken-text method, carrying the values that differ between
  * them: the forced tool, the tool-input field, the length cap, the timeout