@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/providers/inference/auth.ts

@@ -126,6 +126,12 @@ export const VALID_CONNECTION_PROVIDERS: readonly string[] = [
   // persisted `vellum` rows — the routing threaded in via `providerOverride`
   // never runs on a row that fails to load.
   VELLUM_MANAGED_PROVIDER,
+  // The ChatGPT-subscription row stores the "chatgpt" routing identity in its
+  // `provider` column for the same reason: the row IS the subscription route
+  // (auth modality = provider identity), and dispatch derives the openai
+  // upstream per-request. Allowlisted explicitly or the DB loaders would drop
+  // the persisted row.
+  "chatgpt",
 ];
 
 export type ConnectionProvider = string;

package/src/providers/inference/connection-availability.ts

@@ -23,6 +23,10 @@ import {
   describeSubscriptionModelIncompatibility,
   isConnectionCompatibleWithModel,
 } from "../connection-model-compat.js";
+import {
+  connectionProviderKind,
+  resolveEntryConnectionName,
+} from "../connection-resolution.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { resolveManagedProxyContext } from "../platform-proxy/context.js";
 import {
@@ -161,7 +165,12 @@ export async function computeConnectionAvailability(
   if (resolvedConnectionName === VELLUM_MANAGED_CONNECTION_NAME) {
     return vellumConnectionAvailability();
   }
-  if (connection.provider !== provider) {
+  // The ChatGPT-subscription row stores the "chatgpt" identity while its
+  // upstream is openai; the credential switch below is the right check for
+  // it (the subscription token is its credential).
+  const isChatgptRow =
+    connection.provider === "chatgpt" && provider === "openai";
+  if (!isChatgptRow && connection.provider !== provider) {
     return {
       status: "provider_mismatch",
       message: `Connection "${resolvedConnectionName}" is for provider "${connection.provider}", but the requested provider is "${provider}". Pick a connection for "${provider}" ${SETTINGS_HINT}.`,
@@ -326,9 +335,22 @@ export async function computeProfileAvailability(
     }
   }
 
+  // Precedence matches dispatch: an explicit provider_connection wins over
+  // an entry-name provider, and the vendor judged is the entry's
+  // dispatchable kind either way (the same translation dispatch uses).
+  const entryName = resolveEntryConnectionName(provider);
+  const entryKind =
+    entryName !== null
+      ? (connectionProviderKind(entryName, model) ?? provider)
+      : provider;
+
   const pinned = entry.provider_connection;
   if (typeof pinned === "string") {
-    return computeConnectionAvailability(provider, pinned);
+    return computeConnectionAvailability(entryKind, pinned);
+  }
+
+  if (entryName !== null) {
+    return computeConnectionAvailability(entryKind, entryName);
   }
 
   // Mirror the dispatch-time auto-resolve (`resolveConfiguredProvider`): with

package/src/providers/inference/connections.ts

@@ -348,10 +348,12 @@ export function updateConnection(
     connection: {
       ...existing,
       auth,
+      provider: nextProvider,
       label: input.label !== undefined ? input.label : existing.label,
       baseUrl: nextBaseUrl,
       models: nextModels,
       updatedAt: now,
+      isManaged: isManagedRow({ name, provider: nextProvider, auth }),
     },
   };
 }

package/src/providers/model-catalog.ts

@@ -939,7 +939,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
       },
       {
-        id: "accounts/fireworks/models/deepseek-v4-flash",
+        id: "accounts/fireworks/models/deepseek-v4-flash-0731",
         displayName: "DeepSeek V4 Flash",
         contextWindowTokens: 1040000,
         maxOutputTokens: 131072,
@@ -951,11 +951,11 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         pricing: {
           inputPer1mTokens: 0.14,
           outputPer1mTokens: 0.28,
-          cacheReadPer1mTokens: 0.03,
+          cacheReadPer1mTokens: 0.028,
         },
       },
     ],
-    defaultModel: "accounts/fireworks/models/deepseek-v4-flash",
+    defaultModel: "accounts/fireworks/models/deepseek-v4-flash-0731",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",
     apiKeyPlaceholder: "fw_...",
   },

package/src/providers/model-intents.ts

@@ -1,4 +1,5 @@
 import { isModelInCatalog, PROVIDER_CATALOG } from "./model-catalog.js";
+import { isCodexSubscriptionModel } from "./openai/codex-models.js";
 import type { ModelIntent } from "./types.js";
 
 /**
@@ -10,8 +11,10 @@ const PROVIDER_DEFAULT_MODELS: Record<string, string> = Object.fromEntries(
 );
 
 // `cost-optimized` is the cheapest model a provider serves, `latency-optimized`
-// the fastest to first token. On anthropic, ollama and fireworks the same model
-// is both, so those columns repeat by construction rather than by oversight.
+// the fastest to first token. On anthropic, ollama, fireworks and openai the
+// same model is both, so those columns repeat by construction rather than by
+// oversight (openai's balanced repeats it too: the default-profile templates
+// split those tiers by reasoning effort, not model).
 const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   anthropic: {
     balanced: "claude-sonnet-4-6",
@@ -21,11 +24,11 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
     "vision-optimized": "claude-opus-4-6",
   },
   openai: {
-    balanced: "gpt-5.4-mini",
-    "cost-optimized": "gpt-5.4-nano",
+    balanced: "gpt-5.6-luna",
+    "cost-optimized": "gpt-5.6-luna",
     "latency-optimized": "gpt-5.6-luna",
-    "quality-optimized": "gpt-5.4",
-    "vision-optimized": "gpt-5.4",
+    "quality-optimized": "gpt-5.6-sol",
+    "vision-optimized": "gpt-5.6-terra",
   },
   gemini: {
     balanced: "gemini-3-flash-preview",
@@ -43,8 +46,8 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   fireworks: {
     balanced: "accounts/fireworks/models/minimax-m3",
-    "cost-optimized": "accounts/fireworks/models/deepseek-v4-flash",
-    "latency-optimized": "accounts/fireworks/models/deepseek-v4-flash",
+    "cost-optimized": "accounts/fireworks/models/deepseek-v4-flash-0731",
+    "latency-optimized": "accounts/fireworks/models/deepseek-v4-flash-0731",
     "quality-optimized": "accounts/fireworks/models/kimi-k2p6",
     "vision-optimized": "accounts/fireworks/models/kimi-k2p6",
   },
@@ -89,6 +92,23 @@ for (const [provider, intents] of Object.entries(PROVIDER_MODEL_INTENTS)) {
   }
 }
 
+// The openai column must additionally stay inside the ChatGPT Codex
+// subscription set: the subscription default provider is stored as
+// `llm.defaultProvider = { provider: "openai", connectionName:
+// "chatgpt-subscription" }`, so the materialized default profiles resolve
+// through this column while pinning the subscription connection, which
+// bypasses the auto-resolution compat gate and hard-routes to the Codex
+// endpoint, where a non-Codex model 400s on every request.
+for (const [intent, modelId] of Object.entries(PROVIDER_MODEL_INTENTS.openai)) {
+  if (!isCodexSubscriptionModel(modelId)) {
+    throw new Error(
+      `PROVIDER_MODEL_INTENTS[openai][${intent}] references model "${modelId}" ` +
+        `which the ChatGPT subscription cannot serve. Pick a model from ` +
+        `CODEX_SUBSCRIPTION_MODEL_IDS in openai/codex-models.ts.`,
+    );
+  }
+}
+
 export function isModelIntent(value: unknown): value is ModelIntent {
   return typeof value === "string" && MODEL_INTENTS.has(value as ModelIntent);
 }

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

@@ -5,6 +5,7 @@ import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError, type ProviderErrorReason } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
+import { partialTagSuffix as sharedPartialTagSuffix } from "../../util/think-tag-stream.js";
 import { escapeXmlAttr } from "../../util/xml.js";
 import {
   base64Source,
@@ -293,13 +294,11 @@ const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/webp",
 ]);
 
+// Think-tag scanning primitives are shared with the TTS reasoning filter
+// (util/think-tag-stream.ts) so the two stream parsers cannot drift. This
+// provider keeps its exact historical behavior: case-sensitive, <think> only.
 function partialTagSuffix(text: string, tag: string): number {
-  for (let len = Math.min(text.length, tag.length - 1); len > 0; len--) {
-    if (text.endsWith(tag.substring(0, len))) {
-      return len;
-    }
-  }
-  return 0;
+  return sharedPartialTagSuffix(text, [tag], false);
 }
 
 /**

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

@@ -13,9 +13,10 @@ export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
   "gpt-5.6-terra",
   "gpt-5.6-luna",
   "gpt-5.5",
+  // OpenAI retires these two from ChatGPT sign-in on 2026-08-31; API-key
+  // auth is unaffected.
   "gpt-5.4",
   "gpt-5.4-mini",
-  "gpt-5.3-codex",
 ]);
 
 /** True when `model` is allowlisted for Codex subscription routing. */

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

@@ -17,6 +17,10 @@ import {
   isConnectionCompatibleWithModel,
 } from "./connection-model-compat.js";
 import {
+  connectionProviderKind,
+  dispatchProviderResolvable,
+  expectedVendorProvider,
+  resolveEntryConnectionName,
   resolveRoutingIdentity,
   tryResolveProviderForConnectionName,
 } from "./connection-resolution.js";
@@ -37,6 +41,13 @@ const log = getLogger("provider-send-message");
 export interface ConfiguredProviderResult {
   provider: Provider;
   configuredProviderName: string;
+  /**
+   * True when the profile's provider was an entry label and dispatch routed
+   * through that row. The row's own credential already signed resolution, so
+   * vendor-keyed preflights (which check the generic per-vendor key slot)
+   * do not apply to this result.
+   */
+  entryRouted: boolean;
 }
 
 export type ConfiguredProviderOptions = Pick<
@@ -140,7 +151,10 @@ export async function resolveConfiguredProvider(
     }
   }
 
-  const resolved = resolveCallSiteConfig(callSite, config.llm, opts);
+  const resolved = resolveCallSiteConfig(callSite, config.llm, {
+    ...opts,
+    isResolvableProvider: dispatchProviderResolvable,
+  });
   const inferenceProvider = resolved.provider;
   let connectionName = resolved.provider_connection;
 
@@ -158,6 +172,14 @@ export async function resolveConfiguredProvider(
       resolved.model,
     )?.connectionName;
   }
+  // An entry-name provider IS the connection name: the label points at a
+  // row, and the row's own provider drives dispatch.
+  const entryRoute = connectionName
+    ? null
+    : resolveEntryConnectionName(inferenceProvider);
+  if (entryRoute) {
+    connectionName = entryRoute;
+  }
   if (!connectionName) {
     if (inferenceProvider) {
       try {
@@ -202,7 +224,7 @@ export async function resolveConfiguredProvider(
   const connectionProvider = await tryResolveProviderForConnectionName(
     connectionName,
     config,
-    inferenceProvider,
+    expectedVendorProvider(inferenceProvider, resolved.model),
     resolved.model,
   );
   if (!connectionProvider) {
@@ -234,7 +256,14 @@ export async function resolveConfiguredProvider(
       opts.overrideProfile,
       opts.forceOverrideProfile,
     ),
-    configuredProviderName: inferenceProvider,
+    // The dispatched vendor kind, not the config label: an entry-name
+    // provider reports its row's kind so provider-keyed consumers
+    // (telemetry, pricing) never see a label that matches no catalog id.
+    configuredProviderName:
+      (entryRoute
+        ? connectionProviderKind(entryRoute, resolved.model)
+        : undefined) ?? inferenceProvider,
+    entryRouted: entryRoute !== null,
   };
 }