@vellumai/assistant 0.11.1-dev.202608032226.351a4e2 → 0.11.1-dev.202608032326.ca2b5a1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608032226.351a4e2",
+  "version": "0.11.1-dev.202608032326.ca2b5a1",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/compaction-events.test.ts

@@ -7,6 +7,10 @@
  * turn. The `context_compacted` event is the single source of truth for the
  * indicator — the paired `usage_update` intentionally omits
  * `contextWindowTokens` to avoid a redundant SwiftUI invalidation.
+ *
+ * Also covers the `context_window_usage` push, which carries the provider
+ * tokenizer's post-compaction count so the web indicator matches the numbers
+ * on the `/compact` result card.
  */
 import { describe, expect, mock, test } from "bun:test";
 
@@ -218,7 +222,8 @@ import { Conversation } from "../daemon/conversation.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeProvider() {
+function makeProvider(counts?: number[]) {
+  const pending = counts ? [...counts] : null;
   return {
     name: "mock-provider",
     async sendMessage(): Promise<ProviderResponse> {
@@ -229,16 +234,20 @@ function makeProvider() {
         stopReason: "end_turn",
       };
     },
+    // Present only when the test supplies counts, so the other cases keep
+    // exercising the local-estimate fallback.
+    ...(pending ? { countInputTokens: async () => pending.shift() ?? 0 } : {}),
   };
 }
 
 function makeConversation(
   collected: AssistantEvent[],
   id = "conv-compact-events",
+  counts?: number[],
 ): Conversation {
   return new Conversation(
     id,
-    makeProvider(),
+    makeProvider(counts),
     "system prompt",
     (msg) => {
       collected.push(msg);
@@ -383,6 +392,134 @@ describe("forceCompact event emission", () => {
   });
 });
 
+describe("forceCompact context-window usage push", () => {
+  test("pushes the post-compaction tokenizer count the result card reports", async () => {
+    const collected: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      // Estimate-based figures the compaction pipeline records internally.
+      // The user-facing numbers come from the provider tokenizer instead.
+      previousEstimatedInputTokens: 43_000,
+      estimatedInputTokens: 12_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 1,
+      summaryInputTokens: 500,
+      summaryOutputTokens: 200,
+      summaryModel: "test-model",
+      summaryText: "summary text",
+    };
+
+    const conversation = makeConversation(
+      collected,
+      "conv-compact-usage",
+      [56_000, 18_000],
+    );
+    const result = await conversation.forceCompact();
+
+    expect(result.previousEstimatedInputTokens).toBe(56_000);
+    expect(result.estimatedInputTokens).toBe(18_000);
+
+    const usage = collected.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    const usageEvent = usage[0] as Extract<
+      AssistantEvent,
+      { type: "context_window_usage" }
+    >;
+    expect(usageEvent.conversationId).toBe("conv-compact-usage");
+    // Same figures the `/compact` card renders, so the indicator and the card
+    // cannot disagree.
+    expect(usageEvent.tokens).toBe(result.estimatedInputTokens);
+    expect(usageEvent.maxTokens).toBe(200_000);
+  });
+
+  test("pushes to the caller's sink when the conversation's own sender is dead", async () => {
+    // A `/compact` draining behind an interactive turn: `process-message.ts`
+    // resets `sendToClient` to a no-op in its `finally`, while the queued item
+    // still carries the live sink its result card streams on. The push has to
+    // follow the card, not the dead sender.
+    const stranded: AssistantEvent[] = [];
+    const cardSink: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: true,
+      previousEstimatedInputTokens: 43_000,
+      estimatedInputTokens: 12_000,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 10,
+      compactedPersistedMessages: 5,
+      summaryCalls: 1,
+      summaryInputTokens: 500,
+      summaryOutputTokens: 200,
+      summaryModel: "test-model",
+      summaryText: "summary text",
+    };
+
+    const conversation = makeConversation(
+      stranded,
+      "conv-compact-dead-sender",
+      [56_000, 18_000],
+    );
+    conversation.updateClient(() => {}, true);
+
+    const result = await conversation.forceCompact((msg) => cardSink.push(msg));
+
+    const usage = cardSink.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    expect(
+      (usage[0] as Extract<AssistantEvent, { type: "context_window_usage" }>)
+        .tokens,
+    ).toBe(result.estimatedInputTokens);
+    expect(
+      stranded.filter((m) => m.type === "context_window_usage").length,
+    ).toBe(0);
+  });
+
+  test("pushes the current count when there was nothing to compact", async () => {
+    const collected: AssistantEvent[] = [];
+    mockCompactResult = {
+      messages: [],
+      compacted: false,
+      previousEstimatedInputTokens: 0,
+      estimatedInputTokens: 0,
+      maxInputTokens: 200_000,
+      thresholdTokens: 160_000,
+      compactedMessages: 0,
+      compactedPersistedMessages: 0,
+      summaryCalls: 0,
+      summaryInputTokens: 0,
+      summaryOutputTokens: 0,
+      summaryModel: "",
+      summaryText: "",
+    };
+
+    const conversation = makeConversation(
+      collected,
+      "conv-compact-usage-noop",
+      // A no-op re-counts nothing, so the single count stands as before and
+      // after.
+      [56_000],
+    );
+    const result = await conversation.forceCompact();
+
+    expect(result.previousEstimatedInputTokens).toBe(56_000);
+    expect(result.estimatedInputTokens).toBe(56_000);
+
+    const usage = collected.filter((m) => m.type === "context_window_usage");
+    expect(usage.length).toBe(1);
+    const usageEvent = usage[0] as Extract<
+      AssistantEvent,
+      { type: "context_window_usage" }
+    >;
+    expect(usageEvent.tokens).toBe(56_000);
+    expect(usageEvent.maxTokens).toBe(200_000);
+  });
+});
+
 describe("maybeCompact gate sizing", () => {
   test("default sizing resolves mainAgent's window; wake sizing resolves the wake's call-site window", async () => {
     // The auto-threshold gate derives its trip point from the

package/src/__tests__/conversation-error.test.ts

@@ -777,6 +777,9 @@ describe("classifyConversationError", () => {
       expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.retryable).toBe(false);
       expect(result.errorCategory).toBe("provider_invalid_key");
+      expect(result.userMessage).toBe(
+        "Your personal Anthropic API key was rejected by Anthropic. Update that key in Settings → Models & Services.",
+      );
     });
 
     it("classifies managed-proxy auth failures as managed credential refresh failures", () => {
@@ -791,12 +794,30 @@ describe("classifyConversationError", () => {
 
       expect(result.code).toBe("MANAGED_KEY_INVALID");
       expect(result.userMessage).toBe(
-        "Couldn't refresh assistant credentials.",
+        "Vellum's managed inference credential was rejected. This isn't a personal provider API key — Vellum provisions this one, so there's nothing to update in Settings.",
       );
       expect(result.retryable).toBe(false);
       expect(result.errorCategory).toBe("managed_key_invalid");
     });
 
+    it("keeps credential-shaped 4xx failures on the request's managed route", () => {
+      providerRoutingSources.anthropic = "user-key";
+      const err = new ProviderError(
+        "Authentication error: invalid API key",
+        "anthropic",
+        400,
+      );
+      err.attachRouteAttribution({ credentialSource: "vellum-managed" });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_KEY_INVALID");
+      expect(result.errorCategory).toBe("managed_key_invalid");
+      expect(result.userMessage).toBe(
+        "Vellum's managed inference credential was rejected. This isn't a personal provider API key — Vellum provisions this one, so there's nothing to update in Settings.",
+      );
+    });
+
     it("classifies ProviderError 401 with 'invalid x-api-key' message as PROVIDER_INVALID_KEY", () => {
       // Regex-match branch — Anthropic's standard 401 wording.
       const err = new ProviderError(
@@ -814,6 +835,8 @@ describe("classifyConversationError", () => {
       const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.errorCategory).toBe("provider_invalid_key");
+      expect(result.userMessage).toContain("personal OpenAI API key");
+      expect(result.userMessage).toContain("rejected by OpenAI");
     });
 
     it("includes connection/profile attribution in PROVIDER_INVALID_KEY when provided", () => {
@@ -826,7 +849,84 @@ describe("classifyConversationError", () => {
       expect(result.code).toBe("PROVIDER_INVALID_KEY");
       expect(result.connectionName).toBe("my-anthropic");
       expect(result.profileName).toBe("personal");
-      expect(result.userMessage).toContain("personal");
+      expect(result.userMessage).toBe(
+        'Your personal Anthropic API key for profile "personal" (connection "my-anthropic") was rejected by Anthropic. Update that key in Settings → Models & Services.',
+      );
+    });
+
+    it("uses the request's BYOK attribution when the same provider also has a managed route", () => {
+      providerRoutingSources.anthropic = "managed-proxy";
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      err.attachRouteAttribution({
+        credentialSource: "byok",
+        connectionName: "anthropic-personal",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_INVALID_KEY");
+      expect(result.connectionName).toBe("anthropic-personal");
+      expect(result.userMessage).toBe(
+        'Your personal Anthropic API key for connection "anthropic-personal" was rejected by Anthropic. Update that key in Settings → Models & Services.',
+      );
+    });
+
+    it("uses the request's managed attribution when the same provider also has a BYOK route", () => {
+      providerRoutingSources.anthropic = "user-key";
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      err.attachRouteAttribution({
+        credentialSource: "vellum-managed",
+        connectionName: "vellum",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("MANAGED_KEY_INVALID");
+      expect(result.userMessage).toBe(
+        "Vellum's managed inference credential was rejected. This isn't a personal provider API key — Vellum provisions this one, so there's nothing to update in Settings.",
+      );
+    });
+
+    it("uses subscription-specific recovery when the same provider also has a managed route", () => {
+      providerRoutingSources.openai = "managed-proxy";
+      const err = new ProviderError("Unauthorized", "openai", 401, {
+        reason: "invalid_credentials",
+      });
+      err.attachRouteAttribution({
+        credentialSource: "oauth-subscription",
+        connectionName: "chatgpt-subscription",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_API");
+      expect(result.errorCategory).toBe("provider_subscription_auth");
+      expect(result.retryable).toBe(false);
+      expect(result.connectionName).toBe("chatgpt-subscription");
+      expect(result.userMessage).toBe(
+        'Your OpenAI subscription login for connection "chatgpt-subscription" was rejected by OpenAI. Reconnect that account in Settings → Models & Services.',
+      );
+    });
+
+    it("explains when a no-auth endpoint rejects an unauthenticated request", () => {
+      providerRoutingSources["openai-compatible"] = "managed-proxy";
+      const err = new ProviderError("Unauthorized", "openai-compatible", 401, {
+        reason: "invalid_credentials",
+      });
+      err.attachRouteAttribution({
+        credentialSource: "no-auth",
+        connectionName: "local-model-server",
+      });
+
+      const result = classifyConversationError(err, baseCtx);
+
+      expect(result.code).toBe("PROVIDER_API");
+      expect(result.errorCategory).toBe("provider_endpoint_auth_required");
+      expect(result.retryable).toBe(false);
+      expect(result.connectionName).toBe("local-model-server");
+      expect(result.userMessage).toBe(
+        'The OpenAI-compatible endpoint for connection "local-model-server" requires authentication, but that connection is configured without credentials. Configure authentication for that endpoint in Settings → Models & Services.',
+      );
     });
 
     it("classifies direct ProviderError with 402 as provider_billing (non-retryable)", () => {

package/src/__tests__/conversation-summarize-route.test.ts

@@ -257,7 +257,13 @@ describe("POST /v1/conversations/summarize", () => {
 
     await settle();
 
-    expect(ctx.summarizeUpToMessage).toHaveBeenCalledWith("msg-42");
+    // The second arg is the sink the context-window usage push rides. This
+    // route's conversation may hold the store's no-op sender, so it hands in
+    // the broadcast path its result card goes out on.
+    expect(ctx.summarizeUpToMessage).toHaveBeenCalledWith(
+      "msg-42",
+      expect.any(Function),
+    );
     expect(ctx.emitActivityState).toHaveBeenCalledWith(
       "thinking",
       "context_compacting",

package/src/__tests__/conversation-summarize-up-to.test.ts

@@ -15,6 +15,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
 import type { CompactionContext } from "../plugins/defaults/compaction/compact.js";
 import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
@@ -212,7 +213,8 @@ import { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "../daemon/trust-context.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeProvider() {
+function makeProvider(counts?: number[]) {
+  const pending = counts ? [...counts] : null;
   return {
     name: "mock-provider",
     async sendMessage(): Promise<ProviderResponse> {
@@ -223,15 +225,21 @@ function makeProvider() {
         stopReason: "end_turn",
       };
     },
+    // Present only when the test supplies counts, so the other cases keep
+    // exercising the local-estimate fallback.
+    ...(pending ? { countInputTokens: async () => pending.shift() ?? 0 } : {}),
   };
 }
 
-function makeConversation(): Conversation {
+function makeConversation(options?: {
+  counts?: number[];
+  onEvent?: (msg: AssistantEvent) => void;
+}): Conversation {
   const conversation = new Conversation(
     "conv-1",
-    makeProvider(),
+    makeProvider(options?.counts),
     "system prompt",
-    () => {},
+    options?.onEvent ?? (() => {}),
     "/tmp",
     { maxTokens: 4096 },
   );
@@ -365,7 +373,10 @@ describe("Conversation.summarizeUpToMessage", () => {
 
     const result = await conversation.summarizeUpToMessage("m4");
 
-    expect(result).toBe(mockCompactResult);
+    // The compaction result passes through with its displayed token counts
+    // re-measured by the provider tokenizer, which the mocked manager reports
+    // as 0 here.
+    expect(result).toEqual(mockCompactResult);
     expect(compactCalls).toHaveLength(1);
     expect(compactCalls[0].force).toBe(true);
     // Row index 4 with no compacted prefix and no summary message → 4.
@@ -853,6 +864,61 @@ describe("Conversation.summarizeUpToMessage", () => {
     expect(recordOutcome).toHaveBeenCalledTimes(1);
     expect(recordOutcome).toHaveBeenCalledWith(true, expect.anything());
   });
+
+  test("reports tokenizer counts and pushes them to the caller's sink", async () => {
+    // The management route resolves its conversation outside the send path, so
+    // the instance keeps the store's no-op sender: the push has to ride the
+    // sink the route hands in, not `sendToClient`.
+    const collected: AssistantEvent[] = [];
+    const conversation = makeConversation({ counts: [56_000, 18_000] });
+    mockCompactResult = {
+      ...makeNoopResult(),
+      compacted: true,
+      // Estimate-based figures the pipeline records internally; the card and
+      // the indicator both report the tokenizer counts instead.
+      previousEstimatedInputTokens: 43_000,
+      estimatedInputTokens: 12_000,
+      maxInputTokens: 200_000,
+      compactedPersistedMessages: 4,
+    };
+
+    const result = await conversation.summarizeUpToMessage("m4", (msg) =>
+      collected.push(msg),
+    );
+
+    expect(result.previousEstimatedInputTokens).toBe(56_000);
+    expect(result.estimatedInputTokens).toBe(18_000);
+
+    const usage = collected.filter((m) => m.type === "context_window_usage");
+    expect(usage).toHaveLength(1);
+    const usageEvent = usage[0] as Extract<
+      AssistantEvent,
+      { type: "context_window_usage" }
+    >;
+    expect(usageEvent.conversationId).toBe("conv-1");
+    expect(usageEvent.tokens).toBe(result.estimatedInputTokens);
+    expect(usageEvent.maxTokens).toBe(200_000);
+  });
+
+  test("falls back to the conversation's own sender when no sink is passed", async () => {
+    const collected: AssistantEvent[] = [];
+    const conversation = makeConversation({
+      counts: [56_000, 18_000],
+      onEvent: (msg) => collected.push(msg),
+    });
+    mockCompactResult = {
+      ...makeNoopResult(),
+      compacted: true,
+      maxInputTokens: 200_000,
+      compactedPersistedMessages: 4,
+    };
+
+    await conversation.summarizeUpToMessage("m4");
+
+    expect(
+      collected.filter((m) => m.type === "context_window_usage"),
+    ).toHaveLength(1);
+  });
 });
 
 describe("formatSummarizeUpToResult", () => {

package/src/__tests__/guardian-card-withdrawal.test.ts

@@ -14,6 +14,13 @@ mock.module("../messaging/providers/slack/withdraw.js", () => ({
   withdrawSlackApprovalCard,
 }));
 
+const withdrawTelegramApprovalCard = mock(
+  async (_params: Record<string, unknown>) => {},
+);
+mock.module("../messaging/providers/telegram-bot/withdraw.js", () => ({
+  withdrawTelegramApprovalCard,
+}));
+
 // The recorder writes through the gateway client; serve that surface from
 // the in-memory sim the assertions read.
 import {
@@ -60,6 +67,7 @@ describe("withdrawGuardianRequestCards", () => {
     completeSurfaceAndNotify.mockClear();
     markSurfaceCompleted.mockClear();
     withdrawSlackApprovalCard.mockClear();
+    withdrawTelegramApprovalCard.mockClear();
   });
 
   test("withdraws + broadcasts the in-app card when the decision came from another surface", async () => {
@@ -199,7 +207,7 @@ describe("withdrawGuardianRequestCards", () => {
     expect(withdrawSlackApprovalCard).toHaveBeenCalledTimes(1);
   });
 
-  test("ignores channels without in-place edit support (telegram)", async () => {
+  test("withdraws the Telegram card with a status reply when resolved from another surface", async () => {
     const req = makeRequest({ sourceChannel: "telegram" });
     bridgeState.seedDelivery({
       requestId: req.id,
@@ -208,10 +216,90 @@ describe("withdrawGuardianRequestCards", () => {
       destinationMessageId: "9",
     });
 
-    await withdrawGuardianRequestCards({ request: req, status: "approved" });
+    await withdrawGuardianRequestCards({
+      request: req,
+      status: "approved",
+      originChannel: "vellum",
+    });
 
     expect(withdrawSlackApprovalCard).not.toHaveBeenCalled();
-    expect(completeSurfaceAndNotify).not.toHaveBeenCalled();
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledTimes(1);
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledWith({
+      chatId: "T1",
+      messageId: "9",
+      status: "approved",
+      postStatusReply: true,
+    });
+  });
+
+  test("suppresses the Telegram status reply only when the origin flow replies to the guardian", async () => {
+    const req = makeRequest({ sourceChannel: "telegram" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "telegram",
+      destinationChatId: "T1",
+      destinationMessageId: "9",
+    });
+
+    await withdrawGuardianRequestCards({
+      request: req,
+      status: "denied",
+      originChannel: "telegram",
+      decidedAction: "reject",
+      hasOriginGuardianReply: true,
+    });
+
+    // The resolver's guardian-facing reply is being delivered in that chat;
+    // withdrawal only drops the keyboard.
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledWith({
+      chatId: "T1",
+      messageId: "9",
+      status: "denied",
+      decidedAction: "reject",
+      postStatusReply: false,
+    });
+  });
+
+  test("posts the Telegram status reply for origin decisions without a guardian-facing resolver reply", async () => {
+    const req = makeRequest({ sourceChannel: "telegram" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "telegram",
+      destinationChatId: "T1",
+      destinationMessageId: "9",
+    });
+
+    // Most resolvers (tool grants, tool approvals, questions) reply to the
+    // requester only, so the quoted status reply is the guardian's only
+    // durable outcome even for a decision made on Telegram itself.
+    await withdrawGuardianRequestCards({
+      request: req,
+      status: "approved",
+      originChannel: "telegram",
+      decidedAction: "approve_once",
+      hasOriginGuardianReply: false,
+    });
+
+    expect(withdrawTelegramApprovalCard).toHaveBeenCalledWith({
+      chatId: "T1",
+      messageId: "9",
+      status: "approved",
+      decidedAction: "approve_once",
+      postStatusReply: true,
+    });
+  });
+
+  test("skips the Telegram edit when no channel message id was captured", async () => {
+    const req = makeRequest({ sourceChannel: "telegram" });
+    bridgeState.seedDelivery({
+      requestId: req.id,
+      destinationChannel: "telegram",
+      destinationChatId: "T1",
+    });
+
+    await withdrawGuardianRequestCards({ request: req, status: "approved" });
+
+    expect(withdrawTelegramApprovalCard).not.toHaveBeenCalled();
   });
 
   test("is best-effort: a failing surface never blocks the others or throws", async () => {

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -27,6 +27,9 @@ mock.module("../messaging/providers/telegram-bot/send.js", () => ({
       text,
       approval: approval as (typeof sendCalls)[0]["approval"],
     });
+    // Mirror the real send result: the id of the sent message, which the
+    // adapter surfaces so the delivery row can address the card later.
+    return { lastMessageId: String(1000 + sendCalls.length) };
   },
   sendTelegramAttachments: async () => ({
     allFailed: false,
@@ -196,6 +199,9 @@ describe("TelegramAdapter", () => {
     const result = await adapter.send(payload, makeDestination());
 
     expect(result.success).toBe(true);
+    // The sent message's channel-native id is surfaced so the delivery row
+    // can address the card for in-place withdrawal later.
+    expect(result.messageId).toBe("1001");
     expect(sendCalls).toHaveLength(1);
 
     const call = sendCalls[0]!;