@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240206.7c2bca6

package/src/providers/anthropic/client.ts

@@ -18,6 +18,7 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
+  ToolDefinition,
 } from "../types.js";
 import {
   ContextOverflowError,
@@ -823,181 +824,7 @@ export class AnthropicProvider implements Provider {
     // edge LB, NAT idle) — only the latter should be retried.
     let innerTimeoutSignal: AbortSignal | undefined;
     try {
-      const formatted = messages
-        .map((m) => {
-          // Track whether an unknown block was dropped during filtering
-          let droppedUnknownBlock = false;
-
-          const content = m.content
-            .map((block) => {
-              const result = this.toAnthropicBlockSafe(block);
-              if (result == null) {
-                droppedUnknownBlock = true;
-              }
-              return result;
-            })
-            .filter(
-              (block): block is Anthropic.ContentBlockParam => block != null,
-            )
-            .filter(
-              (block) =>
-                !(
-                  block.type === "text" &&
-                  !(block as { text?: string }).text?.trim()
-                ),
-            );
-
-          // Preserve assistant turns that would otherwise become empty after filtering
-          // unknown block types (e.g. ui_surface). Dropping these messages can violate
-          // Anthropic's role alternation requirement.
-          if (
-            content.length === 0 &&
-            m.role === "assistant" &&
-            droppedUnknownBlock
-          ) {
-            return {
-              role: m.role as "assistant",
-              content: [
-                { type: "text" as const, text: PLACEHOLDER_BLOCKS_OMITTED },
-              ],
-            };
-          }
-
-          return {
-            role: m.role,
-            content,
-          } as Anthropic.MessageParam;
-        })
-        .reduce<Anthropic.MessageParam[]>((acc, m) => {
-          if (m.content.length > 0) {
-            acc.push(m);
-            return acc;
-          }
-          // Dropping an empty assistant message between two user messages (or vice
-          // versa) would create consecutive same-role messages, violating
-          // Anthropic's role alternation requirement. Inject a placeholder instead.
-          const prev = acc[acc.length - 1];
-          if (m.role === "assistant" && prev && prev.role !== "assistant") {
-            acc.push({
-              role: "assistant" as const,
-              content: [
-                { type: "text" as const, text: PLACEHOLDER_EMPTY_TURN },
-              ],
-            });
-          }
-          return acc;
-        }, []);
-
-      // Post-processing: merge consecutive same-role messages that violate
-      // Anthropic's strict user/assistant alternation requirement. These can
-      // arise from:
-      //   - Dropping empty messages in the reduce above (placeholder-adjacent)
-      //   - History reconstruction artifacts that bypass repairHistory
-      //
-      // Walk backwards so splice indices stay valid. After a merge+splice
-      // the element that was at i+1 shifts to i, potentially creating a
-      // new adjacent pair — bump i back up to recheck that position.
-      {
-        let i = formatted.length - 1;
-        while (i > 0 && i < formatted.length) {
-          if (formatted[i].role !== formatted[i - 1].role) {
-            i--;
-            continue;
-          }
-
-          const iContent = (
-            Array.isArray(formatted[i].content) ? formatted[i].content : []
-          ) as Anthropic.ContentBlockParam[];
-          const prevContent = (
-            Array.isArray(formatted[i - 1].content)
-              ? formatted[i - 1].content
-              : []
-          ) as Anthropic.ContentBlockParam[];
-          const isPlaceholder = (c: Anthropic.ContentBlockParam[]): boolean => {
-            if (
-              c.length !== 1 ||
-              typeof c[0] === "string" ||
-              c[0].type !== "text"
-            )
-              return false;
-            const text = (c[0] as { text?: string }).text;
-            return typeof text === "string" && isPlaceholderSentinelText(text);
-          };
-
-          if (isPlaceholder(iContent)) {
-            formatted.splice(i, 1);
-            // Removed the later element. The new formatted[i] (formerly
-            // i+1) may now be same-role as i-1, so decrement once to
-            // recheck from the correct position.
-            i--;
-          } else if (isPlaceholder(prevContent)) {
-            formatted.splice(i - 1, 1);
-            // Removed the earlier element — everything shifted down by 1.
-            // The element that was at i is now at i-1. Decrement so the
-            // next iteration compares the new i-1 with i-2 (or exits if
-            // i-1 is 0).
-            i--;
-          } else {
-            // Neither is a placeholder — merge content blocks into the
-            // earlier message and remove the later one. Skip the merge
-            // when either message carries tool_use or tool_result blocks;
-            // those require structural alternation for ensureToolPairing
-            // to inject the correct synthetic results downstream.
-            const hasToolBlock = (c: Anthropic.ContentBlockParam[]): boolean =>
-              c.some(
-                (b) =>
-                  typeof b !== "string" &&
-                  (b.type === "tool_use" || b.type === "tool_result"),
-              );
-            if (!hasToolBlock(prevContent) && !hasToolBlock(iContent)) {
-              formatted[i - 1] = {
-                ...formatted[i - 1],
-                content: [...prevContent, ...iContent],
-              };
-              formatted.splice(i, 1);
-              // Clamp i to the new last index — the splice may have put
-              // us past the end. If there's a new element at i (formerly
-              // i+1), it will be rechecked against the merged i-1.
-              if (i >= formatted.length) {
-                i = formatted.length - 1;
-              }
-            } else {
-              // Can't merge (tool blocks present) — leave for
-              // ensureToolPairing which handles tool_use/tool_result
-              // alternation in its own forward walk.
-              i--;
-            }
-          }
-        }
-      }
-
-      // Strip thinking/redacted_thinking blocks from completed historical
-      // assistant turns. Anthropic only requires these blocks for active
-      // tool-use continuation (the tail span where assistant tool_use is
-      // followed by user tool_result). Replaying stale thinking blocks from
-      // earlier turns causes 400 errors when the signature is no longer
-      // valid (e.g. after a provider/model/profile switch).
-      const activeToolUseStart = findActiveToolUseContinuationStart(formatted);
-      for (let i = 0; i < activeToolUseStart; i++) {
-        const msg = formatted[i];
-        if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
-        const stripped = (msg.content as Anthropic.ContentBlockParam[]).filter(
-          (b) =>
-            typeof b === "string" ||
-            (b.type !== "thinking" && b.type !== "redacted_thinking"),
-        );
-        if (stripped.length === 0) {
-          stripped.push({
-            type: "text" as const,
-            text: PLACEHOLDER_BLOCKS_OMITTED,
-          });
-        }
-        formatted[i] = { ...msg, content: stripped };
-      }
-
-      sentMessages = ensureToolPairing(
-        repairOrphanedServerToolBlocks(formatted),
-      );
+      sentMessages = this.buildSentMessages(messages);
       const {
         effort,
         speed,
@@ -1008,6 +835,11 @@ export class AnthropicProvider implements Provider {
         disableCache: _disableCache,
         max_tokens: callerMaxTokens,
         usageAttributionHeaders,
+        // Pulled out of `restConfig` so they are forwarded conditionally below:
+        // newer models reject them outright (see `deprecatesSamplingParams`).
+        temperature: callerTemperature,
+        top_p: callerTopP,
+        top_k: callerTopK,
         ...restConfig
       } = (config ?? {}) as Record<string, unknown> & {
         // "xhigh" is an intermediate tier between "high" and "max" supported
@@ -1020,6 +852,9 @@ export class AnthropicProvider implements Provider {
         speed?: "standard" | "fast";
         output_config?: Record<string, unknown>;
         usageAttributionHeaders?: Record<string, string>;
+        temperature?: number;
+        top_p?: number;
+        top_k?: number;
       };
       // Haiku does not support the effort / output_config parameter or
       // extended cache TTL betas.
@@ -1029,6 +864,16 @@ export class AnthropicProvider implements Provider {
         (restConfig as Record<string, unknown>).model?.toString() ?? this.model;
       const isHaiku = effectiveModel.includes("haiku");
       const supportsEffort = !isHaiku;
+      // opus-4-7 / opus-4-8 reject `temperature` and `top_p` with a 400
+      // "`temperature`/`top_p` is deprecated for this model" — model-wide, not
+      // effort-conditional (verified 2026-06-23). opus-4-6 / sonnet-4-6 /
+      // haiku-4-5 still accept them. fable-5 is included conservatively (a
+      // frontier model that could not be verified directly but follows the same
+      // deprecation direction). Stripping the params here keeps callers that set
+      // them (e.g. the memory-v3 L2 selector's `temperature: 0`) from 400ing.
+      const deprecatesSamplingParams =
+        /claude-opus-4-[78]\b/.test(effectiveModel) ||
+        effectiveModel.startsWith("claude-fable-");
       const mergedOutputConfig = {
         ...(output_config ?? {}),
         ...(effort && effort !== "none" && supportsEffort
@@ -1056,6 +901,19 @@ export class AnthropicProvider implements Provider {
             : 64000,
         messages: sentMessages,
         ...restConfig,
+        // Forward `temperature` / `top_p` / `top_k` only to models that still
+        // accept them; newer models 400 on any of the deprecated sampler params.
+        // `temperature: 0` is preserved for accepting models (a `typeof ===
+        // "number"` check, not truthiness).
+        ...(deprecatesSamplingParams
+          ? {}
+          : {
+              ...(typeof callerTemperature === "number"
+                ? { temperature: callerTemperature }
+                : {}),
+              ...(typeof callerTopP === "number" ? { top_p: callerTopP } : {}),
+              ...(typeof callerTopK === "number" ? { top_k: callerTopK } : {}),
+            }),
         ...(Object.keys(mergedOutputConfig).length > 0
           ? { output_config: mergedOutputConfig }
           : {}),
@@ -1195,15 +1053,27 @@ export class AnthropicProvider implements Provider {
       }
 
       // Advancing tail: place a short-lived 5m cache breakpoint on the last
-      // block of the last message when it falls after the turn-starting user
-      // message (i.e. tool-use loop content). This caches the growing tail
-      // cheaply without conflicting with the 1h breakpoints above.
-      // Skip thinking/redacted_thinking blocks — Anthropic doesn't allow
+      // block of the last message. This caches the growing tail cheaply
+      // without conflicting with the 1h breakpoints above. It fires during
+      // tool-use loops (the tail falls after the turn-starting user message)
+      // and also on a first-of-turn request whose volatile turn-start anchor
+      // was skipped while a previous-turn anchor exists: there the latest
+      // message would otherwise carry no breakpoint, so the next request's
+      // anchor can land far ahead of the previous-turn anchor and Anthropic's
+      // ~20-block cache lookback can't bridge the gap — forcing a full
+      // re-creation of the prefix. The 5m breakpoint gives the next call an
+      // exact, reachable boundary; cross-turn it expires harmlessly. The
+      // first-of-turn bridge lands on the turn-start block, so it honors
+      // `disableTurnStartCache` like the long-TTL anchor above. Skip
+      // thinking/redacted_thinking blocks — Anthropic doesn't allow
       // cache_control on those types.
       if (
         !disableCache &&
         turnStartIdx >= 0 &&
-        turnStartIdx < sentMessages.length - 1
+        (turnStartIdx < sentMessages.length - 1 ||
+          (skipVolatileTurnStartAnchor &&
+            turnStartIdx > 0 &&
+            !disableTurnStartCache))
       ) {
         const lastMsg = sentMessages[sentMessages.length - 1];
         if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
@@ -1230,11 +1100,13 @@ export class AnthropicProvider implements Provider {
       }
 
       // Cache-breakpoint accounting: system(≤2) + tools(1, only when the
-      // system is a single block or absent) + turn-start(1) +
-      // (tail OR prev-turn-anchor)(1) ≤ 4 — Anthropic's per-request cap.
-      // Tail and prev-turn-anchor are mutually exclusive (the latter only
-      // fires when turn-start is the last message, which suppresses the
-      // tail), so the total can't drift past 4.
+      // system is a single block or absent) + at most two message anchors
+      // ≤ 4 — Anthropic's per-request cap. The two message anchors are
+      // turn-start + prev-turn-anchor (first-of-turn), turn-start + tail
+      // (tool-use loop), or prev-turn-anchor + tail (first-of-turn with the
+      // volatile turn-start anchor skipped — the freed turn-start slot covers
+      // the tail). At most two message-level breakpoints are placed, so the
+      // total can't drift past 4.
 
       // Strip orphaned UTF-16 surrogates so the Anthropic JSON parser never
       // sees invalid strings produced by upstream surrogate-splitting `.slice()` calls.
@@ -1681,6 +1553,234 @@ export class AnthropicProvider implements Provider {
     }
   }
 
+  /**
+   * Exact prompt-token count via Anthropic's `/v1/messages/count_tokens`
+   * endpoint — the real tokenizer, no inference. Serializes `messages` /
+   * `systemPrompt` / `tools` the same way {@link sendMessage} does (so the
+   * count tracks what the next call would actually send), minus the
+   * `cache_control` breakpoints, which don't affect token counts.
+   *
+   * The serialization here is intentionally simpler than `sendMessage`'s
+   * (no role-alternation merge / placeholder injection): on a pathological
+   * history `count_tokens` may reject the request, which surfaces as a thrown
+   * error the caller turns into a local-estimator fallback. The common path —
+   * a well-formed history — counts exactly.
+   */
+  async countInputTokens(
+    messages: Message[],
+    systemPrompt: string,
+    tools?: ToolDefinition[],
+  ): Promise<number> {
+    const sentMessages = this.buildSentMessages(messages);
+
+    const system = systemPrompt
+      ? systemPrompt
+          .split(SYSTEM_PROMPT_CACHE_BOUNDARY)
+          .filter((text) => text.length > 0)
+          .map((text) => ({ type: "text" as const, text }))
+      : [];
+    const toolsParam =
+      tools && tools.length > 0
+        ? tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.input_schema as Anthropic.Tool["input_schema"],
+          }))
+        : undefined;
+
+    const res = await this.client.messages.countTokens({
+      model: this.model,
+      messages: sentMessages,
+      ...(system.length > 0 ? { system } : {}),
+      ...(toolsParam ? { tools: toolsParam } : {}),
+    });
+    return res.input_tokens;
+  }
+
+  /**
+   * Serialize internal `Message[]` into the Anthropic `MessageParam[]` the
+   * Messages API expects: drop unknown/empty blocks, preserve role
+   * alternation (placeholder injection + same-role merge), strip stale
+   * thinking blocks outside the active tool-use continuation, and repair
+   * tool_use/tool_result pairing. Shared by {@link sendMessage} and
+   * {@link countInputTokens} so both send the identical message payload —
+   * `cache_control` breakpoints (which don't affect token counts) are the
+   * only thing layered on top in `sendMessage`.
+   */
+  private buildSentMessages(messages: Message[]): Anthropic.MessageParam[] {
+    const formatted = messages
+      .map((m) => {
+        // Track whether an unknown block was dropped during filtering
+        let droppedUnknownBlock = false;
+
+        const content = m.content
+          .map((block) => {
+            const result = this.toAnthropicBlockSafe(block);
+            if (result == null) {
+              droppedUnknownBlock = true;
+            }
+            return result;
+          })
+          .filter(
+            (block): block is Anthropic.ContentBlockParam => block != null,
+          )
+          .filter(
+            (block) =>
+              !(
+                block.type === "text" &&
+                !(block as { text?: string }).text?.trim()
+              ),
+          );
+
+        // Preserve assistant turns that would otherwise become empty after filtering
+        // unknown block types (e.g. ui_surface). Dropping these messages can violate
+        // Anthropic's role alternation requirement.
+        if (
+          content.length === 0 &&
+          m.role === "assistant" &&
+          droppedUnknownBlock
+        ) {
+          return {
+            role: m.role as "assistant",
+            content: [
+              { type: "text" as const, text: PLACEHOLDER_BLOCKS_OMITTED },
+            ],
+          };
+        }
+
+        return {
+          role: m.role,
+          content,
+        } as Anthropic.MessageParam;
+      })
+      .reduce<Anthropic.MessageParam[]>((acc, m) => {
+        if (m.content.length > 0) {
+          acc.push(m);
+          return acc;
+        }
+        // Dropping an empty assistant message between two user messages (or vice
+        // versa) would create consecutive same-role messages, violating
+        // Anthropic's role alternation requirement. Inject a placeholder instead.
+        const prev = acc[acc.length - 1];
+        if (m.role === "assistant" && prev && prev.role !== "assistant") {
+          acc.push({
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: PLACEHOLDER_EMPTY_TURN }],
+          });
+        }
+        return acc;
+      }, []);
+
+    // Post-processing: merge consecutive same-role messages that violate
+    // Anthropic's strict user/assistant alternation requirement. These can
+    // arise from:
+    //   - Dropping empty messages in the reduce above (placeholder-adjacent)
+    //   - History reconstruction artifacts that bypass repairHistory
+    //
+    // Walk backwards so splice indices stay valid. After a merge+splice
+    // the element that was at i+1 shifts to i, potentially creating a
+    // new adjacent pair — bump i back up to recheck that position.
+    {
+      let i = formatted.length - 1;
+      while (i > 0 && i < formatted.length) {
+        if (formatted[i].role !== formatted[i - 1].role) {
+          i--;
+          continue;
+        }
+
+        const iContent = (
+          Array.isArray(formatted[i].content) ? formatted[i].content : []
+        ) as Anthropic.ContentBlockParam[];
+        const prevContent = (
+          Array.isArray(formatted[i - 1].content)
+            ? formatted[i - 1].content
+            : []
+        ) as Anthropic.ContentBlockParam[];
+        const isPlaceholder = (c: Anthropic.ContentBlockParam[]): boolean => {
+          if (
+            c.length !== 1 ||
+            typeof c[0] === "string" ||
+            c[0].type !== "text"
+          )
+            return false;
+          const text = (c[0] as { text?: string }).text;
+          return typeof text === "string" && isPlaceholderSentinelText(text);
+        };
+
+        if (isPlaceholder(iContent)) {
+          formatted.splice(i, 1);
+          // Removed the later element. The new formatted[i] (formerly
+          // i+1) may now be same-role as i-1, so decrement once to
+          // recheck from the correct position.
+          i--;
+        } else if (isPlaceholder(prevContent)) {
+          formatted.splice(i - 1, 1);
+          // Removed the earlier element — everything shifted down by 1.
+          // The element that was at i is now at i-1. Decrement so the
+          // next iteration compares the new i-1 with i-2 (or exits if
+          // i-1 is 0).
+          i--;
+        } else {
+          // Neither is a placeholder — merge content blocks into the
+          // earlier message and remove the later one. Skip the merge
+          // when either message carries tool_use or tool_result blocks;
+          // those require structural alternation for ensureToolPairing
+          // to inject the correct synthetic results downstream.
+          const hasToolBlock = (c: Anthropic.ContentBlockParam[]): boolean =>
+            c.some(
+              (b) =>
+                typeof b !== "string" &&
+                (b.type === "tool_use" || b.type === "tool_result"),
+            );
+          if (!hasToolBlock(prevContent) && !hasToolBlock(iContent)) {
+            formatted[i - 1] = {
+              ...formatted[i - 1],
+              content: [...prevContent, ...iContent],
+            };
+            formatted.splice(i, 1);
+            // Clamp i to the new last index — the splice may have put
+            // us past the end. If there's a new element at i (formerly
+            // i+1), it will be rechecked against the merged i-1.
+            if (i >= formatted.length) {
+              i = formatted.length - 1;
+            }
+          } else {
+            // Can't merge (tool blocks present) — leave for
+            // ensureToolPairing which handles tool_use/tool_result
+            // alternation in its own forward walk.
+            i--;
+          }
+        }
+      }
+    }
+
+    // Strip thinking/redacted_thinking blocks from completed historical
+    // assistant turns. Anthropic only requires these blocks for active
+    // tool-use continuation (the tail span where assistant tool_use is
+    // followed by user tool_result). Replaying stale thinking blocks from
+    // earlier turns causes 400 errors when the signature is no longer
+    // valid (e.g. after a provider/model/profile switch).
+    const activeToolUseStart = findActiveToolUseContinuationStart(formatted);
+    for (let i = 0; i < activeToolUseStart; i++) {
+      const msg = formatted[i];
+      if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+      const stripped = (msg.content as Anthropic.ContentBlockParam[]).filter(
+        (b) =>
+          typeof b === "string" ||
+          (b.type !== "thinking" && b.type !== "redacted_thinking"),
+      );
+      if (stripped.length === 0) {
+        stripped.push({
+          type: "text" as const,
+          text: PLACEHOLDER_BLOCKS_OMITTED,
+        });
+      }
+      formatted[i] = { ...msg, content: stripped };
+    }
+
+    return ensureToolPairing(repairOrphanedServerToolBlocks(formatted));
+  }
+
   /**
    * Convert a content block to Anthropic format, returning null for unknown
    * block types instead of throwing.  Unknown types (e.g. ui_surface stored

package/src/providers/call-site-routing.ts

@@ -60,6 +60,12 @@ export class CallSiteRoutingProvider implements Provider {
     return this._activeProviderContext.getStore() ?? this.defaultProvider.name;
   }
 
+  // Forward the optional token-counting endpoint from the default provider —
+  // the same one whose `tokenEstimationProvider` this wrapper surfaces, and
+  // the provider that handles the main agent turn that `/compact` sizes
+  // against. Per-call connection routing only affects `sendMessage`.
+  public readonly countInputTokens?: NonNullable<Provider["countInputTokens"]>;
+
   constructor(
     private readonly defaultProvider: Provider,
     /**
@@ -88,6 +94,10 @@ export class CallSiteRoutingProvider implements Provider {
     ) => Promise<Provider | null>,
   ) {
     this.tokenEstimationProvider = defaultProvider.tokenEstimationProvider;
+    if (defaultProvider.countInputTokens) {
+      this.countInputTokens =
+        defaultProvider.countInputTokens.bind(defaultProvider);
+    }
   }
 
   async sendMessage(

package/src/providers/gemini/client.ts

@@ -17,6 +17,7 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
+  ToolDefinition,
 } from "../types.js";
 import {
   ContextOverflowError,
@@ -518,6 +519,48 @@ export class GeminiProvider implements Provider {
     }
   }
 
+  /**
+   * Exact prompt-token count via Gemini's `models.countTokens` — the real
+   * tokenizer, no generation. Mirrors {@link sendMessage}'s composition
+   * (contents + `systemInstruction` + tool function declarations) so the count
+   * tracks what a real call would send. Throws when the endpoint returns no
+   * `totalTokens`, so the caller falls back to the local estimate.
+   */
+  async countInputTokens(
+    messages: Message[],
+    systemPrompt: string,
+    tools?: ToolDefinition[],
+  ): Promise<number> {
+    const contents = this.toGeminiContents(messages, this.model);
+    const config: genai.CountTokensConfig = {};
+    if (systemPrompt) {
+      config.systemInstruction = systemPrompt.replaceAll(
+        SYSTEM_PROMPT_CACHE_BOUNDARY,
+        "\n\n",
+      );
+    }
+    if (tools && tools.length > 0) {
+      config.tools = [
+        {
+          functionDeclarations: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parametersJsonSchema: t.input_schema,
+          })),
+        },
+      ];
+    }
+    const res = await this.client.models.countTokens({
+      model: this.model,
+      contents,
+      ...(Object.keys(config).length > 0 ? { config } : {}),
+    });
+    if (typeof res.totalTokens !== "number") {
+      throw new Error("Gemini countTokens returned no totalTokens");
+    }
+    return res.totalTokens;
+  }
+
   /** Convert neutral messages to Gemini Content[] format. */
   private toGeminiContents(
     messages: Message[],

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

@@ -29,6 +29,7 @@ import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provid
 import { OpenAIResponsesProvider } from "../openai/responses-provider.js";
 import { OpenRouterProvider } from "../openrouter/client.js";
 import { RetryProvider } from "../retry.js";
+import { TogetherProvider } from "../together/client.js";
 import type { Provider } from "../types.js";
 import { UsageTrackingProvider } from "../usage-tracking.js";
 import type { ResolvedAuth } from "./auth.js";
@@ -117,6 +118,11 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
     new MinimaxProvider(apiKey, model, { streamTimeoutMs }),
   atlascloud: ({ apiKey, model, streamTimeoutMs }) =>
     new AtlasCloudProvider(apiKey, model, { streamTimeoutMs }),
+  together: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+    new TogetherProvider(apiKey, model, {
+      streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
+    }),
 };
 
 /**

package/src/providers/inference/connections.ts

@@ -346,6 +346,12 @@ const CANONICAL_CONNECTIONS: Array<{
     auth: { type: "platform" },
     label: "Fireworks",
   },
+  {
+    name: "together-managed",
+    provider: "together",
+    auth: { type: "platform" },
+    label: "Together AI",
+  },
 ];
 
 /**
@@ -415,4 +421,3 @@ export function seedCanonicalConnections(db: DrizzleDb): void {
       .run();
   }
 }
-