@vellumai/assistant 0.8.4 → 0.8.5

package/src/__tests__/llm-request-log-source-clickhouse.test.ts

@@ -84,6 +84,7 @@ const SAMPLE_ROW = {
   // ClickHouse emits Int64 as a quoted string under JSONEachRow by default.
   created_at: "1778465138786",
   agent_loop_exit_reason: "no_tool_calls",
+  call_site: "mainAgent",
 };
 
 describe("ClickHouseLlmRequestLogSource", () => {
@@ -104,6 +105,7 @@ describe("ClickHouseLlmRequestLogSource", () => {
       responsePayload: '{"bar":2}',
       createdAt: 1778465138786,
       agentLoopExitReason: "no_tool_calls",
+      callSite: "mainAgent",
     });
   });
 
@@ -164,6 +166,30 @@ describe("ClickHouseLlmRequestLogSource", () => {
     expect(rows).toEqual([]);
   });
 
+  test("getRequestLogsByConversationId binds conversation id via parameterized placeholder", async () => {
+    // Regression guard: the conversation id flows from user-controlled
+    // input (conversationKey → conversations.id), so it must travel as a
+    // typed parameter, never as an inline string literal.
+    const recorder: FakeFetchCall[] = [];
+    const malicious = "conv-1' OR 1=1 --";
+    const src = makeSource({
+      body: JSON.stringify(SAMPLE_ROW) + "\n",
+      recorder,
+    });
+    const rows = await src.getRequestLogsByConversationId(malicious);
+    expect(rows).toHaveLength(1);
+    expect(recorder).toHaveLength(1);
+    const call = recorder[0]!;
+    const parsed = new URL(call.url);
+    expect(parsed.searchParams.get("param_assistant_id")).toBe(
+      "asst-fixture-001",
+    );
+    expect(parsed.searchParams.get("param_conversation_id")).toBe(malicious);
+    const body = String(call.init?.body ?? "");
+    expect(body).toContain("conversation_id = {conversation_id:String}");
+    expect(body).not.toContain(`'${malicious}'`);
+  });
+
   test("getRequestLogsByMessageId binds message ids via parameterized placeholders", async () => {
     // Regression for ATL-537. `getAssistantMessageIdsInTurn` returns the
     // caller-supplied id straight through when the message lookup misses,

package/src/__tests__/llm-resolver.test.ts

@@ -2,7 +2,10 @@ import { describe, expect, test } from "bun:test";
 
 import { z } from "zod";
 
-import { resolveCallSiteConfig, resolveDefaultProfileKey } from "../config/llm-resolver.js";
+import {
+  resolveCallSiteConfig,
+  resolveDefaultProfileKey,
+} from "../config/llm-resolver.js";
 import { type LLMCallSite, LLMSchema } from "../config/schemas/llm.js";
 
 const fullDefault = {
@@ -690,13 +693,28 @@ describe("resolveCallSiteConfig", () => {
     });
 
     const callSites: LLMCallSite[] = [
-      "mainAgent", "subagentSpawn", "heartbeatAgent", "filingAgent",
-      "compactionAgent", "analyzeConversation", "callAgent",
-      "memoryExtraction", "memoryConsolidation", "memoryRetrieval",
-      "memoryRouter", "recall", "conversationSummarization",
-      "commitMessage", "conversationStarters", "replySuggestion",
-      "conversationTitle", "identityIntro", "emptyStateGreeting",
-      "notificationDecision", "interactionClassifier", "inference",
+      "mainAgent",
+      "subagentSpawn",
+      "heartbeatAgent",
+      "filingAgent",
+      "compactionAgent",
+      "analyzeConversation",
+      "callAgent",
+      "memoryExtraction",
+      "memoryConsolidation",
+      "memoryRetrieval",
+      "memoryRouter",
+      "recall",
+      "conversationSummarization",
+      "commitMessage",
+      "conversationStarters",
+      "replySuggestion",
+      "conversationTitle",
+      "identityIntro",
+      "emptyStateGreeting",
+      "notificationDecision",
+      "interactionClassifier",
+      "inference",
     ];
 
     for (const cs of callSites) {
@@ -778,7 +796,10 @@ describe("resolveCallSiteConfig", () => {
         provider_connection: "anthropic-managed",
       },
       profiles: {
-        fireworks: { provider: "fireworks", model: "accounts/fireworks/models/kimi-k2p5" },
+        fireworks: {
+          provider: "fireworks",
+          model: "accounts/fireworks/models/kimi-k2p5",
+        },
       },
       activeProfile: "fireworks",
     });
@@ -874,3 +895,50 @@ describe("resolveDefaultProfileKey", () => {
     );
   });
 });
+
+describe("memory v3 call sites resolve through the standard resolver", () => {
+  const llm = LLMSchema.parse({
+    default: fullDefault,
+    profiles: {
+      balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      "cost-optimized": {
+        provider: "anthropic",
+        model: "claude-haiku-4-5-20251001",
+      },
+    },
+  });
+
+  test("memoryV3Filter and memoryV3Descent resolve to the cost-optimized profile", () => {
+    expect(resolveDefaultProfileKey("memoryV3Filter", llm)).toBe(
+      "cost-optimized",
+    );
+    expect(resolveDefaultProfileKey("memoryV3Descent", llm)).toBe(
+      "cost-optimized",
+    );
+    expect(resolveCallSiteConfig("memoryV3Filter", llm).model).toBe(
+      "claude-haiku-4-5-20251001",
+    );
+    expect(resolveCallSiteConfig("memoryV3Descent", llm).model).toBe(
+      "claude-haiku-4-5-20251001",
+    );
+  });
+
+  test("memoryV3Gate resolves to the balanced (capable) profile", () => {
+    expect(resolveDefaultProfileKey("memoryV3Gate", llm)).toBe("balanced");
+    expect(resolveCallSiteConfig("memoryV3Gate", llm).model).toBe(
+      "claude-sonnet-4-7",
+    );
+  });
+
+  test("v3 call sites are addressable as call-site override keys", () => {
+    const overridden = LLMSchema.parse({
+      default: fullDefault,
+      callSites: {
+        memoryV3Gate: { model: "claude-opus-4-7" },
+      },
+    });
+    expect(resolveCallSiteConfig("memoryV3Gate", overridden).model).toBe(
+      "claude-opus-4-7",
+    );
+  });
+});

package/src/__tests__/llm-usage-store.test.ts

@@ -31,6 +31,7 @@ function makeInput(overrides?: Partial<UsageEventInput>): UsageEventInput {
     outputTokens: 500,
     cacheCreationInputTokens: null,
     cacheReadInputTokens: null,
+    rawUsage: null,
     actor: "main_agent",
     conversationId: null,
     runId: null,
@@ -217,6 +218,44 @@ describe("recordUsageEvent", () => {
     expect(events[0].cacheCreationInputTokens).toBe(200);
     expect(events[0].cacheReadInputTokens).toBe(300);
   });
+
+  test("round-trips the provider's raw_usage payload verbatim", () => {
+    // The `raw_usage` column carries the literal usage object the provider
+    // returned (Anthropic nests TTL breakdown under `cache_creation`,
+    // OpenAI nests cached-read details under `prompt_tokens_details`, etc.)
+    // It must round-trip from `recordUsageEvent` through SQLite back to
+    // `listUsageEvents` byte-for-byte so downstream consumers can extract
+    // any provider-specific detail without a schema change.
+    const rawUsage = {
+      input_tokens: 1000,
+      output_tokens: 500,
+      cache_creation_input_tokens: 500,
+      cache_creation: {
+        ephemeral_5m_input_tokens: 100,
+        ephemeral_1h_input_tokens: 400,
+      },
+      cache_read_input_tokens: 0,
+      service_tier: "standard",
+    };
+    recordUsageEvent(makeInput({ rawUsage }), pricedResult);
+
+    const [event] = listUsageEvents();
+    expect(event.rawUsage).toEqual(rawUsage);
+  });
+
+  test("raw_usage defaults to null when the provider did not return one", () => {
+    // Providers that don't surface a usage block (or daemons predating
+    // migration 260) write null. Coercing to `{}` would be
+    // indistinguishable from a usage block that genuinely has no fields,
+    // so we preserve null as the "absent" signal.
+    recordUsageEvent(
+      makeInput({ provider: "openai", model: "gpt-4o", rawUsage: null }),
+      pricedResult,
+    );
+
+    const [event] = listUsageEvents();
+    expect(event.rawUsage).toBeNull();
+  });
 });
 
 describe("listUsageEvents", () => {
@@ -1391,4 +1430,31 @@ describe("queryUnreportedUsageEvents", () => {
     // Analytics can treat 0 as "pre-first-turn" if needed.
     expect(events[0].turnIndex).toBe(0);
   });
+
+  test("surfaces raw_usage on unreported events", () => {
+    // The telemetry reporter consumes `queryUnreportedUsageEvents` output
+    // directly and forwards it to BigQuery. If the SELECT projection
+    // drops the `raw_usage` column, every provider-specific detail
+    // (Anthropic TTL breakdown, OpenAI prompt-token details, etc.)
+    // vanishes silently — covered here so a refactor of the projection
+    // can't regress the wire shape.
+    const rawUsage = {
+      input_tokens: 1500,
+      output_tokens: 600,
+      cache_creation_input_tokens: 800,
+      cache_creation: {
+        ephemeral_5m_input_tokens: 300,
+        ephemeral_1h_input_tokens: 500,
+      },
+    };
+    insertEventAt(1000, {
+      cacheCreationInputTokens: 800,
+      rawUsage,
+    });
+
+    const events = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(events).toHaveLength(1);
+    expect(events[0].cacheCreationInputTokens).toBe(800);
+    expect(events[0].rawUsage).toEqual(rawUsage);
+  });
 });

package/src/__tests__/logger.test.ts

@@ -0,0 +1,89 @@
+import { mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, describe, expect, test } from "bun:test";
+
+import { getLogger, initLogger, LOG_FILE_PATTERN } from "../util/logger.js";
+
+// ---------------------------------------------------------------------------
+// Test rationale
+// ---------------------------------------------------------------------------
+//
+// `getLogger()` returns a Proxy that lazily creates a pino child against the
+// current rootLogger. Before this PR's refactor, the child was cached on
+// first access and never re-evaluated — which meant that across:
+//
+//   1. day rollover (ensureCurrentDate rebuilds rootLogger past UTC midnight),
+//   2. or a late `initLogger()` call (which swaps the rootLogger),
+//
+// previously-cached children kept writing to the OLD root's destination
+// forever — silently misrouting logs into the wrong daily file.
+//
+// These tests pin the new contract: when the rootLogger changes, the proxy's
+// next access rebuilds the child against the new root.
+//
+// We assert via file-system side effects (logs appearing in the expected
+// directory). pino's `sync: false` default makes the fd open asynchronous,
+// so we wait a tick before reading.
+//
+// NB: the file-creating fallback path itself is gated behind a BUN_TEST=1
+// stderr fast-path in `getRootLogger()` (so test output stays sensible), so
+// these tests exercise the rebind via `initLogger()` calls instead. The
+// "no vellum.log" property is covered by `platform.test.ts` (asserts
+// `getLogsDir()` returns the directory) and by the mechanical guarantee that
+// `buildRotatingLogger` derives filenames via `logFilePathForDate`.
+
+const SLEEP_MS = 100;
+
+const dirA = mkdtempSync(join(tmpdir(), "logger-rebind-A-"));
+const dirB = mkdtempSync(join(tmpdir(), "logger-rebind-B-"));
+
+afterAll(() => {
+  // Detach the module-level rootLogger from the temp dirs we're about to
+  // delete. Without this, a later flush (or the test runner's shutdown)
+  // could try to write into a removed directory.
+  initLogger({ dir: undefined, retentionDays: 0 });
+  rmSync(dirA, { recursive: true, force: true });
+  rmSync(dirB, { recursive: true, force: true });
+});
+
+describe("getLogger() proxy rebind", () => {
+  test("a proxy created BEFORE initLogger() still routes to the post-init root", async () => {
+    // Create the proxy before initLogger has run. This mirrors the real
+    // lifecycle.ts pattern: modules call `getLogger()` at import time, long
+    // before `initLogger()` boots in daemon startup.
+    const log = getLogger("early-binding");
+
+    initLogger({ dir: dirA, retentionDays: 0 });
+
+    log.info("first — should land in dirA");
+
+    await Bun.sleep(SLEEP_MS);
+
+    const aFiles = readdirSync(dirA);
+    expect(aFiles.some((f) => LOG_FILE_PATTERN.test(f))).toBe(true);
+  });
+
+  test("subsequent log calls follow rootLogger swaps from initLogger()", async () => {
+    // rootLogger is currently bound to dirA from the previous test. Reuse
+    // an existing proxy and verify it follows the swap.
+    const log = getLogger("rebind-target");
+    log.info("warm-up against dirA so the child is cached");
+
+    await Bun.sleep(SLEEP_MS);
+
+    // Swap the rootLogger to a different directory.
+    initLogger({ dir: dirB, retentionDays: 0 });
+
+    log.info("post-swap — should land in dirB if the proxy rebound");
+
+    await Bun.sleep(SLEEP_MS);
+
+    // If the proxy correctly re-evaluates getRootLogger() on each access,
+    // the second log call hits the dirB root and dirB gets a daily log
+    // file. If the proxy were still caching the original child against the
+    // dirA root, dirB would stay empty.
+    const bFiles = readdirSync(dirB);
+    expect(bFiles.some((f) => LOG_FILE_PATTERN.test(f))).toBe(true);
+  });
+});

package/src/__tests__/mcp-abort-signal.test.ts

@@ -142,7 +142,7 @@ describe("MCP AbortSignal threading", () => {
       );
 
       expect(tool.name).toBe("mcp__test-server__my-tool");
-      expect(tool.getDefinition().name).toBe("mcp__test-server__my-tool");
+      expect(tool.name).toBe("mcp__test-server__my-tool");
     });
 
     test("keeps MCP tool names with trailing whitespace distinct", () => {
@@ -211,7 +211,7 @@ describe("MCP AbortSignal threading", () => {
       expect(tool.name.startsWith("mcp__stripe_link-cli__create_link__")).toBe(
         true,
       );
-      expect(tool.getDefinition().name).toBe(tool.name);
+      expect(tool.name).toBe(tool.name);
 
       await tool.execute(
         { someArg: "value" },

package/src/__tests__/media-generate-image.test.ts

@@ -321,6 +321,9 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock Gemini error: API failure");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
   });
 
   test("openai generation error uses OpenAI-specific mapping", async () => {
@@ -331,6 +334,34 @@ describe("image-studio skill script wrapper", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Mock OpenAI error: openai failure");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
+  });
+
+  test("missing credentials error includes guidance not to change service config", async () => {
+    mockGeminiKey = undefined;
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("No Gemini API key");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
+  });
+
+  test("managed mode credential error includes guidance not to change service config", async () => {
+    mockImageGenMode = "managed";
+    mockManagedBaseUrl = undefined;
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Managed proxy is not available");
+    expect(result.content).toContain(
+      "Do not change service configuration (mode, provider, or model) to try to fix it",
+    );
   });
 
   test("reads source images from file paths on disk", async () => {

package/src/__tests__/memory-v2-static-injector.test.ts

@@ -4,9 +4,9 @@
  * Covers:
  *   - Returns null when `memoryV2Static` is missing/empty.
  *   - Returns null when `mode === "minimal"`.
- *   - Wraps content in `<memory>...</memory>` and uses
+ *   - Wraps content in `<info>...</info>` and uses
  *     `after-memory-prefix` placement.
- *   - Escapes any `</memory>` substring inside the authored content so the
+ *   - Escapes any `</info>` substring inside the authored content so the
  *     wrapper cannot be broken out of.
  *
  * Hermetic: drives the injector's `produce()` directly with a synthesized
@@ -66,7 +66,7 @@ describe("memory-v2-static injector", () => {
     expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
   });
 
-  test("wraps content in <memory>...</memory> with after-memory-prefix placement", async () => {
+  test("wraps content in <info>...</info> with after-memory-prefix placement", async () => {
     const content =
       "## Essentials\n\nAlice prefers VS Code.\n\n## Threads\n\nOpen: ship PR.";
     const ctx = makeContext({
@@ -77,11 +77,11 @@ describe("memory-v2-static injector", () => {
     expect(block).not.toBeNull();
     expect(block!.id).toBe("memory-v2-static");
     expect(block!.placement).toBe("after-memory-prefix");
-    expect(block!.text).toBe(`<memory>\n${content}\n</memory>`);
+    expect(block!.text).toBe(`<info>\n${content}\n</info>`);
   });
 
-  test("escapes inner </memory> closing tags so the wrapper cannot be broken out of", async () => {
-    const content = "## Essentials\n\nText with </memory> embedded.";
+  test("escapes inner </info> closing tags so the wrapper cannot be broken out of", async () => {
+    const content = "## Essentials\n\nText with </info> embedded.";
     const ctx = makeContext({
       injectionInputs: { memoryV2Static: content },
     });
@@ -89,7 +89,7 @@ describe("memory-v2-static injector", () => {
     const block = await memoryV2StaticInjector.produce(ctx);
     expect(block).not.toBeNull();
     expect(block!.text).toBe(
-      "<memory>\n## Essentials\n\nText with &lt;/memory&gt; embedded.\n</memory>",
+      "<info>\n## Essentials\n\nText with &lt;/info&gt; embedded.\n</info>",
     );
   });
 });

package/src/__tests__/model-intents.test.ts

@@ -29,7 +29,7 @@ describe("model intents", () => {
       "gpt-5.4-nano",
     );
     expect(resolveModelIntent("gemini", "latency-optimized")).toBe(
-      "gemini-3.1-flash-lite-preview",
+      "gemini-3.1-flash-lite",
     );
     expect(resolveModelIntent("gemini", "quality-optimized")).toBe(
       "gemini-3.1-pro-preview",
@@ -44,9 +44,7 @@ describe("model intents", () => {
   });
 
   test("falls back to provider default for unknown providers", () => {
-    expect(getProviderDefaultModel("unknown-provider")).toBe(
-      "claude-opus-4-7",
-    );
+    expect(getProviderDefaultModel("unknown-provider")).toBe("claude-opus-4-7");
     expect(resolveModelIntent("unknown-provider", "quality-optimized")).toBe(
       "claude-opus-4-7",
     );

package/src/__tests__/notification-guardian-path.test.ts

@@ -66,7 +66,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     }
     return mockEmitResult;
   },
-  registerBroadcastFn: () => {},
 }));
 
 import {

package/src/__tests__/onboarding-template-contract.test.ts

@@ -44,7 +44,7 @@ describe("onboarding template contracts", () => {
     test("instructs saving to IDENTITY.md, SOUL.md, and user persona file via file_edit", () => {
       expect(bootstrap).toContain("IDENTITY.md");
       expect(bootstrap).toContain("SOUL.md");
-      expect(bootstrap).toContain("{{USER_PERSONA_FILE}}");
+      expect(bootstrap).toContain("{{userSlug}}.md");
       expect(bootstrap).toContain("file_edit");
     });
 

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

@@ -56,6 +56,7 @@ let lastCreateParams: Record<string, unknown> | null = null;
 let lastCreateOptions: Record<string, unknown> | null = null;
 let lastConstructorOptions: Record<string, unknown> | null = null;
 let shouldThrow: Error | null = null;
+const DEFAULT_SDK_TIMEOUT_MS = 1_860_000;
 
 function userMsg(text: string): Message {
   return { role: "user", content: [{ type: "text", text }] };
@@ -102,6 +103,7 @@ mock.module("openai", () => ({
 
 // Import after mocking
 import { FireworksProvider } from "../providers/fireworks/client.js";
+import { MinimaxProvider } from "../providers/minimax/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
 import { OpenAIChatCompletionsProvider } from "../providers/openai/chat-completions-provider.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
@@ -307,6 +309,7 @@ describe("OpenAIProvider", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-local",
       baseURL: "http://127.0.0.1:11434/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -319,6 +322,7 @@ describe("OpenAIProvider", () => {
       expect(lastConstructorOptions).toEqual({
         apiKey: "ollama",
         baseURL: "http://127.0.0.1:11434/v1",
+        timeout: DEFAULT_SDK_TIMEOUT_MS,
       });
     } finally {
       if (previousBaseUrl !== undefined) {
@@ -338,6 +342,7 @@ describe("OpenAIProvider", () => {
       expect(lastConstructorOptions).toEqual({
         apiKey: "ollama",
         baseURL: "http://127.0.0.1:11434/v1",
+        timeout: DEFAULT_SDK_TIMEOUT_MS,
       });
     } finally {
       if (previousBaseUrl !== undefined) {
@@ -1280,6 +1285,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/openai",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1289,6 +1295,19 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-user-key",
       baseURL: undefined,
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("OpenAIProvider passes configured stream timeout plus buffer to SDK", () => {
+    new OpenAIProvider("sk-user-key", "gpt-4o", {
+      streamTimeoutMs: 300_000,
+    });
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "sk-user-key",
+      baseURL: undefined,
+      timeout: 360_000,
     });
   });
 
@@ -1305,6 +1324,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/fireworks",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1317,6 +1337,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "fw-user-key",
       baseURL: "https://api.fireworks.ai/inference/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1329,6 +1350,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1338,6 +1360,30 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "or-user-key",
       baseURL: "https://openrouter.ai/api/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("MinimaxProvider forwards a custom baseURL", () => {
+    const managed = new MinimaxProvider("ast-key-123", "MiniMax-M2.7", {
+      baseURL: "https://platform.example.com/v1/runtime-proxy/minimax",
+    });
+
+    expect(managed.name).toBe("minimax");
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "ast-key-123",
+      baseURL: "https://platform.example.com/v1/runtime-proxy/minimax",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("MinimaxProvider without custom baseURL uses default MiniMax URL", () => {
+    new MinimaxProvider("mm-user-key", "MiniMax-M2.7");
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "mm-user-key",
+      baseURL: "https://api.minimax.io/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 });