@vellumai/assistant 0.8.2 → 0.8.4

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";

package/src/__tests__/pending-interactions-resolved-event.test.ts

@@ -0,0 +1,190 @@
+/**
+ * Verifies that every resolution path through
+ * `runtime/pending-interactions.ts` publishes an `interaction_resolved`
+ * envelope on the event hub with the right state.
+ *
+ * Each test registers an interaction directly and calls `resolve()` or
+ * `removeByConversation()` so we exercise the tracker in isolation
+ * without spinning up a Conversation, prompter, or proxy.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+// Capture every broadcast emitted by the tracker. The real hub is replaced
+// with a thin recorder so we can assert payloads deterministically.
+const publishedMessages: ServerMessage[] = [];
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: ServerMessage) => {
+    publishedMessages.push(msg);
+  },
+  capabilityForMessageType: () => undefined,
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => ({ dispose: () => {}, active: true }),
+  },
+}));
+
+const pendingInteractions = await import("../runtime/pending-interactions.js");
+
+beforeEach(() => {
+  publishedMessages.length = 0;
+  pendingInteractions.clear();
+});
+
+afterEach(() => {
+  pendingInteractions.clear();
+});
+
+function lastResolvedEvent() {
+  const evt = publishedMessages.find((m) => m.type === "interaction_resolved");
+  expect(evt).toBeDefined();
+  return evt as Extract<ServerMessage, { type: "interaction_resolved" }>;
+}
+
+describe("pendingInteractions.resolve emits interaction_resolved", () => {
+  test("default state is 'cancelled'", () => {
+    pendingInteractions.register("req-1", {
+      conversationId: "conv-1",
+      kind: "confirmation",
+    });
+    const returned = pendingInteractions.resolve("req-1");
+    expect(returned).toBeDefined();
+    const evt = lastResolvedEvent();
+    expect(evt.requestId).toBe("req-1");
+    expect(evt.conversationKey).toBe("conv-1");
+    expect(evt.conversationId).toBe("conv-1");
+    expect(evt.state).toBe("cancelled");
+    expect(evt.kind).toBe("confirmation");
+  });
+
+  test("approved state propagates", () => {
+    pendingInteractions.register("req-approve", {
+      conversationId: "conv-a",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-approve", "approved");
+    expect(lastResolvedEvent().state).toBe("approved");
+  });
+
+  test("rejected state propagates", () => {
+    pendingInteractions.register("req-reject", {
+      conversationId: "conv-b",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-reject", "rejected");
+    expect(lastResolvedEvent().state).toBe("rejected");
+  });
+
+  test("answered state propagates (secret response)", () => {
+    pendingInteractions.register("req-secret", {
+      conversationId: "conv-c",
+      kind: "secret",
+    });
+    pendingInteractions.resolve("req-secret", "answered");
+    const evt = lastResolvedEvent();
+    expect(evt.state).toBe("answered");
+    expect(evt.kind).toBe("secret");
+  });
+
+  test("superseded state propagates", () => {
+    pendingInteractions.register("req-super", {
+      conversationId: "conv-d",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-super", "superseded");
+    expect(lastResolvedEvent().state).toBe("superseded");
+  });
+
+  test("no event is emitted when the requestId is unknown", () => {
+    pendingInteractions.resolve("never-registered", "approved");
+    expect(publishedMessages).toHaveLength(0);
+  });
+
+  test("a single resolve emits exactly one event", () => {
+    pendingInteractions.register("req-once", {
+      conversationId: "conv-e",
+      kind: "host_bash",
+    });
+    pendingInteractions.resolve("req-once", "answered");
+    // Second resolve is a no-op because the entry was already consumed.
+    pendingInteractions.resolve("req-once", "answered");
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    );
+    expect(events).toHaveLength(1);
+  });
+
+  test("clears the registered timer on resolve", () => {
+    let fired = false;
+    const timer = setTimeout(() => {
+      fired = true;
+    }, 10_000);
+    pendingInteractions.register("req-timer", {
+      conversationId: "conv-f",
+      kind: "confirmation",
+      timer,
+    });
+    pendingInteractions.resolve("req-timer", "approved");
+    clearTimeout(timer);
+    expect(fired).toBe(false);
+  });
+});
+
+describe("removeByConversation emits interaction_resolved per entry", () => {
+  test("emits superseded for every non-host interaction in the conversation", () => {
+    pendingInteractions.register("conf-1", {
+      conversationId: "conv-x",
+      kind: "confirmation",
+    });
+    pendingInteractions.register("secret-1", {
+      conversationId: "conv-x",
+      kind: "secret",
+    });
+    pendingInteractions.register("question-1", {
+      conversationId: "conv-x",
+      kind: "question",
+    });
+    pendingInteractions.register("host-bash-1", {
+      conversationId: "conv-x",
+      kind: "host_bash",
+    });
+    pendingInteractions.register("conf-other", {
+      conversationId: "conv-y",
+      kind: "confirmation",
+    });
+
+    pendingInteractions.removeByConversation("conv-x");
+
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    ) as Extract<ServerMessage, { type: "interaction_resolved" }>[];
+    expect(events).toHaveLength(3);
+    expect(events.every((e) => e.state === "superseded")).toBe(true);
+    const requestIds = new Set(events.map((e) => e.requestId));
+    expect(requestIds).toEqual(new Set(["conf-1", "secret-1", "question-1"]));
+
+    // host_bash entries survive auto-deny — no event for them.
+    expect(pendingInteractions.get("host-bash-1")).toBeDefined();
+    // Unrelated conversation is untouched.
+    expect(pendingInteractions.get("conf-other")).toBeDefined();
+  });
+
+  test("explicit state arg overrides the default 'superseded'", () => {
+    pendingInteractions.register("conf-2", {
+      conversationId: "conv-z",
+      kind: "confirmation",
+    });
+    pendingInteractions.removeByConversation("conv-z", "cancelled");
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    );
+    expect(events).toHaveLength(1);
+    expect(
+      (events[0] as Extract<ServerMessage, { type: "interaction_resolved" }>)
+        .state,
+    ).toBe("cancelled");
+  });
+});

package/src/__tests__/platform-proxy-context.test.ts

@@ -117,8 +117,13 @@ describe("buildManagedBaseUrl", () => {
     );
   });
 
+  test("returns managed URL for fireworks", async () => {
+    expect(await buildManagedBaseUrl("fireworks")).toBe(
+      "https://platform.example.com/v1/runtime-proxy/fireworks",
+    );
+  });
+
   test("returns undefined for non-managed providers", async () => {
-    expect(await buildManagedBaseUrl("fireworks")).toBeUndefined();
     expect(await buildManagedBaseUrl("openrouter")).toBeUndefined();
     expect(await buildManagedBaseUrl("ollama")).toBeUndefined();
   });

package/src/__tests__/platform.test.ts

@@ -8,7 +8,6 @@ import {
   getDataDir,
   getDbPath,
   getHistoryPath,
-  getInterfacesDir,
   getLogPath,
   getPidPath,
   getSandboxRootDir,
@@ -67,7 +66,6 @@ describe("path characterization", () => {
     expect(getDbPath()).toBe(join(data, "db", "assistant.db"));
     expect(getLogPath()).toBe(join(data, "logs", "vellum.log"));
     expect(getHistoryPath()).toBe(join(data, "history"));
-    expect(getInterfacesDir()).toBe(join(data, "interfaces"));
     expect(getSandboxRootDir()).toBe(join(data, "sandbox"));
     expect(getSandboxWorkingDir()).toBe(ws);
 
@@ -117,7 +115,6 @@ describe("path characterization", () => {
     expect(existsSync(join(data, "memory"))).toBe(true);
     expect(existsSync(join(data, "memory", "knowledge"))).toBe(true);
     expect(existsSync(join(data, "apps"))).toBe(true);
-    expect(existsSync(join(data, "interfaces"))).toBe(true);
 
     rmSync(wsDir, { recursive: true, force: true });
   });