@vellumai/assistant 0.8.3 → 0.8.5

package/src/providers/types.ts

@@ -27,6 +27,15 @@ export interface FileContent {
     filename: string;
   };
   extracted_text?: string;
+  /**
+   * Internal id linking this block to a row in the attachments table.
+   * Set when the file block originates from a persisted user-message
+   * attachment so downstream consumers (DB joins, inline-chip
+   * positioning) can correlate the block back to its attachment id.
+   * Stripped by `daemon/handlers/shared.ts` before sending to the
+   * model.
+   */
+  _attachmentId?: string;
 }
 
 export interface ToolUseContent {
@@ -137,6 +146,22 @@ export type ProviderEvent =
       toolUseId: string;
       isError: boolean;
       content?: unknown[];
+      /**
+       * Finalized input for the server tool call (e.g. the actual query).
+       * Anthropic streams `server_tool_use` block input via `input_json_delta`
+       * events, so consumers reading the input at `server_tool_start` see `{}`.
+       * The provider accumulates the JSON and surfaces it here once the block
+       * stops, so downstream handlers can build accurate activity metadata.
+       */
+      resolvedInput?: Record<string, unknown>;
+      /**
+       * Provider-specific error code when `isError` is true (e.g. Anthropic's
+       * `max_uses_exceeded`, `query_too_long`). Surfaced so user-facing
+       * messages can be specific instead of a generic "Search failed".
+       */
+      errorCode?: string;
+      /** Optional human-readable error message from the provider. */
+      errorMessage?: string;
     };
 
 export interface SendMessageConfig {

package/src/providers/usage-tracking.ts

@@ -2,6 +2,7 @@ import { recordUsageEvent } from "../memory/llm-usage-store.js";
 import { resolveUsageAttribution } from "../usage/attribution.js";
 import {
   buildPricingUsageFromResponse,
+  extractRawUsage,
   resolveStructuredPricing,
 } from "../usage/pricing.js";
 import { getLogger } from "../util/logger.js";
@@ -76,6 +77,7 @@ export class UsageTrackingProvider implements Provider {
           outputTokens: pricingUsage.outputTokens,
           cacheCreationInputTokens: pricingUsage.cacheCreationInputTokens,
           cacheReadInputTokens: pricingUsage.cacheReadInputTokens,
+          rawUsage: extractRawUsage(response.rawResponse),
           conversationId: null,
           runId: null,
           requestId: null,

package/src/runtime/AGENTS.md

@@ -161,10 +161,10 @@ All `/v1/*` endpoints share a per-client-IP sliding-window rate limiter (`middle
 
 When the limit is exceeded, the limiter returns 429 and logs a structured warning (module: `rate-limiter`) with the denied endpoint and a breakdown of which endpoints consumed the budget in the current window. This makes it easy to identify whether the cause is rapid conversation switching, polling, or unexpected request volume.
 
-Logs are written to `~/.vellum/workspace/data/logs/vellum.log` by default. If `logFile.dir` is configured, logs rotate daily as `assistant-YYYY-MM-DD.log` in that directory. To watch rate limit events in real time:
+Logs rotate daily into `$VELLUM_WORKSPACE_DIR/data/logs/assistant-YYYY-MM-DD.log` (or into the directory configured via `logFile.dir`). To watch rate limit events in real time:
 
 ```bash
-tail -f ~/.vellum/workspace/data/logs/vellum.log | grep rate-limit
+tail -f "$VELLUM_WORKSPACE_DIR/data/logs/assistant-$(date -u +%Y-%m-%d).log" | grep rate-limit
 ```
 
 The provider-level rate limiter (`providers/ratelimit.ts`) also logs warnings (module: `rate-limit`) when request rate or token budget limits are enforced.

package/src/runtime/__tests__/agent-wake.test.ts

@@ -22,8 +22,29 @@ import type { DiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
 // Stub the DB-backed override-profile read so unit tests don't need a
 // real SQLite database. The wake helper calls this on every invocation
 // to honor the conversation's pinned inference profile.
+// `getConversation` is consumed by `defaultResolveTarget` — most tests
+// pass explicit `deps.resolveTarget` and bypass it, but the
+// trust-context threading test below drives the default resolver and
+// needs the existence/archived check to pass.
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
+  getConversation: () => ({ archivedAt: null }),
+}));
+
+const mockGetOrCreateConversationCalls: Array<{
+  conversationId: string;
+  options: unknown;
+}> = [];
+mock.module("../../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: (conversationId: string, options?: unknown) => {
+    mockGetOrCreateConversationCalls.push({ conversationId, options });
+    return Promise.resolve({ __mockConversation: true });
+  },
+}));
+
+let mockResolverTarget: unknown = null;
+mock.module("../../daemon/wake-target-adapter.js", () => ({
+  conversationToWakeTarget: () => mockResolverTarget,
 }));
 
 mock.module("../../config/loader.js", () => ({
@@ -248,6 +269,8 @@ function makeTarget(options: {
 beforeEach(() => {
   __resetWakeChainForTests();
   recordRequestLogCalls.length = 0;
+  mockGetOrCreateConversationCalls.length = 0;
+  mockResolverTarget = null;
   mockDiskPressureStatus = {
     enabled: false,
     state: "disabled",
@@ -1587,4 +1610,195 @@ describe("wakeAgentForOpportunity", () => {
     // No log row was inserted because JSON.stringify threw.
     expect(recordRequestLogCalls).toHaveLength(0);
   });
+
+  // Regression guard for fork-based memory retrospectives: PR #31260
+  // forked a conversation and waked it with a guardian trustContext,
+  // but the wake's default resolver called
+  // `getOrCreateConversation(conversationId)` with no options, so the
+  // store hydrated with `trustContext === undefined`. `loadFromDb`
+  // fail-closes to `trustClass: "unknown"` and filters out every
+  // guardian-provenance message — so the LLM saw an empty history and
+  // every fork sent `messages: []`. Threading trustContext through
+  // ensures `setTrustContext` + `ensureActorScopedHistory` run during
+  // hydration.
+  const makeDefaultResolverTarget = (conversationId: string): WakeTarget => {
+    const history: Message[] = [];
+    let processing = false;
+    return {
+      conversationId,
+      agentLoop: { run: async (input) => input },
+      getMessages: () => history,
+      pushMessage: () => {},
+      emitAgentEvent: () => {},
+      isProcessing: () => processing,
+      markProcessing: (on) => {
+        processing = on;
+      },
+      persistTailMessage: async () => {},
+    };
+  };
+
+  test("default resolver threads WakeOptions.trustContext into getOrCreateConversation", async () => {
+    mockResolverTarget = makeDefaultResolverTarget("conv-thread-trust");
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+    } as const;
+
+    await wakeAgentForOpportunity({
+      conversationId: "conv-thread-trust",
+      hint: "consolidate",
+      source: "memory_v2_consolidation",
+      trustContext,
+    });
+
+    expect(mockGetOrCreateConversationCalls).toEqual([
+      { conversationId: "conv-thread-trust", options: { trustContext } },
+    ]);
+  });
+
+  test("default resolver passes trustContext: undefined when WakeOptions.trustContext is omitted", async () => {
+    // Inbound user-turn wakes get trust via processMessage(); the wake
+    // must not synthesize a trust context out of thin air.
+    mockResolverTarget = makeDefaultResolverTarget("conv-no-trust-default");
+
+    await wakeAgentForOpportunity({
+      conversationId: "conv-no-trust-default",
+      hint: "x",
+      source: "unit-test",
+    });
+
+    expect(mockGetOrCreateConversationCalls).toEqual([
+      {
+        conversationId: "conv-no-trust-default",
+        options: { trustContext: undefined },
+      },
+    ]);
+  });
+
+  describe("suppressWakeSurface option", () => {
+    function makeCheckpointTarget(): {
+      target: WakeTarget;
+      persistedTailCalls: Message[];
+      wakeProducedOutputCalls: string[];
+    } {
+      const firstAssistant: Message = {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu-1", name: "some_tool", input: {} },
+        ],
+      };
+      const toolResult: Message = {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: "tu-1", content: "ok" }],
+      };
+      const persistedTailCalls: Message[] = [];
+      const baseline: Message[] = [
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ];
+      const history: Message[] = [...baseline];
+      let processing = false;
+      const wakeProducedOutputCalls: string[] = [];
+
+      const target: WakeTarget = {
+        conversationId: "conv-suppress-surface",
+        agentLoop: {
+          run: async (_input, _onEvent, _signal, _requestId, onCheckpoint) => {
+            const runHistory: Message[] = [..._input];
+            runHistory.push(firstAssistant);
+            runHistory.push(toolResult);
+            await onCheckpoint!({
+              turnIndex: 0,
+              toolCount: 1,
+              hasToolUse: true,
+              history: runHistory,
+            });
+            return runHistory;
+          },
+        },
+        getMessages: () => history,
+        pushMessage: (msg) => {
+          history.push(msg);
+        },
+        emitAgentEvent: () => {},
+        isProcessing: () => processing,
+        markProcessing: (on) => {
+          processing = on;
+        },
+        persistTailMessage: async (msg) => {
+          persistedTailCalls.push(msg);
+        },
+        onWakeProducedOutput: (_source, _hint, surfaceId) => {
+          wakeProducedOutputCalls.push(surfaceId);
+        },
+      };
+      return { target, persistedTailCalls, wakeProducedOutputCalls };
+    }
+
+    test(
+      "default (suppressWakeSurface omitted) still injects the ui_surface " +
+        "card and calls onWakeProducedOutput",
+      async () => {
+        const { target, persistedTailCalls, wakeProducedOutputCalls } =
+          makeCheckpointTarget();
+
+        await wakeAgentForOpportunity(
+          {
+            conversationId: "conv-suppress-surface",
+            hint: "do the thing",
+            source: "memory_v2_consolidation",
+          },
+          { resolveTarget: async () => target },
+        );
+
+        // Existing behavior: card injected, broadcast fired exactly once.
+        expect(wakeProducedOutputCalls).toHaveLength(1);
+        const persistedFirst = persistedTailCalls[0];
+        expect(persistedFirst).toBeDefined();
+        const blocks = Array.isArray(persistedFirst!.content)
+          ? persistedFirst!.content
+          : [];
+        const uiBlock = blocks.find(
+          (b: { type?: string }) => b.type === "ui_surface",
+        );
+        expect(uiBlock).toBeDefined();
+      },
+    );
+
+    test(
+      "suppressWakeSurface: true produces output but skips the ui_surface " +
+        "card injection and the onWakeProducedOutput broadcast",
+      async () => {
+        const { target, persistedTailCalls, wakeProducedOutputCalls } =
+          makeCheckpointTarget();
+
+        await wakeAgentForOpportunity(
+          {
+            conversationId: "conv-suppress-surface",
+            hint: "do the thing",
+            source: "memory_v2_consolidation",
+            suppressWakeSurface: true,
+          },
+          { resolveTarget: async () => target },
+        );
+
+        // Tail still persisted (wake produced real output).
+        const persistedFirst = persistedTailCalls[0];
+        expect(persistedFirst).toBeDefined();
+        // First assistant tail message should NOT have a ui_surface block
+        // prepended at the front.
+        const blocks = Array.isArray(persistedFirst!.content)
+          ? persistedFirst!.content
+          : [];
+        const firstBlock = blocks[0] as { type?: string } | undefined;
+        expect(firstBlock?.type).not.toBe("ui_surface");
+        const uiBlock = blocks.find(
+          (b: { type?: string }) => b.type === "ui_surface",
+        );
+        expect(uiBlock).toBeUndefined();
+        // Live broadcast was suppressed.
+        expect(wakeProducedOutputCalls).toHaveLength(0);
+      },
+    );
+  });
 });

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

@@ -94,6 +94,8 @@ mock.module("../pre-first-message-gate.js", () => ({
 
 // Import after mocks are in place.
 const { runBackgroundJob } = await import("../background-job-runner.js");
+const { bufferIfDeferred, resetDeferredForTest } =
+  await import("../../notifications/deferred-emit.js");
 
 // ── Shared fixtures ──────────────────────────────────────────────────
 
@@ -121,6 +123,7 @@ beforeEach(() => {
   processMessageCalls.length = 0;
   emitCalls.length = 0;
   addMessageCalls.length = 0;
+  resetDeferredForTest();
   preFirstMessageGateOpen = true;
   processMessageImpl = async () => ({ messageId: "msg-1" });
   emitImpl = async () => ({
@@ -354,4 +357,129 @@ describe("runBackgroundJob", () => {
       expect(processMessageCalls).toHaveLength(1);
     });
   });
+
+  describe("deferNotifications", () => {
+    function buildSkillNotificationParams(message: string) {
+      return {
+        sourceEventName: "assistant.share",
+        sourceChannel: "assistant_tool" as const,
+        sourceContextId: "skill-ctx",
+        contextPayload: { requestedMessage: message },
+        attentionHints: {
+          requiresAction: false,
+          urgency: "low" as const,
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+      };
+    }
+
+    test("success path commits buffered in-band notifications", async () => {
+      processMessageImpl = async () => {
+        // Stand in for the IPC route's bufferIfDeferred call when the model
+        // invokes `notifications send` mid-turn.
+        const buffered = bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("all green"),
+        );
+        expect(buffered).not.toBeNull();
+        expect(buffered!.dispatched).toBe(false);
+        return { messageId: "msg-success" };
+      };
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true }),
+      );
+
+      expect(result.ok).toBe(true);
+      // Commit flushed the buffered notification through emitNotificationSignal.
+      const successEmits = emitCalls.filter(
+        (e) => e.sourceEventName !== "activity.failed",
+      );
+      expect(successEmits).toHaveLength(1);
+      expect(successEmits[0].sourceEventName).toBe("assistant.share");
+    });
+
+    // Regression for the PR #31216 Codex P1 finding: a heartbeat that calls
+    // the notifications skill and then times out must not leave a "success"
+    // notification standing alongside the runner's `activity.failed` emit.
+    test("timeout drops buffered in-band notifications; only activity.failed emits", async () => {
+      processMessageImpl = () => {
+        bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("premature success"),
+        );
+        return new Promise(() => {});
+      };
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true, timeoutMs: 30 }),
+      );
+
+      expect(result.ok).toBe(false);
+      expect(result.errorKind).toBe("timeout");
+      // Only the runner's failure signal makes it out — the buffered
+      // "success" notification is discarded.
+      expect(emitCalls).toHaveLength(1);
+      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+    });
+
+    test("thrown exception also drops buffered notifications", async () => {
+      processMessageImpl = async () => {
+        bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("doomed"),
+        );
+        throw new Error("kaboom");
+      };
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true }),
+      );
+
+      expect(result.ok).toBe(false);
+      expect(emitCalls).toHaveLength(1);
+      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+    });
+
+    // Regression: after timeout, `processMessage` keeps running and may
+    // emit a late skill call. The tombstone must swallow it instead of
+    // letting it bypass the buffer and reach the dispatch pipeline.
+    test("late skill call after timeout is swallowed by the tombstone", async () => {
+      processMessageImpl = () => new Promise(() => {});
+
+      const result = await runBackgroundJob(
+        baseOpts({ deferNotifications: true, timeoutMs: 20 }),
+      );
+      expect(result.ok).toBe(false);
+
+      const late = bufferIfDeferred(
+        STUB_CONVERSATION_ID,
+        buildSkillNotificationParams("post-timeout"),
+      );
+      expect(late).not.toBeNull();
+      expect(late!.dispatched).toBe(false);
+      expect(late!.reason).toMatch(/did not complete/);
+
+      // Only the runner's failure signal made it out.
+      expect(emitCalls).toHaveLength(1);
+      expect(emitCalls[0].sourceEventName).toBe("activity.failed");
+    });
+
+    test("without deferNotifications, bufferIfDeferred is a no-op", async () => {
+      processMessageImpl = async () => {
+        const buffered = bufferIfDeferred(
+          STUB_CONVERSATION_ID,
+          buildSkillNotificationParams("immediate"),
+        );
+        // Buffer was never armed, so the call returns null and the IPC
+        // handler would emit directly.
+        expect(buffered).toBeNull();
+        return { messageId: "msg-success" };
+      };
+
+      const result = await runBackgroundJob(baseOpts());
+      expect(result.ok).toBe(true);
+    });
+  });
 });