@vellumai/assistant 0.8.6 → 0.8.7

package/src/runtime/background-job-runner.ts

@@ -248,26 +248,23 @@ export async function runBackgroundJob(
         conversation.id,
         "user",
         opts.assistantSandwich.preamble,
-        undefined,
         { skipIndexing: true },
       );
       await addMessage(
         conversation.id,
         "assistant",
         opts.assistantSandwich.content,
-        undefined,
         { skipIndexing: true },
       );
       await addMessage(
         conversation.id,
         "user",
         opts.assistantSandwich.postamble,
-        undefined,
         { skipIndexing: true },
       );
     }
 
-    const work = processMessage(conversation.id, opts.prompt, undefined, {
+    const work = processMessage(conversation.id, opts.prompt, {
       trustContext: opts.trustContext,
       callSite: opts.callSite,
     });

package/src/runtime/btw-sidechain.ts

@@ -89,7 +89,9 @@ export async function runBtwSidechain(
   let hadTextDeltas = false;
 
   try {
-    const response = await provider.sendMessage(messages, tools, systemPrompt, {
+    const response = await provider.sendMessage(messages, {
+      tools,
+      systemPrompt,
       config: {
         max_tokens: params.maxTokens ?? 1024,
         tool_choice: { type: "none" },

package/src/runtime/channel-approvals.ts

@@ -170,20 +170,9 @@ export function handleChannelDecision(
   const conversation = findConversation(resolved.conversationId);
   if (!conversation) return { applied: false };
 
-  if (decisionContext === undefined) {
-    conversation.handleConfirmationResponse(
-      info.requestId,
-      userDecision,
-    );
-  } else {
-    conversation.handleConfirmationResponse(
-      info.requestId,
-      userDecision,
-      undefined,
-      undefined,
-      decisionContext,
-    );
-  }
+  conversation.handleConfirmationResponse(info.requestId, userDecision, {
+    decisionContext,
+  });
 
   return {
     applied: true,

package/src/runtime/channel-invite-transport.ts

@@ -13,8 +13,6 @@
  */
 
 import type { ChannelId } from "../channels/types.js";
-import { getConfig } from "../config/loader.js";
-import { isEmailEnabled } from "../email/feature-gate.js";
 import { emailInviteAdapter } from "./channel-invite-transports/email.js";
 import { slackInviteAdapter } from "./channel-invite-transports/slack.js";
 import { telegramInviteAdapter } from "./channel-invite-transports/telegram.js";
@@ -24,7 +22,10 @@ import { whatsappInviteAdapter } from "./channel-invite-transports/whatsapp.js";
 // Types
 // ---------------------------------------------------------------------------
 import type { ChannelInviteAdapter } from "./channel-invite-types.js";
-export type { ChannelInviteAdapter, InviteShareLink } from "./channel-invite-types.js";
+export type {
+  ChannelInviteAdapter,
+  InviteShareLink,
+} from "./channel-invite-types.js";
 
 // ---------------------------------------------------------------------------
 // Registry
@@ -95,9 +96,7 @@ export async function resolveAdapterHandle(
 /** Create a registry instance with built-in adapters registered. */
 export function createInviteAdapterRegistry(): InviteAdapterRegistry {
   const registry = new InviteAdapterRegistry();
-  if (isEmailEnabled(getConfig())) {
-    registry.register(emailInviteAdapter);
-  }
+  registry.register(emailInviteAdapter);
   registry.register(slackInviteAdapter);
   registry.register(telegramInviteAdapter);
   registry.register(voiceInviteAdapter);

package/src/runtime/channel-readiness-service.ts

@@ -7,8 +7,7 @@ import { resolveTwilioPhoneNumber } from "../calls/twilio-config.js";
 import { hasTwilioCredentials } from "../calls/twilio-rest.js";
 import { getChannelInvitePolicy } from "../channels/config.js";
 import { getIsPlatform } from "../config/env-registry.js";
-import { getConfig, getNestedValue, loadRawConfig } from "../config/loader.js";
-import { isEmailEnabled } from "../email/feature-gate.js";
+import { getNestedValue, loadRawConfig } from "../config/loader.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 import { resolveWhatsAppDisplayNumber } from "./channel-invite-transports/whatsapp.js";
@@ -513,9 +512,7 @@ export function createReadinessService(): ChannelReadinessService {
   const service = new ChannelReadinessService();
   service.registerProbe(voiceProbe);
   service.registerProbe(telegramProbe);
-  if (isEmailEnabled(getConfig())) {
-    service.registerProbe(emailProbe);
-  }
+  service.registerProbe(emailProbe);
   service.registerProbe(whatsappProbe);
   service.registerProbe(slackProbe);
   return service;

package/src/runtime/channel-retry-sweep.ts

@@ -298,26 +298,22 @@ export async function sweepFailedEvents(
 
     let userMessageId: string | undefined;
     try {
-      const result = await processMessage(
-        event.conversationId,
-        content,
+      const result = await processMessage(event.conversationId, content, {
         attachmentIds,
-        {
-          transport: {
-            channelId: sourceChannel,
-            hints: metadataHints.length > 0 ? metadataHints : undefined,
-            uxBrief: metadataUxBrief,
-            chatType: metadataChatType,
-          },
-          assistantId,
-          trustContext,
-          isInteractive:
-            resolveRoutingStateFromRuntime(trustContext).promptWaitingAllowed,
-          onEvent: observeAgentEvent,
+        transport: {
+          channelId: sourceChannel,
+          hints: metadataHints.length > 0 ? metadataHints : undefined,
+          uxBrief: metadataUxBrief,
+          chatType: metadataChatType,
         },
+        assistantId,
+        trustContext,
+        isInteractive:
+          resolveRoutingStateFromRuntime(trustContext).promptWaitingAllowed,
+        onEvent: observeAgentEvent,
         sourceChannel,
         sourceInterface,
-      );
+      });
       userMessageId = result.messageId;
       linkMessage(event.id, userMessageId);
       markProcessed(event.id);

package/src/runtime/conversation-stream-state.ts

@@ -0,0 +1,294 @@
+/**
+ * Conversation Stream State -- per-conversation SSE sequence counter and
+ * ring buffer for `Last-Event-ID` replay (B7 Unit 1).
+ *
+ * Every conversation-scoped outbound event picks up a monotonic `seq`
+ * number from this module. The same event is also pushed onto a bounded
+ * ring buffer so a reconnecting client can request replay of events the
+ * daemon emitted while it was disconnected.
+ *
+ * Bounds (oldest evicted first; first bound hit wins):
+ * - Count: 200 events
+ * - Total size: 256 KB
+ * - Age: 30 seconds
+ *
+ * The ring is in-memory and per-daemon-process. After a daemon restart
+ * all seqs reset and reconnecting clients fall through to the snapshot
+ * path (delivered by B7 Unit 2). The ring is sized generously enough
+ * that a typical refresh round-trip (~1-3s) is well within window.
+ */
+
+import type { AssistantEvent } from "./assistant-event.js";
+
+// ── Tunables ─────────────────────────────────────────────────────────
+
+const RING_COUNT_LIMIT = 200;
+const RING_SIZE_LIMIT_BYTES = 256 * 1024;
+const RING_AGE_LIMIT_MS = 30_000;
+
+// ── Types ────────────────────────────────────────────────────────────
+
+/**
+ * Targeting / exclusion modifiers attached to an event at publish time.
+ * Stored on ring entries so replay can re-apply the same delivery
+ * filter that the live `publish()` path used.
+ *
+ * Fields use plain `string` rather than branded channel types so
+ * this module stays independent of the `channels/` package.
+ */
+export interface EventTargeting {
+  targetCapability?: string;
+  targetClientId?: string;
+  targetInterfaceId?: string;
+  excludeClientId?: string;
+}
+
+/**
+ * Identity of the subscriber requesting a replay window. Replay
+ * filtering mirrors the live `publish()` logic in `AssistantEventHub`:
+ * targeted entries are only delivered when the subscriber matches.
+ */
+export interface ReplaySubscriber {
+  type: "client" | "process";
+  clientId?: string;
+  interfaceId?: string;
+  capabilities?: readonly string[];
+}
+
+interface RingEntry {
+  seq: number;
+  event: AssistantEvent;
+  emittedAt: number;
+  sizeBytes: number;
+  targeting?: EventTargeting;
+}
+
+interface ConversationStreamState {
+  nextSeq: number;
+  ring: RingEntry[];
+  totalSizeBytes: number;
+}
+
+// ── State ────────────────────────────────────────────────────────────
+
+const streams = new Map<string, ConversationStreamState>();
+
+function getOrCreate(conversationId: string): ConversationStreamState {
+  let state = streams.get(conversationId);
+  if (!state) {
+    state = { nextSeq: 1, ring: [], totalSizeBytes: 0 };
+    streams.set(conversationId, state);
+  }
+  return state;
+}
+
+// ── Public API ───────────────────────────────────────────────────────
+
+/**
+ * Assign a monotonic `seq` to a conversation-scoped event and push it
+ * onto the ring buffer. No-op when `event.conversationId` is absent
+ * (unscoped broadcasts are never replayable).
+ *
+ * When `options.targeting` is provided, the metadata is stored on the
+ * ring entry so that {@link getReplayWindow} can re-apply the same
+ * delivery filter at replay time. This keeps targeted events in the
+ * ring (preventing false-positive seq gaps on reconnect) without
+ * leaking them to subscribers outside their intended delivery set.
+ *
+ * Mutates `event.seq` in place.
+ */
+export function stampAndBuffer(
+  event: AssistantEvent,
+  options?: { targeting?: EventTargeting },
+): void {
+  const cid = event.conversationId;
+  if (cid == null) return;
+
+  const state = getOrCreate(cid);
+  event.seq = state.nextSeq++;
+
+  // Approximate size by serialized JSON length. This is the same
+  // bytes-on-wire we'll send, so it tracks ring memory pressure
+  // closely without a separate measurement pass.
+  const sizeBytes = JSON.stringify(event).length;
+  const entry: RingEntry = {
+    seq: event.seq,
+    event,
+    emittedAt: Date.now(),
+    sizeBytes,
+  };
+  if (options?.targeting) {
+    entry.targeting = options.targeting;
+  }
+  state.ring.push(entry);
+  state.totalSizeBytes += sizeBytes;
+
+  evict(state);
+}
+
+/**
+ * Replay events with `seq > lastSeenSeq` for a given conversation.
+ * Returns `null` when the requested cursor is older than the oldest
+ * buffered entry -- callers should fall back to a snapshot resync.
+ *
+ * When `subscriber` is provided, entries carrying targeting metadata
+ * are filtered using the same rules as the live `publish()` path in
+ * `AssistantEventHub`. This prevents targeted events from leaking to
+ * subscribers outside their intended delivery set on reconnect.
+ * When `subscriber` is omitted, all entries are returned unfiltered
+ * (backwards-compatible behaviour).
+ *
+ * Sweeps age-expired entries at read time so an idle conversation
+ * cannot serve stale deltas past the 30-second window (eviction
+ * only runs on `stampAndBuffer`, so without this an idle stream
+ * would retain its tail until the next write). When the sweep
+ * drains the ring entirely, the conversation's state entry is
+ * dropped to keep the global map from growing unboundedly with
+ * inactive conversations.
+ */
+export function getReplayWindow(
+  conversationId: string,
+  lastSeenSeq: number,
+  subscriber?: ReplaySubscriber,
+): readonly AssistantEvent[] | null {
+  const state = streams.get(conversationId);
+  if (!state) return [];
+
+  evict(state);
+
+  if (state.ring.length === 0) {
+    streams.delete(conversationId);
+    return [];
+  }
+
+  const oldest = state.ring[0]?.seq ?? Infinity;
+  if (lastSeenSeq < oldest - 1) return null;
+
+  return state.ring
+    .filter(
+      (entry) =>
+        entry.seq > lastSeenSeq &&
+        (subscriber == null || matchesSubscriber(entry, subscriber)),
+    )
+    .map((entry) => entry.event);
+}
+
+/**
+ * Drop all state for a conversation. Currently unused -- the ring
+ * self-evicts by age -- but exposed for explicit dispose flows
+ * (e.g. when a conversation is deleted).
+ */
+export function clearConversationStream(conversationId: string): void {
+  streams.delete(conversationId);
+}
+
+/**
+ * Reset all stream state. Test-only.
+ */
+export function _resetConversationStreamsForTesting(): void {
+  streams.clear();
+}
+
+/**
+ * Read-only inspector for tests.
+ */
+export function _peekStreamForTesting(conversationId: string): {
+  nextSeq: number;
+  ringLength: number;
+  totalSizeBytes: number;
+  oldestSeq: number | null;
+  newestSeq: number | null;
+} | null {
+  const state = streams.get(conversationId);
+  if (!state) return null;
+  return {
+    nextSeq: state.nextSeq,
+    ringLength: state.ring.length,
+    totalSizeBytes: state.totalSizeBytes,
+    oldestSeq: state.ring[0]?.seq ?? null,
+    newestSeq: state.ring[state.ring.length - 1]?.seq ?? null,
+  };
+}
+
+// ── Internals ────────────────────────────────────────────────────────
+
+/**
+ * Mirrors the delivery logic in `AssistantEventHub.publish()`. Returns
+ * `true` when `subscriber` would have received the entry during live
+ * fanout.
+ */
+function matchesSubscriber(
+  entry: RingEntry,
+  subscriber: ReplaySubscriber,
+): boolean {
+  const t = entry.targeting;
+  if (!t) return true;
+
+  // Self-echo suppression: the originating client never receives the
+  // event back.
+  if (
+    t.excludeClientId != null &&
+    subscriber.type === "client" &&
+    subscriber.clientId === t.excludeClientId
+  ) {
+    return false;
+  }
+
+  // Interface targeting: only clients of the requested interface.
+  if (t.targetInterfaceId != null) {
+    if (
+      subscriber.type !== "client" ||
+      subscriber.interfaceId !== t.targetInterfaceId
+    ) {
+      return false;
+    }
+  }
+
+  if (t.targetClientId != null) {
+    // Client targeting: bypass conversation filter, deliver only to the
+    // named client.
+    if (
+      subscriber.type !== "client" ||
+      subscriber.clientId !== t.targetClientId
+    ) {
+      return false;
+    }
+    if (
+      t.targetCapability != null &&
+      !subscriber.capabilities?.includes(t.targetCapability)
+    ) {
+      return false;
+    }
+    return true;
+  }
+
+  // Capability targeting (without client targeting): only subscribers
+  // that declare the required capability.
+  if (t.targetCapability != null) {
+    if (
+      subscriber.type !== "client" ||
+      !subscriber.capabilities?.includes(t.targetCapability)
+    ) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function evict(state: ConversationStreamState): void {
+  const now = Date.now();
+  while (state.ring.length > 0) {
+    const head = state.ring[0];
+    if (head == null) break;
+
+    const overCount = state.ring.length > RING_COUNT_LIMIT;
+    const overSize = state.totalSizeBytes > RING_SIZE_LIMIT_BYTES;
+    const overAge = now - head.emittedAt > RING_AGE_LIMIT_MS;
+
+    if (!overCount && !overSize && !overAge) break;
+
+    state.ring.shift();
+    state.totalSizeBytes -= head.sizeBytes;
+  }
+}

package/src/runtime/http-router.ts

@@ -12,7 +12,8 @@
 
 import type { z } from "zod";
 
-import { enforcePolicy, getPolicy } from "./auth/route-policy.js";
+import type { RoutePolicy } from "./auth/route-policy.js";
+import { enforcePolicy } from "./auth/route-policy.js";
 import type { AuthContext } from "./auth/types.js";
 import { httpError } from "./http-errors.js";
 import { withErrorHandling } from "./middleware/error-handler.js";
@@ -82,14 +83,15 @@ export interface RouteRequestBodyVariant {
  *   catch-all params that match across slashes (e.g. `interfaces/:path*`).
  * - `method`: HTTP method (GET, POST, DELETE, PATCH, PUT).
  * - `handler`: Async function that produces the Response.
- * - `policyKey`: Override the policy lookup key. When omitted the router
- *   derives it from the endpoint pattern (stripping param segments).
+ * - `policy`: Scope + principal-type policy for this route, or `null`
+ *   when the route is intentionally unprotected. See
+ *   `runtime/auth/route-policy.ts` for the type.
  */
 export interface HTTPRouteDefinition {
   endpoint: string;
   method: string;
   handler: (ctx: RouteContext) => Promise<Response> | Response;
-  policyKey?: string;
+  policy: RoutePolicy | null;
 
   /** Stable identifier used as the IPC method name when served over both transports. */
   operationId?: string;
@@ -143,8 +145,6 @@ interface CompiledRoute {
   def: HTTPRouteDefinition;
   regex: RegExp;
   paramNames: string[];
-  /** Policy key used for enforcePolicy() lookups. */
-  resolvedPolicyKey: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -228,13 +228,14 @@ export class HttpRouter {
         }
       }
 
-      // Enforce route-level scope/principal policy.
-      // Try method-specific key first (e.g. "messages:POST"), then plain key.
-      const methodKey = `${compiled.resolvedPolicyKey}:${req.method}`;
-      const policyKey = getPolicy(methodKey)
-        ? methodKey
-        : compiled.resolvedPolicyKey;
-      const policyDenied = enforcePolicy(policyKey, authContext);
+      // Enforce route-level scope/principal policy. The policy
+      // travels with the RouteDefinition itself — no side-registry
+      // lookup, no derivation, no key mismatch.
+      const policyDenied = enforcePolicy(
+        compiled.def.endpoint,
+        compiled.def.policy,
+        authContext,
+      );
       if (policyDenied) return policyDenied;
 
       return withErrorHandling(endpoint, () =>
@@ -265,21 +266,22 @@ const PARAM_TYPE_PATTERNS: Record<string, string> = {
 };
 
 /**
- * Compile a route definition into a regex + param list + policy key.
+ * Compile a route definition into a regex + param list.
  *
  * Endpoint patterns like `calls/:id/cancel` become:
  *   regex: /^calls\/([^/]+)\/cancel$/
  *   paramNames: ["id"]
- *   resolvedPolicyKey: "calls/cancel" (params stripped)
  *
  * When the route declares `pathParams` with a `type` constraint (e.g.
  * `{ name: "id", type: "uuid" }`), the capture group is narrowed to
  * only match values of that type. This prevents parameterized routes
  * from shadowing literal sibling routes regardless of declaration order.
+ *
+ * Policies are declared inline on the RouteDefinition itself —
+ * no derivation, no lookup key.
  */
 function compileRoute(def: HTTPRouteDefinition): CompiledRoute {
   const paramNames: string[] = [];
-  const policySegments: string[] = [];
 
   // Build a lookup for typed path params.
   const paramTypeMap = new Map<string, string>();
@@ -306,18 +308,13 @@ function compileRoute(def: HTTPRouteDefinition): CompiledRoute {
         const typePattern = PARAM_TYPE_PATTERNS[paramTypeMap.get(name) ?? ""];
         return typePattern ? `(${typePattern})` : "([^/]+)";
       }
-      policySegments.push(segment);
       return escapeRegex(segment);
     })
     .join("\\/");
 
   const regex = new RegExp(`^${regexSource}$`);
 
-  // If the definition specifies a policyKey, use it. Otherwise derive from
-  // the non-param segments (e.g. `calls/:id/cancel` -> `calls/cancel`).
-  const resolvedPolicyKey = def.policyKey ?? policySegments.join("/");
-
-  return { def, regex, paramNames, resolvedPolicyKey };
+  return { def, regex, paramNames };
 }
 
 function escapeRegex(str: string): string {

package/src/runtime/http-types.ts

@@ -85,8 +85,7 @@ export interface RuntimeMessageConversationOptions {
   /**
    * Optional LLM call-site identifier. Channel ingress and other inbound paths
    * may pass this so the daemon's per-call provider config picks up the right
-   * profile via `resolveCallSiteConfig`. PRs 7-11 wire individual call-site
-   * literals into specific call paths.
+   * profile via `resolveCallSiteConfig`.
    */
   callSite?: LLMCallSite;
   /**
@@ -96,15 +95,18 @@ export interface RuntimeMessageConversationOptions {
    * chronological renderer to consume.
    */
   slackInbound?: SlackInboundMessageMetadata;
+  /** IDs of user-uploaded attachments to resolve and include in the turn. */
+  attachmentIds?: string[];
+  /** Originating channel (e.g. "slack", "telegram"). Defaults to "vellum". */
+  sourceChannel?: ChannelId;
+  /** Originating interface (e.g. "cli", "web"). Defaults to "web". */
+  sourceInterface?: InterfaceId;
 }
 
 export type MessageProcessor = (
   conversationId: string,
   content: string,
-  attachmentIds?: string[],
   options?: RuntimeMessageConversationOptions,
-  sourceChannel?: ChannelId,
-  sourceInterface?: InterfaceId,
 ) => Promise<{ messageId: string; assistantMessageId?: string }>;
 
 /**
@@ -148,8 +150,12 @@ export interface RuntimeAttachmentMetadata {
 
 export interface RuntimeMessagePayload {
   id: string;
+  /**
+   * Server message ids that were folded into this display row when consecutive
+   * assistant messages were consolidated for history rendering.
+   */
+  mergedMessageIds?: string[];
   role: string;
-  content: string;
   timestamp: string;
   attachments: RuntimeAttachmentMetadata[];
   toolCalls?: Array<{

package/src/runtime/invite-instruction-generator.ts

@@ -70,7 +70,9 @@ export async function generateInviteInstruction(params: {
     ? `Send ${contact} this link: ${params.shareUrl} — or tell them to message me${handle} with the code below.`
     : `Tell ${contact} to message me${handle} with the code below.`;
 
-  const resolved = await resolveConfiguredProvider("inviteInstructionGenerator");
+  const resolved = await resolveConfiguredProvider(
+    "inviteInstructionGenerator",
+  );
   if (!resolved) {
     log.debug(
       "No provider available for invite instruction generation, using fallback",
@@ -121,8 +123,6 @@ export async function generateInviteInstruction(params: {
 
     const response = await resolved.provider.sendMessage(
       [userMessage(prompt)],
-      undefined,
-      undefined,
       { signal, config: { callSite: "inviteInstructionGenerator" } },
     );
 

package/src/runtime/pending-interactions.ts

@@ -18,14 +18,14 @@
  * resolve the interaction.
  */
 
-import type { InteractionResolutionState } from "../daemon/message-types/messages.js";
+import type { InteractionResolutionState } from "../api/events/interaction-resolved.js";
 import type { UserDecision } from "../permissions/types.js";
 import { getLogger } from "../util/logger.js";
 import { broadcastMessage } from "./assistant-event-hub.js";
 
 const log = getLogger("pending-interactions");
 
-export type { InteractionResolutionState } from "../daemon/message-types/messages.js";
+export type { InteractionResolutionState } from "../api/events/interaction-resolved.js";
 
 export interface ConfirmationDetails {
   toolName: string;