@vellumai/assistant 0.8.4 → 0.8.5

package/src/providers/gemini/client.ts

@@ -1,7 +1,6 @@
 import type * as genai from "@google/genai";
-import { ApiError, GoogleGenAI } from "@google/genai";
+import { ApiError, GoogleGenAI, ThinkingLevel } from "@google/genai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
@@ -34,6 +33,47 @@ function isGemini3Model(model: string): boolean {
   return model.startsWith("gemini-3") || model.startsWith("models/gemini-3");
 }
 
+const THINKING_LEVEL_BY_NAME: Record<string, ThinkingLevel> = {
+  minimal: ThinkingLevel.MINIMAL,
+  low: ThinkingLevel.LOW,
+  medium: ThinkingLevel.MEDIUM,
+  high: ThinkingLevel.HIGH,
+};
+
+/**
+ * Translate the resolved wire-shape `thinking` config into Gemini's
+ * `thinkingConfig`. Returns `undefined` when no thinking config was supplied,
+ * which lets Google's per-model default apply (e.g. `gemini-3.5-flash`
+ * defaults to dynamic medium-level thinking).
+ *
+ * `enabled: false` maps to `thinkingLevel: MINIMAL` because Gemini 3.x cannot
+ * fully disable thinking — `"minimal"` is the floor. `includeThoughts` is
+ * gated on `streamThinking` so callers that opted out of streaming thoughts
+ * don't pay for thought tokens in the response.
+ */
+function buildThinkingConfig(
+  thinking: Record<string, unknown> | undefined,
+): genai.ThinkingConfig | undefined {
+  if (!thinking) return undefined;
+  if (thinking.type === "disabled") {
+    return {
+      thinkingLevel: ThinkingLevel.MINIMAL,
+      includeThoughts: false,
+    };
+  }
+  if (thinking.type !== "adaptive") return undefined;
+
+  const result: genai.ThinkingConfig = {};
+  if (typeof thinking.level === "string") {
+    const mapped = THINKING_LEVEL_BY_NAME[thinking.level];
+    if (mapped) result.thinkingLevel = mapped;
+  }
+  if (typeof thinking.streamThinking === "boolean") {
+    result.includeThoughts = thinking.streamThinking;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 function stripGeminiHttpOptions(
   config: genai.GenerateContentConfig,
 ): genai.GenerateContentConfig {
@@ -175,6 +215,9 @@ export class GeminiProvider implements Provider {
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
       | Record<string, string>
       | undefined;
+    const thinkingConfig = buildThinkingConfig(
+      configObj?.thinking as Record<string, unknown> | undefined,
+    );
     const activeModel = modelOverride ?? this.model;
 
     try {
@@ -183,14 +226,14 @@ export class GeminiProvider implements Provider {
       const geminiConfig: genai.GenerateContentConfig = {};
 
       if (systemPrompt) {
-        geminiConfig.systemInstruction = systemPrompt.replaceAll(
-          SYSTEM_PROMPT_CACHE_BOUNDARY,
-          "\n",
-        );
+        geminiConfig.systemInstruction = systemPrompt;
       }
       if (maxTokens) {
         geminiConfig.maxOutputTokens = maxTokens;
       }
+      if (thinkingConfig) {
+        geminiConfig.thinkingConfig = thinkingConfig;
+      }
       if (tools && tools.length > 0) {
         geminiConfig.tools = [
           {

package/src/providers/inference/adapter-factory.ts

@@ -21,6 +21,7 @@
 import { AnthropicProvider } from "../anthropic/client.js";
 import { FireworksProvider } from "../fireworks/client.js";
 import { GeminiProvider } from "../gemini/client.js";
+import { MinimaxProvider } from "../minimax/client.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { OllamaProvider } from "../ollama/client.js";
 import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
@@ -111,6 +112,8 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
+  minimax: ({ apiKey, model, streamTimeoutMs }) =>
+    new MinimaxProvider(apiKey, model, { streamTimeoutMs }),
 };
 
 /**

package/src/providers/minimax/client.ts

@@ -0,0 +1,106 @@
+import OpenAI from "openai";
+
+import { getLogger } from "../../util/logger.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+
+const log = getLogger("minimax-client");
+
+/** Validation-specific timeout (10s) so a stalled network doesn't block key submission. */
+const VALIDATION_TIMEOUT_MS = 10_000;
+
+export interface MinimaxProviderOptions {
+  apiKey?: string;
+  baseURL?: string;
+  streamTimeoutMs?: number;
+}
+
+const DEFAULT_MINIMAX_BASE_URL = "https://api.minimax.io/v1";
+const FALLBACK_MINIMAX_BASE_URL = "https://api.minimaxi.com/v1";
+
+/**
+ * Validate a MiniMax API key by testing against the default URL first,
+ * then the fallback URL if the default fails. Both URLs must fail with
+ * definitive errors (401/403) for the key to be rejected. Transient errors
+ * (429, 5xx, network) allow the key to be stored.
+ */
+export async function validateMinimaxApiKey(
+  apiKey: string,
+): Promise<{ valid: true } | { valid: false; reason: string }> {
+  // Try default URL first
+  const defaultResult = await tryValidate(apiKey, DEFAULT_MINIMAX_BASE_URL);
+  if (defaultResult.valid && !defaultResult.transient) {
+    return { valid: true };
+  }
+
+  // Default failed or was transient — try fallback URL
+  const fallbackResult = await tryValidate(apiKey, FALLBACK_MINIMAX_BASE_URL);
+  if (fallbackResult.valid) {
+    return { valid: true };
+  }
+
+  // Both URLs failed definitively — reject the key
+  return { valid: false, reason: fallbackResult.reason };
+}
+
+async function tryValidate(
+  apiKey: string,
+  baseURL: string,
+): Promise<
+  | { valid: true; transient: false }
+  | { valid: true; transient: true }
+  | { valid: false; reason: string }
+> {
+  try {
+    const client = new OpenAI({
+      apiKey,
+      baseURL,
+      timeout: VALIDATION_TIMEOUT_MS,
+      maxRetries: 0,
+    });
+    await client.models.list();
+    return { valid: true, transient: false };
+  } catch (error) {
+    if (error instanceof OpenAI.APIError) {
+      if (error.status === 401) {
+        return { valid: false, reason: "API key is invalid or expired." };
+      }
+      if (error.status === 403) {
+        return {
+          valid: false,
+          reason: `MiniMax API error (${error.status}): ${error.message}`,
+        };
+      }
+      // Transient errors (429, 5xx, etc.) — try the other URL
+      log.warn(
+        { status: error.status, baseURL },
+        "MiniMax API returned a transient error during key validation — trying fallback",
+      );
+      return { valid: true, transient: true };
+    }
+    // Network errors — try the other URL
+    log.warn(
+      {
+        error: error instanceof Error ? error.message : String(error),
+        baseURL,
+      },
+      "Network error during MiniMax key validation — trying fallback",
+    );
+    return { valid: true, transient: true };
+  }
+}
+
+export class MinimaxProvider extends OpenAIChatCompletionsProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: MinimaxProviderOptions = {},
+  ) {
+    const baseURL = options.baseURL?.trim() || DEFAULT_MINIMAX_BASE_URL;
+    super(apiKey, model, {
+      baseURL,
+      providerName: "minimax",
+      providerLabel: "MiniMax",
+      streamTimeoutMs: options.streamTimeoutMs,
+    });
+  }
+}

package/src/providers/model-catalog.ts

@@ -493,6 +493,21 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.025,
         },
       },
+      {
+        id: "gemini-3.1-flash-lite",
+        displayName: "Gemini 3.1 Flash-Lite",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.25,
+          outputPer1mTokens: 1.5,
+          cacheReadPer1mTokens: 0.025,
+        },
+      },
       {
         id: "gemini-2.5-flash",
         displayName: "Gemini 2.5 Flash",
@@ -1122,6 +1137,34 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     models: [],
     defaultModel: "",
   },
+  {
+    id: "minimax",
+    displayName: "MiniMax",
+    subtitle: "MiniMax AI models. Requires a MiniMax API key.",
+    setupMode: "api-key",
+    setupHint: "Enter your MiniMax API key to enable MiniMax models.",
+    envVar: "MINIMAX_API_KEY",
+    credentialsGuide: {
+      description: "Sign in to the MiniMax dashboard and create an API key.",
+      url: "https://platform.minimax.io/",
+      linkLabel: "Open MiniMax Dashboard",
+    },
+    models: [
+      {
+        id: "MiniMax-M2.7",
+        displayName: "MiniMax M2.7",
+        contextWindowTokens: 200000,
+        maxOutputTokens: 16384,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+      },
+    ],
+    defaultModel: "MiniMax-M2.7",
+    apiKeyUrl: "https://platform.minimax.io/",
+    apiKeyPlaceholder: "sk-cp-...",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =

package/src/providers/model-intents.ts

@@ -24,7 +24,7 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   gemini: {
     balanced: "gemini-3-flash-preview",
-    "latency-optimized": "gemini-3.1-flash-lite-preview",
+    "latency-optimized": "gemini-3.1-flash-lite",
     "quality-optimized": "gemini-3.1-pro-preview",
     "vision-optimized": "gemini-3-flash-preview",
   },

package/src/providers/openai/chat-completions-provider.ts

@@ -1,6 +1,5 @@
 import OpenAI from "openai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
@@ -155,12 +154,16 @@ export class OpenAIChatCompletionsProvider implements Provider {
   ) {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    // Keep the SDK deadline behind our provider stream timeout so
+    // createStreamTimeout owns the user-facing timeout error.
+    const sdkTimeoutMs = this.streamTimeoutMs + 60_000;
     this.client = new OpenAI({
       apiKey,
       baseURL: options.baseURL,
+      timeout: sdkTimeoutMs,
     });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.extraCreateParams = options.extraCreateParams ?? {};
     this.maxReasoningEffort = options.maxReasoningEffort ?? "xhigh";
     this.requestHeaders = options.requestHeaders ?? {};
@@ -593,7 +596,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     if (systemPrompt) {
       result.push({
         role: "system",
-        content: systemPrompt.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n"),
+        content: systemPrompt,
       });
     }
 

package/src/providers/openai/codex-models.ts

@@ -0,0 +1,18 @@
+/**
+ * Model IDs accepted by the ChatGPT Codex subscription endpoint
+ * (`https://chatgpt.com/backend-api/codex`).
+ *
+ * `oauth_subscription` OpenAI connections hard-route every request to that
+ * endpoint, which rejects any model outside this set with HTTP 400. The set
+ * gates whether such a connection may serve a given model during auto-
+ * resolution of an "Any active OpenAI connection" profile.
+ */
+export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
+  "gpt-5.4",
+  "gpt-5.3-codex",
+]);
+
+/** True when `model` is accepted by the Codex subscription endpoint. */
+export function isCodexSubscriptionModel(model: string): boolean {
+  return CODEX_SUBSCRIPTION_MODEL_IDS.has(model);
+}

package/src/providers/openai/responses-provider.ts

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
 
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../../prompts/cache-boundary.js";
 import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError } from "../../util/errors.js";
+import { getLogger } from "../../util/logger.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
 import { escapeXmlAttr } from "../../util/xml.js";
 import { createStreamTimeout } from "../stream-timeout.js";
@@ -17,6 +17,8 @@ import type {
 import { ContextOverflowError } from "../types.js";
 import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
 
+const log = getLogger("openai-responses");
+
 export interface OpenAIResponsesProviderOptions {
   baseURL?: string;
   providerName?: string;
@@ -24,7 +26,7 @@ export interface OpenAIResponsesProviderOptions {
   streamTimeoutMs?: number;
   useNativeWebSearch?: boolean;
   /** When true, target the Codex subscription endpoint and strip fields it
-   *  rejects (`max_output_tokens`, `metadata`). */
+   *  rejects (`max_output_tokens`, `reasoning`, `text`, `tools`). */
   codexSubscription?: boolean;
 }
 
@@ -107,6 +109,7 @@ export class OpenAIResponsesProvider implements Provider {
   private streamTimeoutMs: number;
   private useNativeWebSearch: boolean;
   private codexSubscription: boolean;
+  private lastCodexErrorBody: string | undefined;
 
   constructor(
     apiKey: string,
@@ -116,14 +119,39 @@ export class OpenAIResponsesProvider implements Provider {
     this.name = options.providerName ?? "openai";
     this.providerLabel = options.providerLabel ?? "OpenAI";
     this.codexSubscription = options.codexSubscription ?? false;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    // Keep the SDK deadline behind our provider stream timeout so
+    // createStreamTimeout owns the user-facing timeout error.
+    const sdkTimeoutMs = this.streamTimeoutMs + 60_000;
     this.client = new OpenAI({
       apiKey,
       baseURL: this.codexSubscription
         ? "https://chatgpt.com/backend-api/codex"
         : options.baseURL,
+      timeout: sdkTimeoutMs,
+      ...(this.codexSubscription
+        ? {
+            fetch: async (url: RequestInfo | URL, init?: RequestInit) => {
+              const res = await globalThis.fetch(url, init);
+              if (!res.ok) {
+                const body = await res.text();
+                this.lastCodexErrorBody = body;
+                log.warn(
+                  { status: res.status, body, url: String(url) },
+                  "Codex endpoint raw error response",
+                );
+                return new Response(body, {
+                  status: res.status,
+                  statusText: res.statusText,
+                  headers: res.headers,
+                });
+              }
+              return res;
+            },
+          }
+        : {}),
     });
     this.model = model;
-    this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
@@ -149,35 +177,35 @@ export class OpenAIResponsesProvider implements Provider {
       const params: Record<string, unknown> = {
         model: modelOverride ?? this.model,
         input,
+        ...(this.codexSubscription ? { store: false } : {}),
       };
 
       if (systemPrompt) {
-        params.instructions = systemPrompt.replaceAll(
-          SYSTEM_PROMPT_CACHE_BOUNDARY,
-          "\n",
-        );
+        params.instructions = systemPrompt;
       }
 
       if (maxTokens && !this.codexSubscription) {
         params.max_output_tokens = maxTokens;
       }
 
-      const reasoningEffort = effort
-        ? EFFORT_TO_REASONING_EFFORT[effort]
-        : undefined;
-      if (reasoningEffort) {
-        params.reasoning = { effort: reasoningEffort };
-      }
+      if (!this.codexSubscription) {
+        const reasoningEffort = effort
+          ? EFFORT_TO_REASONING_EFFORT[effort]
+          : undefined;
+        if (reasoningEffort) {
+          params.reasoning = { effort: reasoningEffort };
+        }
 
-      if (
-        verbosity &&
-        VALID_VERBOSITIES.has(verbosity) &&
-        modelSupportsVerbosity(modelOverride ?? this.model)
-      ) {
-        params.text = { verbosity };
+        if (
+          verbosity &&
+          VALID_VERBOSITIES.has(verbosity) &&
+          modelSupportsVerbosity(modelOverride ?? this.model)
+        ) {
+          params.text = { verbosity };
+        }
       }
 
-      if (tools && tools.length > 0) {
+      if (tools && tools.length > 0 && !this.codexSubscription) {
         if (
           this.useNativeWebSearch &&
           tools.some((t) => t.name === "web_search")
@@ -410,6 +438,21 @@ export class OpenAIResponsesProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
+        // Temporary diagnostic: log the raw error shape for Codex 400 debugging
+        if (this.codexSubscription) {
+          log.warn(
+            {
+              status: error.status,
+              message: error.message,
+              code: error.code,
+              type: error.type,
+              param: error.param,
+              errorBody: error.error,
+              headers: Object.fromEntries(error.headers?.entries?.() ?? []),
+            },
+            "Codex subscription API error — raw details",
+          );
+        }
         const overflow = detectOpenAICompatibleContextOverflow(error);
         if (overflow) {
           throw new ContextOverflowError(
@@ -431,8 +474,22 @@ export class OpenAIResponsesProvider implements Provider {
         if (retryAfterMs !== undefined)
           errorOptions.retryAfterMs = retryAfterMs;
         if (abortReason) errorOptions.abortReason = abortReason;
+        let errorDetail = error.message;
+        if (this.lastCodexErrorBody) {
+          try {
+            const parsed = JSON.parse(this.lastCodexErrorBody);
+            if (parsed.detail) errorDetail = parsed.detail;
+          } catch {
+            errorDetail = this.lastCodexErrorBody.slice(0, 200);
+          }
+          this.lastCodexErrorBody = undefined;
+        }
+        const extras = [error.code, error.type, error.param]
+          .filter(Boolean)
+          .join(", ");
+        const extraSuffix = extras ? ` [${extras}]` : "";
         throw new ProviderError(
-          `${this.providerLabel} API error (${error.status}): ${error.message}`,
+          `${this.providerLabel} API error (${error.status}): ${errorDetail}${extraSuffix}`,
           this.name,
           error.status,
           Object.keys(errorOptions).length > 0 ? errorOptions : undefined,

package/src/providers/provider-send-message.ts

@@ -9,6 +9,7 @@ import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
+import { isConnectionCompatibleWithModel } from "./connection-model-compat.js";
 import { tryResolveProviderForConnectionName } from "./connection-resolution.js";
 import { listConnections } from "./inference/connections.js";
 import { initializeProviders, listProviders } from "./registry.js";
@@ -126,7 +127,11 @@ export async function resolveConfiguredProvider(
         const candidates = listConnections(getDb(), {
           provider: inferenceProvider,
         });
-        const active = candidates.find((c) => c.status === "active");
+        const active = candidates.find(
+          (c) =>
+            c.status === "active" &&
+            isConnectionCompatibleWithModel(c, resolved.model),
+        );
         if (active) {
           connectionName = active.name;
         }
@@ -147,6 +152,7 @@ export async function resolveConfiguredProvider(
     connectionName,
     config,
     inferenceProvider,
+    resolved.model,
   );
   if (!connectionProvider) {
     // Soft credential failure — the connection resolved to no usable

package/src/providers/retry.ts

@@ -47,9 +47,18 @@ const EFFORT_SUPPORTED_PROVIDERS = new Set([
 /**
  * Providers that consume the `thinking` config. Anthropic uses it directly on
  * the wire; OpenRouter either forwards it to its Anthropic-compatible path or
- * translates it into the unified `reasoning` parameter on OpenAI-compat calls.
+ * translates it into the unified `reasoning` parameter on OpenAI-compat calls;
+ * Gemini reads `thinking.level` to populate `thinkingConfig.thinkingLevel`.
  */
-const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter"]);
+const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter", "gemini"]);
+
+/**
+ * Providers that consume Gemini-only thinking extras (`level`,
+ * `streamThinking`). For other thinking-aware providers, we scrub these from
+ * the normalized wire payload because Anthropic's SDK rejects unknown keys
+ * inside the `thinking` object with "Extra inputs are not permitted".
+ */
+const THINKING_EXTRA_FIELDS_AWARE_PROVIDERS = new Set(["gemini"]);
 
 /**
  * Providers that consume the `verbosity` config. Currently OpenAI (mapped to
@@ -289,7 +298,8 @@ function normalizeSendMessageOptions(
   }
 
   // thinking is Anthropic-specific on the wire; OpenRouter reads it as a
-  // signal for its unified reasoning parameter. Strip it for other providers.
+  // signal for its unified reasoning parameter; Gemini reads `level` from it.
+  // Strip it for other providers.
   if (
     !THINKING_AWARE_PROVIDERS.has(providerName) &&
     nextConfig.thinking !== undefined
@@ -297,6 +307,27 @@ function normalizeSendMessageOptions(
     delete nextConfig.thinking;
   }
 
+  // Strip Gemini-only extras (`level`, `streamThinking`) from the wire
+  // `thinking` object for providers that don't read them. Anthropic in
+  // particular rejects unknown keys inside `thinking` with "Extra inputs are
+  // not permitted"; the OpenRouter Anthropic-compat path hits the same SDK.
+  if (
+    nextConfig.thinking !== undefined &&
+    !THINKING_EXTRA_FIELDS_AWARE_PROVIDERS.has(providerName) &&
+    typeof nextConfig.thinking === "object" &&
+    nextConfig.thinking !== null
+  ) {
+    const wire = nextConfig.thinking as Record<string, unknown>;
+    if (wire.level !== undefined || wire.streamThinking !== undefined) {
+      const scrubbed: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(wire)) {
+        if (key === "level" || key === "streamThinking") continue;
+        scrubbed[key] = value;
+      }
+      nextConfig.thinking = scrubbed;
+    }
+  }
+
   // Anthropic (and OpenRouter fronting Anthropic) rejects requests that
   // combine extended thinking with forced tool use (`tool_choice.type` of
   // `"tool"` or `"any"`).  Strip thinking when both are present so the

package/src/providers/thinking-config.ts

@@ -1,20 +1,45 @@
+import { THINKING_LEVELS, type ThinkingLevel } from "../config/schemas/llm.js";
+
 type ThinkingConfigRecord = Record<string, unknown>;
 
+const THINKING_LEVEL_SET: ReadonlySet<string> = new Set(THINKING_LEVELS);
+
 function isRecord(value: unknown): value is ThinkingConfigRecord {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function pickGeminiExtras(thinking: ThinkingConfigRecord): {
+  level?: ThinkingLevel;
+  streamThinking?: boolean;
+} {
+  const extras: { level?: ThinkingLevel; streamThinking?: boolean } = {};
+  if (
+    typeof thinking.level === "string" &&
+    THINKING_LEVEL_SET.has(thinking.level)
+  ) {
+    extras.level = thinking.level as ThinkingLevel;
+  }
+  if (typeof thinking.streamThinking === "boolean") {
+    extras.streamThinking = thinking.streamThinking;
+  }
+  return extras;
+}
+
 export function normalizeThinkingConfigForWire(
   thinking: unknown,
 ): ThinkingConfigRecord | undefined {
   if (!isRecord(thinking)) return undefined;
 
+  // Already in wire shape — preserve as-is so re-normalization is idempotent
+  // and Gemini-only fields stay attached for the Gemini provider to read.
   if (typeof thinking.type === "string") {
     return thinking;
   }
 
+  const extras = pickGeminiExtras(thinking);
+
   if (thinking.enabled === true) {
-    return { type: "adaptive" };
+    return { type: "adaptive", ...extras };
   }
 
   if (thinking.enabled === false) {

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/agent-wake.ts

@@ -640,6 +640,7 @@ export async function wakeAgentForOpportunity(
           JSON.stringify(record.rawResponse),
           undefined,
           record.provider,
+          "mainAgent",
         );
       } catch (err) {
         log.warn(