@vellumai/assistant 0.9.0 → 0.10.0-dev.202606192226.8ed8a6a

package/src/providers/model-catalog.ts

@@ -677,6 +677,23 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.16,
         },
       },
+      {
+        id: "accounts/fireworks/models/glm-5p2",
+        displayName: "GLM 5.2",
+        // Fireworks serves GLM 5.2 with a 1,040K input window.
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        maxEffort: "max",
+        pricing: {
+          inputPer1mTokens: 1.4,
+          outputPer1mTokens: 4.4,
+          cacheReadPer1mTokens: 0.26,
+        },
+      },
       {
         id: "accounts/fireworks/models/kimi-k2p5",
         displayName: "Kimi K2.5",
@@ -1148,6 +1165,18 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         supportsToolUse: false,
         pricing: { inputPer1mTokens: 0.2, outputPer1mTokens: 1.1 },
       },
+      // Z.ai
+      {
+        id: "z-ai/glm-5.2",
+        displayName: "GLM-5.2",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 1.4, outputPer1mTokens: 4.4 },
+      },
       // Mistral
       {
         id: "mistralai/mistral-medium-3",
@@ -1284,6 +1313,35 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyUrl: "https://platform.minimax.io/",
     apiKeyPlaceholder: "sk-cp-...",
   },
+  {
+    id: "atlascloud",
+    displayName: "Atlas Cloud",
+    subtitle:
+      "Atlas Cloud AI models (OpenAI-compatible). Requires an Atlas Cloud API key.",
+    setupMode: "api-key",
+    setupHint: "Enter your Atlas Cloud API key to enable Atlas Cloud models.",
+    envVar: "ATLASCLOUD_API_KEY",
+    credentialsGuide: {
+      description: "Sign in to the Atlas Cloud console and create an API key.",
+      url: "https://www.atlascloud.ai/console",
+      linkLabel: "Open Atlas Cloud Console",
+    },
+    models: [
+      {
+        id: "deepseek-ai/deepseek-v4-pro",
+        displayName: "DeepSeek V4 Pro",
+        contextWindowTokens: 128000,
+        maxOutputTokens: 8192,
+        supportsThinking: true,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+      },
+    ],
+    defaultModel: "deepseek-ai/deepseek-v4-pro",
+    apiKeyUrl: "https://www.atlascloud.ai/console",
+    apiKeyPlaceholder: "apikey-...",
+  },
 ];
 
 export const PROVIDER_CATALOG: ProviderCatalogEntry[] =

package/src/providers/openai/__tests__/chat-completions-provider-reasoning.test.ts

@@ -460,6 +460,39 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     expect(params.messages[0].content).toBeNull();
   });
 
+  test("forwards config.top_p onto the request body", async () => {
+    const { provider, requests } = stubProvider([
+      {
+        choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 2, completion_tokens: 1 },
+      },
+    ]);
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      { config: { top_p: 0.95 } },
+    );
+
+    const params = requests[0] as { top_p?: number };
+    expect(params.top_p).toBe(0.95);
+  });
+
+  test("omits top_p from the request body when not configured", async () => {
+    const { provider, requests } = stubProvider([
+      {
+        choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 2, completion_tokens: 1 },
+      },
+    ]);
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ]);
+
+    const params = requests[0] as { top_p?: number };
+    expect(params.top_p).toBeUndefined();
+  });
+
   test("skips Anthropic-originated thinking blocks (with signatures)", async () => {
     const { provider, requests } = stubProvider(
       [

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

@@ -367,6 +367,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const logitBias = configObj?.logit_bias as
       | Record<string, number>
       | undefined;
+    const topP = configObj?.top_p as number | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
       | Record<string, string>
       | undefined;
@@ -398,6 +399,12 @@ export class OpenAIChatCompletionsProvider implements Provider {
         params.logit_bias = logitBias;
       }
 
+      // `top_p` (nucleus sampling). Forwarded explicitly because this client
+      // builds `params` field-by-field rather than spreading the config object.
+      if (typeof topP === "number") {
+        params.top_p = topP;
+      }
+
       // Subclasses (OpenRouter) may already have nested effort under
       // `reasoning.effort` via `buildExtraCreateParams`. Skip the flat
       // `reasoning_effort` assignment in that case to avoid sending both forms,

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

@@ -243,6 +243,16 @@ export class OpenAIResponsesProvider implements Provider {
         params.text = { verbosity };
       }
 
+      // Sampling params (`top_p`/`temperature`) are intentionally NOT forwarded
+      // on the Responses path. OpenAI reasoning models (o-series, GPT-5
+      // reasoning) reject them with HTTP 400 when reasoning is active, and the
+      // resolved `effort` defaults to a reasoning effort, so `reasoning` is set
+      // on essentially every Responses request. The profile editor therefore
+      // doesn't surface `topP` for the native `openai` provider (mirroring
+      // `temperature`, which is also never offered/forwarded here); OpenAI-
+      // compatible connections, which use the chat-completions client, honor
+      // `top_p` normally.
+
       if (tools && tools.length > 0) {
         if (
           this.useNativeWebSearch &&

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

@@ -48,6 +48,7 @@ export class CallSiteConfiguredProvider implements Provider {
     private readonly inner: Provider,
     private readonly callSite: LLMCallSite,
     private readonly overrideProfile?: string,
+    private readonly forceOverrideProfile?: boolean,
   ) {
     this.name = inner.name;
     this.tokenEstimationProvider = inner.tokenEstimationProvider;
@@ -71,6 +72,10 @@ export class CallSiteConfiguredProvider implements Provider {
         this.overrideProfile !== undefined
           ? { overrideProfile: this.overrideProfile }
           : {}),
+        ...(config?.forceOverrideProfile === undefined &&
+        this.forceOverrideProfile !== undefined
+          ? { forceOverrideProfile: this.forceOverrideProfile }
+          : {}),
       },
     });
   }
@@ -88,13 +93,15 @@ export class CallSiteConfiguredProvider implements Provider {
  * matching call-site identifier from `LLMCallSiteEnum` when adding a new
  * caller. Pass `opts.overrideProfile` to apply a per-call ad-hoc profile
  * override (e.g. a per-conversation pinned profile) on top of any workspace
- * `activeProfile`.
+ * `activeProfile`. Pass `opts.forceOverrideProfile` to float that override
+ * above the call-site layers (named site profile + call-site override) for
+ * non-main-agent call sites — see `ResolveCallSiteOpts.forceOverrideProfile`.
  *
  * Returns `null` when no providers are available at all.
  */
 export async function resolveConfiguredProvider(
   callSite: LLMCallSite,
-  opts: { overrideProfile?: string } = {},
+  opts: { overrideProfile?: string; forceOverrideProfile?: boolean } = {},
 ): Promise<ConfiguredProviderResult | null> {
   const config = getConfig();
 
@@ -174,6 +181,7 @@ export async function resolveConfiguredProvider(
       connectionProvider,
       callSite,
       opts.overrideProfile,
+      opts.forceOverrideProfile,
     ),
     configuredProviderName: inferenceProvider,
   };
@@ -189,7 +197,7 @@ export async function resolveConfiguredProvider(
  */
 export async function getConfiguredProvider(
   callSite: LLMCallSite,
-  opts: { overrideProfile?: string } = {},
+  opts: { overrideProfile?: string; forceOverrideProfile?: boolean } = {},
 ): Promise<Provider | null> {
   const result = await resolveConfiguredProvider(callSite, opts);
   return result?.provider ?? null;

package/src/providers/ratelimit.ts

@@ -25,12 +25,21 @@ export class RateLimitProvider implements Provider {
 
   private requestTimestamps: number[];
 
+  // Forward the optional token-counting endpoint so the capability survives
+  // the wrapper chain. Bound straight to the inner provider — count_tokens is
+  // a cheap separate endpoint outside the message rate budget, and its caller
+  // falls back on error.
+  public readonly countInputTokens?: NonNullable<Provider["countInputTokens"]>;
+
   constructor(
     private readonly inner: Provider,
     private readonly config: RateLimitConfig,
     sharedRequestTimestamps?: number[],
   ) {
     this.requestTimestamps = sharedRequestTimestamps ?? [];
+    if (inner.countInputTokens) {
+      this.countInputTokens = inner.countInputTokens.bind(inner);
+    }
   }
 
   async sendMessage(

package/src/providers/retry.ts

@@ -268,6 +268,16 @@ function normalizeSendMessageOptions(
     ) {
       nextConfig.temperature = resolved.temperature;
     }
+    // `topP` (schema, camelCase) maps to the provider wire field `top_p`.
+    // Defaults to `null` ("no opinion"); only forward an actual number so we
+    // never send `top_p: null`, mirroring the `temperature` handling above.
+    if (
+      nextConfig.top_p === undefined &&
+      resolved.topP !== null &&
+      resolved.topP !== undefined
+    ) {
+      nextConfig.top_p = resolved.topP;
+    }
     if (nextConfig.thinking === undefined && resolved.thinking !== undefined) {
       nextConfig.thinking = resolved.thinking;
     }
@@ -428,12 +438,16 @@ function normalizeSendMessageOptions(
   // - Other providers: not our problem here (e.g. OpenAI reasoning models
   //   strip `temperature` upstream; non-Anthropic OpenRouter reasoning
   //   models don't have this exact constraint).
-  const isThinkingTemperatureConflict = (() => {
+  //
+  // Anthropic applies the same constraint family to `top_p` (see the `top_p`
+  // guard below), so the "thinking is enabled on the Anthropic wire" predicate
+  // is shared between the two guards.
+  const isThinkingEnabledOnAnthropicWire = (() => {
     const model = typeof nextConfig.model === "string" ? nextConfig.model : "";
-    // Claude Fable always reasons in adaptive mode, so the `temperature: 1`
-    // constraint applies even when no explicit `thinking` config is present
-    // (a disabled config was already dropped above). For every other model
-    // the constraint only applies when thinking is actually enabled.
+    // Claude Fable always reasons in adaptive mode, so the constraint applies
+    // even when no explicit `thinking` config is present (a disabled config was
+    // already dropped above). For every other model the constraint only applies
+    // when thinking is actually enabled.
     if (!isAdaptiveThinkingOnlyModel(model)) {
       if (nextConfig.thinking == null) {
         return false;
@@ -442,13 +456,6 @@ function normalizeSendMessageOptions(
         return false;
       }
     }
-    const temp = nextConfig.temperature;
-    if (typeof temp !== "number") {
-      return false;
-    }
-    if (temp === 1) {
-      return false;
-    }
     if (providerName === "anthropic") {
       return true;
     }
@@ -457,6 +464,18 @@ function normalizeSendMessageOptions(
     }
     return false;
   })();
+  const isThinkingTemperatureConflict = (() => {
+    if (!isThinkingEnabledOnAnthropicWire) {
+      return false;
+    }
+    const temp = nextConfig.temperature;
+    if (typeof temp !== "number") {
+      return false;
+    }
+    // Unlike `top_p`, `temperature: 1` is explicitly accepted alongside
+    // thinking, so it's the one value that doesn't conflict.
+    return temp !== 1;
+  })();
   if (isThinkingTemperatureConflict) {
     log.warn(
       {
@@ -472,6 +491,28 @@ function normalizeSendMessageOptions(
     delete nextConfig.temperature;
   }
 
+  // Anthropic (and OpenRouter fronting Anthropic) also rejects requests that
+  // combine extended thinking with *any* `top_p` modification. Unlike
+  // `temperature` there is no "=== 1 is fine" exception — when thinking is
+  // enabled the request must not set `top_p` at all. Drop it with a warn log
+  // so the request goes through with Anthropic's default, keeping `thinking`
+  // (the more deliberate, profile-level choice) for the same reasons as the
+  // temperature guard above.
+  if (isThinkingEnabledOnAnthropicWire && nextConfig.top_p !== undefined) {
+    log.warn(
+      {
+        providerName,
+        callSite: config.callSite,
+        droppedTopP: nextConfig.top_p,
+      },
+      "Dropping `top_p` because thinking is enabled — Anthropic does not " +
+        "accept `top_p` modifications when thinking/adaptive mode is on. Set " +
+        "`thinking: { type: 'disabled' }` on the call site if you need a " +
+        "specific top_p.",
+    );
+    delete nextConfig.top_p;
+  }
+
   // effort is supported by Anthropic, OpenAI, and OpenAI-compatible providers; strip for others
   if (
     !EFFORT_SUPPORTED_PROVIDERS.has(providerName) &&
@@ -576,11 +617,20 @@ export class RetryProvider implements Provider {
     return this.inner.tokenEstimationProvider;
   }
 
+  // Forward the optional token-counting endpoint so the capability survives
+  // the wrapper chain (callers gate on its presence). Bound straight to the
+  // inner provider — count_tokens is a cheap separate endpoint and its caller
+  // already falls back on error, so it needs no retry wrapping.
+  public readonly countInputTokens?: NonNullable<Provider["countInputTokens"]>;
+
   constructor(
     private readonly inner: Provider,
     private readonly options: { forwardUsageAttributionHeaders?: boolean } = {},
   ) {
     this.name = inner.name;
+    if (inner.countInputTokens) {
+      this.countInputTokens = inner.countInputTokens.bind(inner);
+    }
   }
 
   async sendMessage(

package/src/providers/search-provider-catalog.ts

@@ -105,6 +105,16 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
     fallbackOrder: 3,
     privacyPolicyUrl: "https://tavily.com/privacy",
   },
+  {
+    id: "firecrawl",
+    displayName: "Firecrawl",
+    kind: "byok",
+    apiKeyPrefix: "fc-...",
+    envVar: "FIRECRAWL_API_KEY",
+    secretKey: "firecrawl",
+    fallbackOrder: 4,
+    privacyPolicyUrl: "https://www.firecrawl.dev/privacy-policy",
+  },
 ];
 
 /** Provider ids accepted by the web-search config schema. */

package/src/providers/types.ts

@@ -269,6 +269,22 @@ export interface Provider {
     messages: Message[],
     options?: SendMessageOptions,
   ): Promise<ProviderResponse>;
+  /**
+   * Exact prompt-token count from the provider's own tokenizer, for the
+   * `messages` + `systemPrompt` + `tools` composition the next call would
+   * send. Optional: providers without a token-counting endpoint omit it, and
+   * callers must fall back to the local estimator (`estimatePromptTokens`).
+   *
+   * This runs a dedicated counting request (no inference), so it carries a
+   * network round-trip and the provider's own rate limit — use it for
+   * user-initiated, occasional actions (e.g. `/compact`), never on the
+   * per-turn hot path.
+   */
+  countInputTokens?(
+    messages: Message[],
+    systemPrompt: string,
+    tools?: ToolDefinition[],
+  ): Promise<number>;
 }
 
 // ── Context-overflow error ────────────────────────────────────────────

package/src/providers/usage-tracking.ts

@@ -18,10 +18,17 @@ const log = getLogger("provider-usage-tracking");
 export class UsageTrackingProvider implements Provider {
   public readonly name: string;
   public readonly tokenEstimationProvider?: string;
+  // Forward the optional token-counting endpoint so the capability survives
+  // the wrapper chain. Bound straight to the inner provider — count_tokens is
+  // not billed, so there's no usage to track.
+  public readonly countInputTokens?: NonNullable<Provider["countInputTokens"]>;
 
   constructor(private readonly inner: Provider) {
     this.name = inner.name;
     this.tokenEstimationProvider = inner.tokenEstimationProvider;
+    if (inner.countInputTokens) {
+      this.countInputTokens = inner.countInputTokens.bind(inner);
+    }
   }
 
   async sendMessage(

package/src/providers/weak-open-model.ts

@@ -0,0 +1,22 @@
+/**
+ * Family-level classification of "weak open models" — open-weight models
+ * (Kimi, DeepSeek, MiniMax, GLM) that disregard static instructions and have
+ * capability gaps that capable models (Claude, GPT) do not. Used by harness
+ * levers that coach or redirect these models without touching capable-model
+ * behavior: the task-progress-nudge plugin and the empty-dynamic_page surface
+ * redirect.
+ *
+ * Family-level matching spans provider naming conventions: OpenRouter
+ * `moonshotai/kimi-k2.6`, `deepseek/deepseek-chat`, `minimax/minimax-m3`;
+ * Fireworks `accounts/fireworks/models/minimax-m3`, `kimi-k2p6`. Extend the
+ * pattern as other open models show the same gaps.
+ *
+ * Distinct from exploration-drift's narrower `LOOP_PRONE_MODEL_PATTERN`, which
+ * targets specific loop-prone versions rather than the whole capability family.
+ */
+export const WEAK_OPEN_MODEL_PATTERN = /kimi|deepseek|minimax|glm/i;
+
+/** True when `model` is a weak open model (see {@link WEAK_OPEN_MODEL_PATTERN}). */
+export function isWeakOpenModel(model: string | null | undefined): boolean {
+  return typeof model === "string" && WEAK_OPEN_MODEL_PATTERN.test(model);
+}

package/src/runtime/AGENTS.md

@@ -22,7 +22,6 @@ GET handlers must be safe and side-effect-free — they must not enqueue backgro
 
 Accepted exceptions (stale-while-revalidate caches): a GET handler may kick off a bounded, fire-and-forget background refresh of a generated-content cache when no fresh cache exists, provided the handler itself stays read-only and returns immediately with cached/fallback copy, the refresh is single-flight (concurrent GETs share one regeneration), and a TTL bounds regeneration frequency. Current instances:
 
-- `GET /v1/identity/intro` — refreshes the generated greeting cache; the background prompt may only depend on static identity/soul context plus caller-supplied local hour/minute.
 - `GET /v1/home/feed` — refreshes the personalized home greeting and suggested-prompt caches via `revalidateHomeContentInBackground()`, which publishes `home_feed_updated` when fresh content lands so clients refetch. This is intentional: home content is generated on demand (when a user actually views Home), never at daemon startup or on a timer.
 - `GET /v1/conversation-starters` — enqueues a `generate_conversation_starters` memory job when the starter set is stale, cooldown-gated and deduped against in-flight jobs.