@vellumai/assistant 0.8.3 → 0.8.4

package/src/__tests__/log-export-routes.test.ts

@@ -1,8 +1,14 @@
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -18,12 +24,23 @@ mock.module("../util/secure-keys.js", () => ({
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { llmUsageEvents } from "../memory/schema.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/log-export-routes.js";
 
 initializeDb();
 
 const exportRoute = ROUTES.find((r) => r.endpoint === "export")!;
 
+function clearConnectedClients(): void {
+  for (const client of assistantEventHub.listClients()) {
+    assistantEventHub.disposeClient(client.clientId);
+  }
+}
+
+beforeEach(() => {
+  clearConnectedClients();
+});
+
 async function extractArchive(bytes: Uint8Array): Promise<string> {
   const extractDir = mkdtempSync(join(tmpdir(), "log-export-routes-"));
   const archivePath = join(extractDir, "archive.tar.gz");
@@ -39,6 +56,86 @@ async function extractArchive(bytes: Uint8Array): Promise<string> {
   return extractDir;
 }
 
+describe("POST /v1/export - connected clients", () => {
+  test("includes current `assistant clients list --json` output", async () => {
+    const subscription = assistantEventHub.subscribe({
+      type: "client",
+      clientId: "client-list-export-test",
+      interfaceId: "macos",
+      capabilities: ["host_bash", "host_file"],
+      machineName: "test-macbook",
+      callback: () => {},
+    });
+
+    try {
+      const result = await exportRoute.handler({ body: {} });
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        const clientsList = JSON.parse(
+          readFileSync(join(dir, "clients-list.json"), "utf-8"),
+        ) as {
+          clients: Array<{
+            clientId: string;
+            interfaceId: string;
+            capabilities: string[];
+            machineName?: string;
+            connectedAt: string;
+            lastActiveAt: string;
+          }>;
+        };
+
+        expect(clientsList.clients).toHaveLength(1);
+        expect(clientsList.clients[0]).toMatchObject({
+          clientId: "client-list-export-test",
+          interfaceId: "macos",
+          capabilities: ["host_bash", "host_file"],
+          machineName: "test-macbook",
+        });
+        expect(new Date(clientsList.clients[0].connectedAt).toISOString()).toBe(
+          clientsList.clients[0].connectedAt,
+        );
+        expect(
+          new Date(clientsList.clients[0].lastActiveAt).toISOString(),
+        ).toBe(clientsList.clients[0].lastActiveAt);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("writes a non-blocking error artifact when client listing fails", async () => {
+    const originalListClients = assistantEventHub.listClients;
+    assistantEventHub.listClients = () => {
+      throw new Error("client list unavailable");
+    };
+
+    try {
+      const result = await exportRoute.handler({ body: {} });
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        expect(existsSync(join(dir, "clients-list.json"))).toBe(false);
+        const errorArtifact = JSON.parse(
+          readFileSync(join(dir, "clients-list-error.json"), "utf-8"),
+        ) as { error: string; collectedAt: string };
+        expect(errorArtifact.error).toBe("client list unavailable");
+        expect(new Date(errorArtifact.collectedAt).toISOString()).toBe(
+          errorArtifact.collectedAt,
+        );
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      assistantEventHub.listClients = originalListClients;
+    }
+  });
+});
+
 describe("POST /v1/export - LLM usage events", () => {
   test("full export includes usage attribution columns", async () => {
     const db = getDb();

package/src/__tests__/message-queue-steer.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  MessageQueue,
+  type QueuedMessage,
+} from "../daemon/conversation-queue-manager.js";
+
+function makeItem(content: string, requestId: string): QueuedMessage {
+  return {
+    content,
+    attachments: [],
+    requestId,
+    onEvent: () => {},
+    sentAt: Date.now(),
+  };
+}
+
+describe("MessageQueue.promoteToHead", () => {
+  test("returns undefined when queue is empty", () => {
+    const q = new MessageQueue();
+    expect(q.promoteToHead("nonexistent")).toBeUndefined();
+  });
+
+  test("returns undefined when requestId is not found", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    expect(q.promoteToHead("r99")).toBeUndefined();
+    // Queue unchanged
+    expect(q.peek(0)?.requestId).toBe("r1");
+    expect(q.peek(1)?.requestId).toBe("r2");
+  });
+
+  test("no-op when the message is already at head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r1");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r1");
+    expect(q.peek(0)?.requestId).toBe("r1");
+    expect(q.peek(1)?.requestId).toBe("r2");
+    expect(q.length).toBe(2);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("moves a middle item to head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r2");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r2");
+    expect(q.peek(0)?.requestId).toBe("r2");
+    expect(q.peek(1)?.requestId).toBe("r1");
+    expect(q.peek(2)?.requestId).toBe("r3");
+    expect(q.length).toBe(3);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("moves the last item to head", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    const result = q.promoteToHead("r3");
+
+    expect(result).toBeDefined();
+    expect(result?.requestId).toBe("r3");
+    expect(q.peek(0)?.requestId).toBe("r3");
+    expect(q.peek(1)?.requestId).toBe("r1");
+    expect(q.peek(2)?.requestId).toBe("r2");
+    expect(q.length).toBe(3);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("byte accounting unchanged after promote (item is reordered, not added/removed)", () => {
+    const q = new MessageQueue(10_000);
+    q.push(makeItem("short", "r1"));
+    q.push(makeItem("a".repeat(200), "r2"));
+    q.push(makeItem("medium text", "r3"));
+
+    const bytesBefore = q.totalBytes;
+    q.promoteToHead("r2");
+    expect(q.totalBytes).toBe(bytesBefore);
+
+    // shift all and verify bytes go to 0
+    q.shift();
+    q.shift();
+    q.shift();
+    expect(q.totalBytes).toBe(0);
+  });
+
+  test("promoted item is returned by shift()", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    q.promoteToHead("r3");
+    const head = q.shift();
+    expect(head?.requestId).toBe("r3");
+    expect(head?.content).toBe("c");
+  });
+});

package/src/__tests__/openai-provider.test.ts

@@ -1744,4 +1744,109 @@ describe("OpenAIProvider reasoning_effort", () => {
     });
     expect(lastCreateParams!.reasoning_effort).toBe("medium");
   });
+
+  test('maxReasoningEffort: "max" passes "max" through unclamped', async () => {
+    const uncapped = new OpenAIProvider("test-key", "gpt-5", {
+      maxReasoningEffort: "max",
+    });
+    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
+  });
+});
+
+describe("FireworksProvider reasoning_effort ceiling", () => {
+  beforeEach(() => {
+    fakeChunks = [];
+    lastCreateParams = null;
+  });
+
+  test('DeepSeek V4 Pro accepts "max" unclamped', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+  });
+
+  test('DeepSeek V4 Pro accepts "xhigh" unclamped', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
+  });
+
+  test('Kimi K2.6 clamps "xhigh"/"max" down to "high"', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test('unknown Fireworks model falls back to "high" ceiling', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/some-future-model",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test("effort below ceiling is forwarded verbatim", async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "medium" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("medium");
+  });
+
+  test('effort: "none" passes through regardless of ceiling', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "none" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("none");
+  });
+
+  test("model override picks ceiling from runtime model, not constructor model", async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: {
+        effort: "max",
+        model: "accounts/fireworks/models/deepseek-v4-pro",
+      },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+  });
 });

package/src/__tests__/openai-responses-provider.test.ts

@@ -714,16 +714,16 @@ describe("OpenAIResponsesProvider", () => {
   });
 
   // -----------------------------------------------------------------------
-  // store: false
+  // store — omitted so prompt caching can persist across turns
   // -----------------------------------------------------------------------
-  test("sends store: false in params", async () => {
+  test("does not set store in params (defaults to true server-side)", async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage([
       { role: "user", content: [{ type: "text", text: "Hi" }] },
     ]);
 
-    expect(lastStreamParams!.store).toBe(false);
+    expect(lastStreamParams!.store).toBeUndefined();
   });
 
   // -----------------------------------------------------------------------
@@ -1122,7 +1122,7 @@ describe("OpenAIResponsesProvider", () => {
     const rawReq = result.rawRequest as Record<string, unknown>;
     expect(rawReq.model).toBe("gpt-5.2");
     expect(rawReq.instructions).toBe("System prompt");
-    expect(rawReq.store).toBe(false);
+    expect(rawReq.store).toBeUndefined();
 
     // rawResponse should contain the final response object, including `output`
     // which downstream normalization relies on for Responses API detection.

package/src/__tests__/outbound-slack-persistence.test.ts

@@ -22,24 +22,33 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    skills: {
-      entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
-      install: { nodeManager: "npm" },
-      allowBundled: null,
-      remoteProviders: {
-        skillssh: { enabled: true },
-        clawhub: { enabled: true },
-      },
-      remotePolicy: {
-        blockSuspicious: true,
-        blockMalware: true,
-        maxSkillsShRisk: "medium",
-      },
+type TestConfig = {
+  ui: { userTimezone?: string; detectedTimezone?: string };
+  skills: Record<string, unknown>;
+};
+
+const baseConfig: TestConfig = {
+  ui: {},
+  skills: {
+    entries: {},
+    load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+    install: { nodeManager: "npm" },
+    allowBundled: null,
+    remoteProviders: {
+      skillssh: { enabled: true },
+      clawhub: { enabled: true },
     },
-  }),
+    remotePolicy: {
+      blockSuspicious: true,
+      blockMalware: true,
+      maxSkillsShRisk: "medium",
+    },
+  },
+};
+let currentConfig: TestConfig = structuredClone(baseConfig);
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => currentConfig,
   loadConfig: () => ({}),
 }));
 
@@ -47,12 +56,21 @@ mock.module("../config/loader.js", () => ({
 // its arguments per test invocation so each case can assert on the metadata
 // that was actually persisted.
 interface AddMessageCall {
+  id: string;
   conversationId: string;
   role: string;
   content: string;
   metadata?: Record<string, unknown>;
 }
 const addMessageCalls: AddMessageCall[] = [];
+const persistedRows: Array<{
+  id: string;
+  conversationId: string;
+  role: string;
+  content: string;
+  createdAt: number;
+  metadata: string | null;
+}> = [];
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: (
     conversationId: string,
@@ -60,11 +78,35 @@ mock.module("../memory/conversation-crud.js", () => ({
     content: string,
     metadata?: Record<string, unknown>,
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
-    return { id: `mock-msg-${addMessageCalls.length}` };
+    const id = `mock-msg-${addMessageCalls.length + 1}`;
+    addMessageCalls.push({ id, conversationId, role, content, metadata });
+    persistedRows.push({
+      id,
+      conversationId,
+      role,
+      content,
+      createdAt: Date.now(),
+      metadata: metadata ? JSON.stringify(metadata) : null,
+    });
+    return { id };
   },
   getConversation: () => null,
-  getMessageById: () => null,
+  getMessageById: (messageId: string) =>
+    persistedRows.find((row) => row.id === messageId) ?? null,
+  getMessages: (conversationId: string) =>
+    persistedRows.filter((row) => row.conversationId === conversationId),
+  updateMessageMetadata: (
+    messageId: string,
+    updates: Record<string, unknown>,
+  ) => {
+    const row = persistedRows.find((candidate) => candidate.id === messageId);
+    if (!row) return;
+    const existing =
+      row.metadata && typeof row.metadata === "string"
+        ? (JSON.parse(row.metadata) as Record<string, unknown>)
+        : {};
+    row.metadata = JSON.stringify({ ...existing, ...updates });
+  },
   updateMessageContent: () => {},
   // The handler treats provenance as a flat spread; returning {} keeps the
   // metadata snapshot focused on the fields under test.
@@ -84,6 +126,18 @@ mock.module("../memory/conversation-disk-view.js", () => ({
   syncMessageToDisk: () => {},
 }));
 
+let nextDeliveryTs: string | null = null;
+mock.module("../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async () => ({
+    ok: true,
+    ...(nextDeliveryTs ? { ts: nextDeliveryTs } : {}),
+  }),
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+}));
+
 // ── Imports (after mocks) ──────────────────────────────────────────────────
 
 import type { AgentEvent } from "../agent/loop.js";
@@ -98,6 +152,7 @@ import {
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { clearThreadTs, setThreadTs } from "../memory/slack-thread-store.js";
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import { deliverReplyViaCallback } from "../runtime/channel-reply-delivery.js";
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
@@ -106,6 +161,8 @@ function makeDeps(
   overrides: {
     assistantMessageChannel?: "slack" | "vellum" | "telegram";
     requesterChatId?: string;
+    requesterTimezoneLabel?: string;
+    clientTimezone?: string;
   } = {},
 ): EventHandlerDeps {
   const assistantMessageChannel = overrides.assistantMessageChannel ?? "slack";
@@ -119,7 +176,9 @@ function makeDeps(
         sourceChannel: assistantMessageChannel,
         trustClass: "guardian",
         requesterChatId: overrides.requesterChatId,
+        requesterTimezoneLabel: overrides.requesterTimezoneLabel,
       },
+      clientTimezone: overrides.clientTimezone,
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (_msg: ServerMessage) => {},
     reqId: "test-req-id",
@@ -172,12 +231,17 @@ describe("outbound assistant Slack metadata persistence", () => {
 
   beforeEach(() => {
     addMessageCalls.length = 0;
+    persistedRows.length = 0;
+    currentConfig = structuredClone(baseConfig);
+    nextDeliveryTs = null;
     state = createEventHandlerState();
     state.turnStartedAt = 1_700_000_000_000;
   });
 
   afterEach(() => {
     addMessageCalls.length = 0;
+    persistedRows.length = 0;
+    nextDeliveryTs = null;
   });
 
   test("stamps slackMeta with threadTs when the conversation has a Slack thread mapping", async () => {
@@ -217,6 +281,109 @@ describe("outbound assistant Slack metadata persistence", () => {
     expect(readSlackMetadata(slackMetaRaw as string)).toBeNull();
   });
 
+  test("stamps assistant Slack rows with effective timestamp timezone and no speaker suffix", async () => {
+    currentConfig = {
+      ...structuredClone(baseConfig),
+      ui: { userTimezone: "America/Denver" },
+    };
+    state.turnStartedAt = Date.parse("2026-03-05T03:38:00Z");
+    const conversationId = "conv-slack-timezone";
+    const channelId = "C999TIMEZONE";
+
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "slack",
+      requesterChatId: channelId,
+      requesterTimezoneLabel: "ET",
+      clientTimezone: "America/Los_Angeles",
+    });
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("timezone-aware reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    const slackMetaRaw = persisted.metadata?.slackMeta;
+    expect(typeof slackMetaRaw).toBe("string");
+
+    const slackMeta = JSON.parse(slackMetaRaw as string) as Record<
+      string,
+      unknown
+    >;
+    expect(slackMeta.timestampTimezone).toBe("America/Denver");
+    expect(slackMeta.timestampTimezoneLabel).toBe("MT");
+    expect(slackMeta.speakerTimezoneLabel).toBeUndefined();
+  });
+
+  test("falls back to the turn client timezone when no configured user timezone is set", async () => {
+    const conversationId = "conv-slack-client-timezone";
+    const channelId = "C999CLIENTTZ";
+
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "slack",
+      requesterChatId: channelId,
+      clientTimezone: "America/Los_Angeles",
+    });
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("client timezone reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    const slackMeta = JSON.parse(
+      persisted.metadata?.slackMeta as string,
+    ) as Record<string, unknown>;
+    expect(slackMeta.timestampTimezone).toBe("America/Los_Angeles");
+    expect(slackMeta.timestampTimezoneLabel).toBe("PT");
+  });
+
+  test("post-send reconciliation preserves assistant Slack timezone metadata", async () => {
+    currentConfig = {
+      ...structuredClone(baseConfig),
+      ui: { userTimezone: "America/Denver" },
+    };
+    const conversationId = "conv-slack-reconcile-timezone";
+    const channelId = "C999RECONCILE";
+
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "slack",
+      requesterChatId: channelId,
+      requesterTimezoneLabel: "ET",
+    });
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("delivery reconciliation reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    const beforeRaw = persisted.metadata?.slackMeta;
+    expect(typeof beforeRaw).toBe("string");
+    expect(readSlackMetadata(beforeRaw as string)).toBeNull();
+
+    nextDeliveryTs = "1772678280.000200";
+    await deliverReplyViaCallback(
+      conversationId,
+      channelId,
+      "http://gateway/deliver/slack",
+      "assistant-1",
+      { messageId: persisted.id },
+    );
+
+    const row = persistedRows.find(
+      (candidate) => candidate.id === persisted.id,
+    );
+    expect(typeof row?.metadata).toBe("string");
+    const envelope = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const reconciled = readSlackMetadata(envelope.slackMeta as string);
+    expect(reconciled).not.toBeNull();
+    expect(reconciled!.channelTs).toBe("1772678280.000200");
+    expect(reconciled!.timestampTimezone).toBe("America/Denver");
+    expect(reconciled!.timestampTimezoneLabel).toBe("MT");
+    expect(reconciled!.speakerTimezoneLabel).toBeUndefined();
+  });
+
   test("stamps slackMeta WITHOUT threadTs for top-level Slack replies", async () => {
     const conversationId = "conv-slack-toplevel";
     const channelId = "C456NOTHREAD";