@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/process-message-background-slack.test.ts

@@ -0,0 +1,331 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentsByIds: () => [],
+  getSourcePathsForAttachments: () => new Map<string, string>(),
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  createCanonicalGuardianRequest: () => ({
+    id: "canonical-id",
+    requestCode: "ABC123",
+  }),
+  generateCanonicalRequestCode: () => "ABC123",
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "message-id" }),
+  getConversation: () => null,
+  provenanceFromTrustContext: () => ({}),
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+}));
+
+mock.module("../memory/conversation-disk-view.js", () => ({
+  updateMetaFile: () => {},
+}));
+
+mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
+  bridgeConfirmationRequestToGuardian: () => {},
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => {},
+  resolve: () => {},
+}));
+
+mock.module("../security/secret-scanner.js", () => ({
+  redactSecrets: (value: string) => value,
+}));
+
+mock.module("../tools/tool-input-summary.js", () => ({
+  summarizeToolInput: () => "",
+}));
+
+mock.module("../daemon/conversation-runtime-assembly.js", () => ({
+  resolveChannelCapabilities: () => ({
+    channel: "slack",
+    dashboardCapable: false,
+    supportsDynamicUi: false,
+    supportsVoiceInput: false,
+    chatType: "channel",
+  }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        contextWindow: { maxInputTokens: 100000 },
+      },
+    },
+  }),
+}));
+
+type Deferred<T> = {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (err: unknown) => void;
+};
+type PersistUserMessageMock = ReturnType<
+  typeof mock<
+    (
+      content: string,
+      attachments: unknown[],
+      requestId?: string,
+      metadata?: Record<string, unknown>,
+    ) => Promise<string>
+  >
+>;
+type RunAgentLoopMock = ReturnType<
+  typeof mock<(...args: unknown[]) => Promise<void>>
+>;
+type NoticeMock = ReturnType<typeof mock<(notice: string | undefined) => void>>;
+interface TestConversation {
+  conversationId: string;
+  trustContext: unknown;
+  authContext: unknown;
+  assistantId: string | undefined;
+  taskRunId: string | undefined;
+  isProcessing: () => boolean;
+  setAssistantId: (assistantId: string) => void;
+  setTrustContext: (ctx: unknown) => void;
+  setAuthContext: (ctx: unknown) => void;
+  ensureActorScopedHistory: () => Promise<void>;
+  setChannelCapabilities: () => void;
+  setHostCuProxy: () => void;
+  addPreactivatedSkillId: () => void;
+  setCommandIntent: () => void;
+  setTurnChannelContext: (ctx: TurnChannelContext) => void;
+  getTurnChannelContext: () => TurnChannelContext | null;
+  setTurnInterfaceContext: (ctx: TurnInterfaceContext) => void;
+  getTurnInterfaceContext: () => TurnInterfaceContext | null;
+  getMessages: () => unknown[];
+  usageStats: {
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCost: number;
+  };
+  persistUserMessage: PersistUserMessageMock;
+  setSlackRuntimeContextNotice: NoticeMock;
+  runAgentLoop: RunAgentLoopMock;
+  updateClient: (sender: (...args: unknown[]) => void) => void;
+  getCurrentSender: () => ((...args: unknown[]) => void) | undefined;
+  __loopDeferred: Deferred<void>;
+  __noticeCalls: Array<string | undefined>;
+  __loopNotices: Array<string | undefined>;
+  __clientSenders: Array<((...args: unknown[]) => void) | undefined>;
+}
+
+let activeConversation: TestConversation;
+const mergeConversationOptionsMock = mock(() => {});
+
+mock.module("../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: async () => activeConversation,
+  mergeConversationOptions: mergeConversationOptionsMock,
+}));
+
+import type {
+  TurnChannelContext,
+  TurnInterfaceContext,
+} from "../channels/types.js";
+import {
+  processMessage,
+  processMessageInBackground,
+} from "../daemon/process-message.js";
+
+function createDeferred<T = void>(): Deferred<T> {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (err: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+async function waitForRunAgentLoopCall(): Promise<void> {
+  for (let i = 0; i < 10; i++) {
+    if (activeConversation.runAgentLoop.mock.calls.length > 0) return;
+    await Promise.resolve();
+  }
+}
+
+function makeConversation(): TestConversation {
+  let turnChannelContext: TurnChannelContext | null = null;
+  let turnInterfaceContext: TurnInterfaceContext | null = null;
+  let slackNotice: string | undefined;
+  let currentSender: ((...args: unknown[]) => void) | undefined;
+  const noticeCalls: Array<string | undefined> = [];
+  const loopDeferred = createDeferred<void>();
+  const loopNotices: Array<string | undefined> = [];
+  const clientSenders: Array<((...args: unknown[]) => void) | undefined> = [];
+  const messages: unknown[] = [];
+
+  const conversation: TestConversation = {
+    conversationId: "conv-background-slack",
+    trustContext: undefined,
+    authContext: undefined,
+    assistantId: undefined,
+    taskRunId: undefined,
+    isProcessing: () => false,
+    setAssistantId: (assistantId: string) => {
+      conversation.assistantId = assistantId;
+    },
+    setTrustContext: (ctx: unknown) => {
+      conversation.trustContext = ctx;
+    },
+    setAuthContext: (ctx: unknown) => {
+      conversation.authContext = ctx;
+    },
+    ensureActorScopedHistory: async () => {},
+    setChannelCapabilities: () => {},
+    setHostCuProxy: () => {},
+    addPreactivatedSkillId: () => {},
+    setCommandIntent: () => {},
+    setTurnChannelContext: (ctx: TurnChannelContext) => {
+      turnChannelContext = ctx;
+    },
+    getTurnChannelContext: () => turnChannelContext,
+    setTurnInterfaceContext: (ctx: TurnInterfaceContext) => {
+      turnInterfaceContext = ctx;
+    },
+    getTurnInterfaceContext: () => turnInterfaceContext,
+    getMessages: () => messages,
+    usageStats: {
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCost: 0,
+    },
+    persistUserMessage: mock(
+      async (
+        _content: string,
+        _attachments: unknown[],
+        _requestId?: string,
+        _metadata?: Record<string, unknown>,
+      ) => "persisted-user-message-id",
+    ),
+    setSlackRuntimeContextNotice: mock((notice: string | undefined) => {
+      slackNotice = notice;
+      noticeCalls.push(notice);
+    }),
+    runAgentLoop: mock(async (..._args: unknown[]) => {
+      loopNotices.push(slackNotice);
+      await loopDeferred.promise;
+    }),
+    updateClient: (sender: (...args: unknown[]) => void) => {
+      currentSender = sender;
+      clientSenders.push(sender);
+    },
+    getCurrentSender: () => currentSender,
+    __loopDeferred: loopDeferred,
+    __noticeCalls: noticeCalls,
+    __loopNotices: loopNotices,
+    __clientSenders: clientSenders,
+  };
+
+  return conversation;
+}
+
+describe("processMessageInBackground Slack option propagation", () => {
+  beforeEach(() => {
+    activeConversation = makeConversation();
+    mergeConversationOptionsMock.mockClear();
+  });
+
+  test("passes Slack inbound metadata to persistence and exposes the runtime notice during the loop", async () => {
+    const slackInbound = {
+      channelId: "C0123CHANNEL",
+      channelTs: "1700000001.111111",
+      threadTs: "1700000000.000001",
+      displayName: "Alice",
+    };
+    const notice =
+      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
+
+    const result = await processMessageInBackground(
+      "conv-background-slack",
+      "Reply from Slack",
+      undefined,
+      {
+        slackInbound,
+        slackRuntimeContextNotice: notice,
+      },
+      "slack",
+      "slack",
+    );
+
+    expect(result).toEqual({ messageId: "persisted-user-message-id" });
+    expect(activeConversation.persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(activeConversation.persistUserMessage.mock.calls[0][3]).toEqual({
+      slackInbound,
+    });
+    expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
+    expect(activeConversation.__loopNotices).toEqual([notice]);
+
+    activeConversation.__loopDeferred.resolve();
+    await activeConversation.__loopDeferred.promise;
+    await Promise.resolve();
+
+    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
+  });
+
+  test("clears the Slack runtime notice after normal message processing", async () => {
+    const notice =
+      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
+
+    const processing = processMessage(
+      "conv-background-slack",
+      "Reply from Slack",
+      undefined,
+      {
+        slackRuntimeContextNotice: notice,
+        isInteractive: true,
+      },
+      "slack",
+      "slack",
+    );
+
+    await waitForRunAgentLoopCall();
+
+    expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
+    expect(activeConversation.__loopNotices).toEqual([notice]);
+
+    activeConversation.__loopDeferred.resolve();
+    await expect(processing).resolves.toEqual({
+      messageId: "persisted-user-message-id",
+    });
+
+    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
+    expect(activeConversation.__clientSenders).toHaveLength(2);
+  });
+
+  test("leaves non-Slack background persistence metadata absent", async () => {
+    await processMessageInBackground(
+      "conv-background-slack",
+      "Regular background wake",
+      undefined,
+      undefined,
+      "vellum",
+      "web",
+    );
+
+    expect(activeConversation.persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(
+      activeConversation.persistUserMessage.mock.calls[0][3],
+    ).toBeUndefined();
+    expect(activeConversation.runAgentLoop.mock.calls[0][3]).toEqual({
+      isInteractive: false,
+      isUserMessage: true,
+    });
+
+    activeConversation.__loopDeferred.resolve();
+  });
+});

package/src/__tests__/provider-managed-proxy-integration.test.ts

@@ -8,6 +8,8 @@ import { credentialKey } from "../security/credential-key.js";
 // assertions. Must be before importing the registry.
 // ---------------------------------------------------------------------------
 let lastGeminiConstructorOpts: Record<string, unknown> | null = null;
+let lastGeminiGenerateContentStreamParams: Record<string, unknown> | null =
+  null;
 
 mock.module("@google/genai", () => ({
   GoogleGenAI: class MockGoogleGenAI {
@@ -15,11 +17,14 @@ mock.module("@google/genai", () => ({
       lastGeminiConstructorOpts = opts;
     }
     models = {
-      generateContentStream: async () => ({
-        [Symbol.asyncIterator]: async function* () {
-          /* no chunks */
-        },
-      }),
+      generateContentStream: async (params: Record<string, unknown>) => {
+        lastGeminiGenerateContentStreamParams = params;
+        return {
+          [Symbol.asyncIterator]: async function* () {
+            /* no chunks */
+          },
+        };
+      },
     };
   },
   ApiError: class FakeApiError extends Error {
@@ -40,6 +45,7 @@ mock.module("@google/genai", () => ({
 let mockPlatformBaseUrl = "";
 let mockAssistantApiKey: string | null = null;
 let mockProviderKeys: Record<string, string> = {};
+let mockLlmConfig: Record<string, unknown> = {};
 
 mock.module("../config/env.js", () => ({
   getPlatformBaseUrl: () => mockPlatformBaseUrl,
@@ -54,6 +60,14 @@ mock.module("../security/secure-keys.js", () => ({
   },
 }));
 
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: mockLlmConfig,
+    services: { inference: { mode: "your-own" } },
+  }),
+}));
+
+import { LLMSchema } from "../config/schemas/llm.js";
 import type { ProvidersConfig } from "../providers/registry.js";
 import {
   getProvider,
@@ -103,13 +117,25 @@ function disableManagedProxy() {
   mockAssistantApiKey = null;
 }
 
+type ProviderWithClientBaseUrl = Record<string, unknown> & {
+  client: { baseURL: string };
+};
+
+function unwrapInnermostProvider(provider: unknown): ProviderWithClientBaseUrl {
+  let current = provider as Record<string, unknown>;
+  while (current.inner) {
+    current = current.inner as Record<string, unknown>;
+  }
+  return current as ProviderWithClientBaseUrl;
+}
+
 /**
  * Set mock secure keys with a user key for every provider in `names`.
  */
 function setUserKeysFor(...names: string[]): void {
   mockProviderKeys = {};
   for (const n of names) {
-    mockProviderKeys[n] = `user-key-${n}`;
+    mockProviderKeys[credentialKey(n, "api_key")] = `user-key-${n}`;
   }
 }
 
@@ -121,6 +147,8 @@ beforeEach(() => {
   disableManagedProxy();
   mockProviderKeys = {};
   lastGeminiConstructorOpts = null;
+  lastGeminiGenerateContentStreamParams = null;
+  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
 });
 
 describe("managed proxy integration — credential precedence", () => {
@@ -198,12 +226,7 @@ describe("managed proxy integration — credential precedence", () => {
 
       const provider = getProvider("anthropic");
 
-      // Unwrap RetryProvider → AnthropicProvider to inspect the Anthropic
-      // SDK client's baseURL. RetryProvider stores the inner provider as
-      // private `inner` and AnthropicProvider stores the SDK client as
-      // private `client`.
-      const retryInner = (provider as any).inner;
-      const anthropicClient = (retryInner as any).client;
+      const anthropicClient = unwrapInnermostProvider(provider).client;
 
       expect(anthropicClient).toBeDefined();
       const baseURL: string = anthropicClient.baseURL;
@@ -217,10 +240,7 @@ describe("managed proxy integration — credential precedence", () => {
 
       const provider = getProvider("openai");
 
-      // Unwrap RetryProvider → OpenAIResponsesProvider to inspect the OpenAI
-      // SDK client's baseURL.
-      const retryInner = (provider as any).inner;
-      const openaiClient = (retryInner as any).client;
+      const openaiClient = unwrapInnermostProvider(provider).client;
 
       expect(openaiClient).toBeDefined();
       const baseURL: string = openaiClient.baseURL;
@@ -239,6 +259,90 @@ describe("managed proxy integration — credential precedence", () => {
       expect(httpOptions).toBeDefined();
       expect(httpOptions!.baseUrl).toContain("/v1/runtime-proxy/gemini");
     });
+
+    test("managed gemini receives attribution headers outside request JSON", async () => {
+      enableManagedProxy();
+      mockProviderKeys = {};
+      mockLlmConfig = LLMSchema.parse({
+        default: { provider: "gemini", model: "gemini-3.1-pro" },
+        profiles: {
+          "conversation-profile": {
+            model: "gemini-3.1-flash",
+            source: "user",
+          },
+        },
+        callSites: {
+          mainAgent: {},
+        },
+      }) as Record<string, unknown>;
+      await initializeProviders(
+        makeProvidersConfig("gemini", "gemini-3.1-pro"),
+      );
+
+      const provider = getProvider("gemini");
+      const response = await provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "hello" }] }],
+        undefined,
+        undefined,
+        {
+          config: {
+            callSite: "mainAgent",
+            overrideProfile: "conversation-profile",
+          },
+        },
+      );
+
+      const constructorHttpOptions = lastGeminiConstructorOpts!.httpOptions as
+        | { baseUrl?: string }
+        | undefined;
+      expect(constructorHttpOptions?.baseUrl).toContain(
+        "/v1/runtime-proxy/gemini",
+      );
+      const sentConfig = lastGeminiGenerateContentStreamParams!.config as {
+        httpOptions?: { headers?: Record<string, string> };
+        usageAttributionHeaders?: Record<string, string>;
+      };
+      expect(sentConfig.httpOptions?.headers).toEqual({
+        "X-Vellum-LLM-Call-Site": "mainAgent",
+        "X-Vellum-Inference-Profile": "conversation-profile",
+        "X-Vellum-Inference-Profile-Source": "conversation",
+        "X-Vellum-Resolved-Provider": "gemini",
+        "X-Vellum-Resolved-Model": "gemini-3.1-flash",
+      });
+      expect(sentConfig.usageAttributionHeaders).toBeUndefined();
+
+      const rawRequest = response.rawRequest as {
+        config?: Record<string, unknown>;
+      };
+      expect(rawRequest.config?.usageAttributionHeaders).toBeUndefined();
+      expect(rawRequest.config?.httpOptions).toBeUndefined();
+    });
+
+    test("managed gemini omits attribution headers without callSite", async () => {
+      enableManagedProxy();
+      mockProviderKeys = {};
+      mockLlmConfig = LLMSchema.parse({
+        default: { provider: "gemini", model: "gemini-3.1-pro" },
+      }) as Record<string, unknown>;
+      await initializeProviders(
+        makeProvidersConfig("gemini", "gemini-3.1-pro"),
+      );
+
+      const provider = getProvider("gemini");
+      await provider.sendMessage(
+        [{ role: "user", content: [{ type: "text", text: "hello" }] }],
+        undefined,
+        undefined,
+        { config: { model: "gemini-3.1-pro" } },
+      );
+
+      const sentConfig = lastGeminiGenerateContentStreamParams!.config as {
+        httpOptions?: { headers?: Record<string, string> };
+        usageAttributionHeaders?: Record<string, string>;
+      };
+      expect(sentConfig.httpOptions?.headers).toBeUndefined();
+      expect(sentConfig.usageAttributionHeaders).toBeUndefined();
+    });
   });
 
   describe("neither user keys nor managed context → providers not initialized", () => {
@@ -318,7 +422,7 @@ describe("managed proxy integration — ollama exclusion", () => {
 
   test("ollama registers with explicit API key", async () => {
     enableManagedProxy();
-    mockProviderKeys = { ollama: "ollama-key" };
+    mockProviderKeys = { [credentialKey("ollama", "api_key")]: "ollama-key" };
     await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
     expect(listProviders()).toContain("ollama");
   });
@@ -331,6 +435,38 @@ describe("managed proxy integration — ollama exclusion", () => {
   });
 });
 
+describe("config mode flip → provider reinit", () => {
+  test("re-running initializeProviders after managed→your-own flip switches gemini from managed-proxy to user-key", async () => {
+    // Phase 1: managed mode without user key → gemini registered as managed-proxy.
+    // This is the pre-patch state before PATCH /v1/config is called.
+    enableManagedProxy();
+    mockProviderKeys = {};
+    await initializeProviders(makeProvidersConfig("gemini", "gemini-2.5-pro"));
+    expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+
+    // Phase 2: user has now saved a key (POST /v1/secrets), then PATCHed config
+    // to mode=your-own. handlePatchConfig calls initializeProviders(getConfig())
+    // after saving, which should re-register gemini using the user key.
+    setUserKeysFor("gemini");
+    await initializeProviders(makeProvidersConfig("gemini", "gemini-2.5-pro"));
+    expect(getProviderRoutingSource("gemini")).toBe("user-key");
+  });
+
+  test("without reinit after config patch, gemini source remains stale managed-proxy", async () => {
+    // Demonstrates the bug: if initializeProviders is NOT called after saving
+    // config, the routing source stays managed-proxy even after mode flip.
+    enableManagedProxy();
+    mockProviderKeys = {};
+    await initializeProviders(makeProvidersConfig("gemini", "gemini-2.5-pro"));
+    expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+
+    // Flip mode but do NOT re-initialize providers (simulates skipping reinit).
+    setUserKeysFor("gemini");
+    // Source stays managed-proxy because initializeProviders was not called.
+    expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+  });
+});
+
 describe("managed proxy integration — constants integrity", () => {
   test("anthropic, openai, and gemini have metadata with managed=true and a proxyPath", () => {
     for (const provider of ["anthropic", "openai", "gemini"]) {

package/src/__tests__/provider-send-message-override-profile.test.ts

@@ -28,6 +28,7 @@ mock.module("../config/loader.js", () => ({
 
 import { LLMSchema } from "../config/schemas/llm.js";
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
+import { CallSiteConfiguredProvider } from "../providers/provider-send-message.js";
 import { RetryProvider } from "../providers/retry.js";
 import type {
   Message,
@@ -59,6 +60,55 @@ beforeEach(() => {
 });
 
 describe("SendMessageOptions.config.overrideProfile", () => {
+  test("CallSiteConfiguredProvider injects the resolving call site when callers omit it", async () => {
+    let captured: SendMessageOptions | undefined;
+    const inner: Provider = {
+      name: "anthropic",
+      async sendMessage(
+        _messages: Message[],
+        _tools?: ToolDefinition[],
+        _systemPrompt?: string,
+        options?: SendMessageOptions,
+      ): Promise<ProviderResponse> {
+        captured = options;
+        return makeResponse("anthropic");
+      },
+    };
+
+    const provider = new CallSiteConfiguredProvider(inner, "mainAgent");
+    await provider.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { model: "claude-opus-4-7" },
+    });
+
+    expect(captured?.config).toMatchObject({
+      callSite: "mainAgent",
+      model: "claude-opus-4-7",
+    });
+  });
+
+  test("CallSiteConfiguredProvider preserves explicit per-call call sites", async () => {
+    let captured: SendMessageOptions | undefined;
+    const inner: Provider = {
+      name: "anthropic",
+      async sendMessage(
+        _messages: Message[],
+        _tools?: ToolDefinition[],
+        _systemPrompt?: string,
+        options?: SendMessageOptions,
+      ): Promise<ProviderResponse> {
+        captured = options;
+        return makeResponse("anthropic");
+      },
+    };
+
+    const provider = new CallSiteConfiguredProvider(inner, "mainAgent");
+    await provider.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "conversationTitle" },
+    });
+
+    expect(captured?.config?.callSite).toBe("conversationTitle");
+  });
+
   test("RetryProvider resolves model from named profile when overrideProfile is set", async () => {
     setLlmConfig({
       default: { provider: "anthropic", model: "claude-opus-4-7" },