@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/plugin-types.test.ts

@@ -12,40 +12,19 @@ import { describe, expect, test } from "bun:test";
 
 import type { TrustContext } from "../daemon/trust-context.js";
 import { RiskLevel } from "../permissions/types.js";
-import type {
-  ToolResultTruncateArgs,
-  ToolResultTruncateResult,
-} from "../plugins/defaults/tool-result-truncate/types.js";
 import {
   type CircuitBreakerArgs,
   type CircuitBreakerResult,
   type CompactionArgs,
   type CompactionResult,
-  type EmptyResponseArgs,
-  type EmptyResponseResult,
-  type EstimateArgs,
-  type EstimateResult,
-  type Injector,
-  type LLMCallArgs,
-  type LLMCallResult,
-  type MemoryArgs,
-  type MemoryResult,
   type Middleware,
   type OverflowReduceArgs,
   type OverflowReduceResult,
-  type PersistArgs,
-  type PersistResult,
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
   type PluginManifest,
   PluginTimeoutError,
-  type TitleArgs,
-  type TitleResult,
-  type ToolErrorArgs,
-  type ToolErrorDecision,
-  type ToolExecuteArgs,
-  type ToolExecuteResult,
   type TurnContext,
 } from "../plugins/types.js";
 import type { Tool } from "../tools/types.js";
@@ -73,70 +52,6 @@ describe("plugin core types", () => {
       config: { parse: (input: unknown) => input },
     };
 
-    // Generic passthrough — typed per slot below because per-pipeline
-    // arg/result types have diverged from the early `{input: unknown}` /
-    // `{output: unknown}` placeholders as individual pipeline wrap-up PRs
-    // land.
-    const passthrough: Middleware<
-      { input: unknown },
-      { output: unknown }
-    > = async (args, next, _ctx) => next(args);
-    // `llmCall` has concrete arg/result types (upgraded in PR 15).
-    const llmCallPassthrough: Middleware<LLMCallArgs, LLMCallResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    // `toolExecute` has concrete arg/result types (refined in PR 16).
-    const toolExecutePassthrough: Middleware<
-      ToolExecuteArgs,
-      ToolExecuteResult
-    > = async (args, next, _ctx) => next(args);
-
-    // `toolResultTruncate` has a concrete args/result shape (PR 17) so we
-    // need a dedicated passthrough for that slot.
-    const truncatePassthrough: Middleware<
-      ToolResultTruncateArgs,
-      ToolResultTruncateResult
-    > = async (args, _next, _ctx) => ({
-      content: args.content,
-      truncated: false,
-    });
-
-    // The `emptyResponse` slot has concrete args/result types; use a
-    // dedicated passthrough so the `satisfies Plugin` check stays honest.
-    const emptyResponsePassthrough: Middleware<
-      EmptyResponseArgs,
-      EmptyResponseResult
-    > = async (args, next, _ctx) => next(args);
-
-    // The `toolError` slot has concrete args/result types (PR 19); use a
-    // dedicated passthrough so the shape-only test keeps compiling as types
-    // get tightened.
-    const toolErrorPassthrough: Middleware<
-      ToolErrorArgs,
-      ToolErrorDecision
-    > = async (args, next, _ctx) => next(args);
-
-    // `memoryRetrieval` has a concrete typed signature (MemoryArgs →
-    // MemoryResult) introduced in PR 20, so it can't use the generic
-    // `{ input }` passthrough above.
-    const memoryPassthrough: Middleware<MemoryArgs, MemoryResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    // `tokenEstimate` has a concrete arg/result shape (refined in the
-    // tokenEstimate-pipeline PR), so its middleware can't share the generic
-    // `{ input, output }` passthrough. A slot-specific passthrough keeps the
-    // shape-only assertion honest across type-refinement PRs.
-    const tokenEstimatePassthrough: Middleware<
-      EstimateArgs,
-      EstimateResult
-    > = async (args, next, _ctx) => next(args);
-
     // `overflowReduce` has a concrete arg/result shape (PR 23). Uses a
     // dedicated passthrough that returns a structurally-correct result so
     // `satisfies Plugin` keeps verifying the signature.
@@ -174,33 +89,6 @@ describe("plugin core types", () => {
       CircuitBreakerResult
     > = async (args, next, _ctx) => next(args);
 
-    // `persistence` has concrete discriminated-union arg/result types
-    // (upgraded from the initial `{ input }/{ output }` placeholder in PR 27)
-    // so it gets its own passthrough rather than sharing the generic one
-    // above.
-    const persistPassthrough: Middleware<PersistArgs, PersistResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    // The `titleGenerate` slot now has concrete arg/result types (PR 28)
-    // rather than the placeholder `{ input/output: unknown }` shape, so it
-    // needs its own passthrough implementation.
-    const titlePassthrough: Middleware<TitleArgs, TitleResult> = async (
-      args,
-      next,
-      _ctx,
-    ) => next(args);
-
-    const injector: Injector = {
-      name: "sample-injector",
-      order: 10,
-      async produce(_ctx) {
-        return { id: "sample-block", text: "hello", meta: { kind: "demo" } };
-      },
-    };
-
     const sampleTool: Tool = {
       name: "sample-tool",
       description: "Sample plugin tool",
@@ -244,27 +132,16 @@ describe("plugin core types", () => {
           body: "## Sample\n\nPlugin-provided skill body.",
         },
       ],
-      injectors: [injector],
       middleware: {
-        turn: passthrough,
-        llmCall: llmCallPassthrough,
-        toolExecute: toolExecutePassthrough,
-        memoryRetrieval: memoryPassthrough,
-        tokenEstimate: tokenEstimatePassthrough,
         compaction: compactionPassthrough,
         overflowReduce: overflowReducePassthrough,
-        persistence: persistPassthrough,
-        titleGenerate: titlePassthrough,
-        toolResultTruncate: truncatePassthrough,
-        emptyResponse: emptyResponsePassthrough,
-        toolError: toolErrorPassthrough,
         circuitBreaker: circuitPassthrough,
       },
     } satisfies Plugin;
 
     // Minimal runtime check so the test body is non-empty.
     expect(plugin.manifest.name).toBe("sample-plugin");
-    expect(plugin.middleware.turn).toBe(passthrough);
+    expect(plugin.middleware.compaction).toBe(compactionPassthrough);
   });
 
   test("PluginTimeoutError carries pipeline, plugin, and elapsed fields", () => {
@@ -280,7 +157,7 @@ describe("plugin core types", () => {
   });
 
   test("PluginTimeoutError omits plugin suffix when unknown", () => {
-    const err = new PluginTimeoutError("llmCall", undefined, 1234);
+    const err = new PluginTimeoutError("circuitBreaker", undefined, 1234);
     expect(err.pluginName).toBeUndefined();
     expect(err.message).not.toContain("offending plugin");
   });

package/src/__tests__/process-message-display-content.test.ts

@@ -12,7 +12,7 @@ let activeConversation: unknown;
 type TestSlashResolution =
   | { kind: "passthrough"; content: string }
   | { kind: "unknown"; message: string }
-  | { kind: "compact"; targetInputTokensOverride?: number };
+  | { kind: "compact" };
 
 let resolveSlashForTest: (
   content: string,
@@ -129,10 +129,14 @@ function makeTestConversation() {
     drain: () => [],
     size: () => 0,
   } as unknown as MessageQueue;
+  let processing = false;
   const messagingCtx: MessagingConversationContext = {
     conversationId: "conv-display-content",
     messages,
-    processing: false,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
     abortController: null,
     queue: queueStub,
     getTurnChannelContext: () => turnChannelContext,

package/src/__tests__/regenerate-fire-and-forget-trace.test.ts

@@ -104,6 +104,7 @@ function buildContext(
   ];
 
   const traceEvents = overrides.traceEvents ?? [];
+  let processing = false;
 
   const runAgentLoop: HistoryConversationContext["runAgentLoop"] =
     overrides.runAgentLoop ??
@@ -120,7 +121,10 @@ function buildContext(
     } as unknown as HistoryConversationContext["traceEmitter"],
     sendToClient: () => {},
     messages,
-    processing: false,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
     abortController: null,
     runAgentLoop,
   };

package/src/__tests__/resolve-trust-class.test.ts

@@ -1,7 +1,5 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-
-
 // ── Module mocks ─────────────────────────────────────────────────────
 
 let fakeHttpAuthDisabled = false;
@@ -13,8 +11,10 @@ mock.module("../config/env.js", () => ({
 
 // ── Real imports (after mocks) ───────────────────────────────────────
 
-import { resolveTrustClass } from "../daemon/conversation-tool-setup.js";
-import type { TrustContext } from "../daemon/trust-context.js";
+import {
+  resolveTrustClass,
+  type TrustContext,
+} from "../daemon/trust-context.js";
 
 afterAll(() => {
   mock.restore();

package/src/__tests__/runtime-events-sse-reconnect.test.ts

@@ -35,9 +35,9 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import {
-  _resetConversationStreamsForTesting,
+  _resetStreamStateForTesting,
   stampAndBuffer,
-} from "../runtime/conversation-stream-state.js";
+} from "../runtime/assistant-stream-state.js";
 
 initializeDb();
 
@@ -56,11 +56,11 @@ describe("SSE reconnect replay (B7.2)", () => {
     const db = getDb();
     db.run("DELETE FROM conversation_keys");
     db.run("DELETE FROM conversations");
-    _resetConversationStreamsForTesting();
+    _resetStreamStateForTesting();
   });
 
   afterEach(() => {
-    _resetConversationStreamsForTesting();
+    _resetStreamStateForTesting();
   });
 
   test("replays buffered events with seq > lastSeenSeq before the first heartbeat", async () => {
@@ -94,11 +94,9 @@ describe("SSE reconnect replay (B7.2)", () => {
     const frame1 = await readFrame(reader);
     expect(frame1).toContain("event: assistant_event");
     expect(frame1).toContain('"seq":2');
-    expect(frame1).toContain('"clientSeq":1');
 
     const frame2 = await readFrame(reader);
     expect(frame2).toContain('"seq":3');
-    expect(frame2).toContain('"clientSeq":2');
 
     // Then the heartbeat.
     const heartbeat = await readFrame(reader);
@@ -107,6 +105,50 @@ describe("SSE reconnect replay (B7.2)", () => {
     ac.abort();
   });
 
+  test("unfiltered connection replays events across conversations from one global cursor", async () => {
+    // The web app rides a single unfiltered (assistant-wide) SSE
+    // connection that multiplexes every conversation. Because `seq` is
+    // one global counter, a single `lastSeenSeq` resumes the whole
+    // stream -- replay must return the missed events from BOTH
+    // conversations, interleaved in global seq order.
+    const { conversationId: convA } = getOrCreateConversation("multi-conv-a");
+    const { conversationId: convB } = getOrCreateConversation("multi-conv-b");
+
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, convA)); // seq 1
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, convB)); // seq 2
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, convA)); // seq 3
+    stampAndBuffer(buildAssistantEvent({ type: "pong" }, convB)); // seq 4
+
+    const ac = new AbortController();
+    const { handleSubscribeAssistantEvents } =
+      await import("../runtime/routes/events-routes.js");
+    // No conversation scope -> unfiltered connection.
+    const stream = handleSubscribeAssistantEvents({
+      queryParams: { lastSeenSeq: "1" },
+      abortSignal: ac.signal,
+    });
+
+    const reader = stream.getReader();
+
+    // seqs 2, 3, 4 replay in global order regardless of conversation.
+    const f2 = await readFrame(reader);
+    expect(f2).toContain('"seq":2');
+    expect(f2).toContain(convB);
+
+    const f3 = await readFrame(reader);
+    expect(f3).toContain('"seq":3');
+    expect(f3).toContain(convA);
+
+    const f4 = await readFrame(reader);
+    expect(f4).toContain('"seq":4');
+    expect(f4).toContain(convB);
+
+    const heartbeat = await readFrame(reader);
+    expect(heartbeat).toBe(": heartbeat\n\n");
+
+    ac.abort();
+  });
+
   test("connects live without replay when lastSeenSeq is older than the ring's oldest entry", async () => {
     // When the client's cursor is older than the ring can serve, the
     // route deliberately does NOT signal anything special over the
@@ -124,10 +166,10 @@ describe("SSE reconnect replay (B7.2)", () => {
       stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
     }
     const { _peekStreamForTesting } =
-      await import("../runtime/conversation-stream-state.js");
-    const peek = _peekStreamForTesting(conversationId);
-    expect(peek?.oldestSeq).toBe(3);
-    expect(peek?.newestSeq).toBe(202);
+      await import("../runtime/assistant-stream-state.js");
+    const peek = _peekStreamForTesting();
+    expect(peek.oldestSeq).toBe(3);
+    expect(peek.newestSeq).toBe(202);
 
     const ac = new AbortController();
     const { handleSubscribeAssistantEvents } =
@@ -226,14 +268,13 @@ describe("SSE reconnect replay (B7.2)", () => {
     ac.abort();
   });
 
-  test("clientSeq is gap-free when targeted events create seq gaps", async () => {
+  test("replay excludes events the subscriber is not targeted to receive", async () => {
     // Stamp three events: two untargeted (seq 1, 3) + one with a
     // capability target (seq 2, host_bash). A process subscriber
     // does NOT match capability targeting (matchesSubscriber requires
     // type=client + matching capability), so the replay filters out
-    // seq 2. The subscriber receives seq 1 and 3 — a gap in raw seq
-    // — but clientSeq is 1, 2 — gap-free.
-    const { conversationId } = getOrCreateConversation("clientseq-gap");
+    // seq 2. The subscriber receives seq 1 and 3.
+    const { conversationId } = getOrCreateConversation("replay-targeting");
 
     stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId));
     stampAndBuffer(buildAssistantEvent({ type: "pong" }, conversationId), {
@@ -246,7 +287,7 @@ describe("SSE reconnect replay (B7.2)", () => {
       await import("../runtime/routes/events-routes.js");
     const stream = handleSubscribeAssistantEvents({
       queryParams: {
-        conversationKey: "clientseq-gap",
+        conversationKey: "replay-targeting",
         lastSeenSeq: "0",
       },
       abortSignal: ac.signal,
@@ -255,14 +296,12 @@ describe("SSE reconnect replay (B7.2)", () => {
     const reader = stream.getReader();
 
     // seq 2 (host_bash-targeted) is filtered out by replay.
-    // Only seq 1 and 3 are delivered, with gap-free clientSeq.
+    // Only seq 1 and 3 are delivered.
     const f1 = await readFrame(reader);
     expect(f1).toContain('"seq":1');
-    expect(f1).toContain('"clientSeq":1');
 
     const f2 = await readFrame(reader);
     expect(f2).toContain('"seq":3');
-    expect(f2).toContain('"clientSeq":2');
 
     const heartbeat = await readFrame(reader);
     expect(heartbeat).toBe(": heartbeat\n\n");
@@ -270,8 +309,8 @@ describe("SSE reconnect replay (B7.2)", () => {
     ac.abort();
   });
 
-  test("live callback includes clientSeq on conversation-scoped events", async () => {
-    const { conversationId } = getOrCreateConversation("clientseq-live");
+  test("live callback stamps seq on conversation-scoped events", async () => {
+    const { conversationId } = getOrCreateConversation("live-seq");
 
     const ac = new AbortController();
     const { AssistantEventHub } =
@@ -281,7 +320,7 @@ describe("SSE reconnect replay (B7.2)", () => {
       await import("../runtime/routes/events-routes.js");
     const stream = handleSubscribeAssistantEvents(
       {
-        queryParams: { conversationKey: "clientseq-live" },
+        queryParams: { conversationKey: "live-seq" },
         abortSignal: ac.signal,
       },
       { hub: testHub },
@@ -303,11 +342,9 @@ describe("SSE reconnect replay (B7.2)", () => {
 
     const f1 = await readFrame(reader);
     expect(f1).toContain('"seq":1');
-    expect(f1).toContain('"clientSeq":1');
 
     const f2 = await readFrame(reader);
     expect(f2).toContain('"seq":2');
-    expect(f2).toContain('"clientSeq":2');
 
     ac.abort();
   });