@vellumai/assistant 0.8.1 → 0.8.2

package/src/providers/anthropic/client.ts

@@ -715,6 +715,7 @@ export class AnthropicProvider implements Provider {
   private model: string;
   private useNativeWebSearch: boolean;
   private streamTimeoutMs: number;
+  private requestHeaders: Record<string, string>;
 
   constructor(
     apiKey: string,
@@ -730,9 +731,12 @@ export class AnthropicProvider implements Provider {
        * positional `apiKey` argument is ignored on the wire.
        */
       authToken?: string;
+      /** Provider-level request headers merged into every API request. */
+      requestHeaders?: Record<string, string>;
     } = {},
   ) {
     this.streamTimeoutMs = options.streamTimeoutMs ?? 1_800_000;
+    this.requestHeaders = options.requestHeaders ?? {};
     // Pass the same deadline to the SDK so its per-request timeout can't
     // fire before `createStreamTimeout` does. The SDK's default is 10 min,
     // which truncates any request we intend to run longer than that. We add
@@ -1003,18 +1007,16 @@ export class AnthropicProvider implements Provider {
           const dynamicBlock = systemPrompt.slice(
             boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length,
           );
-          params.system = [
-            {
+          const systemBlocks = [staticBlock, dynamicBlock]
+            .filter((text) => text.length > 0)
+            .map((text) => ({
               type: "text" as const,
-              text: staticBlock,
+              text,
               cache_control: cacheControl,
-            },
-            {
-              type: "text" as const,
-              text: dynamicBlock,
-              cache_control: cacheControl,
-            },
-          ];
+            }));
+          if (systemBlocks.length > 0) {
+            params.system = systemBlocks;
+          }
         } else {
           params.system = [
             {
@@ -1201,6 +1203,16 @@ export class AnthropicProvider implements Provider {
 
       let response: Anthropic.Message;
       try {
+        const requestHeaders = {
+          ...this.requestHeaders,
+          ...(usageAttributionHeaders ?? {}),
+        };
+        const requestOptions = {
+          signal: timeoutSignal,
+          ...(Object.keys(requestHeaders).length > 0
+            ? { headers: requestHeaders }
+            : {}),
+        };
         const stream: UnifiedStream = useFastMode
           ? (this.client.beta.messages.stream(
               {
@@ -1209,12 +1221,7 @@ export class AnthropicProvider implements Provider {
                 betas,
               } as Anthropic.Beta.Messages.MessageCreateParamsNonStreaming &
                 Anthropic.Beta.Messages.MessageCreateParamsStreaming,
-              {
-                signal: timeoutSignal,
-                ...(usageAttributionHeaders
-                  ? { headers: usageAttributionHeaders }
-                  : {}),
-              },
+              requestOptions,
             ) as unknown as UnifiedStream)
           : betas.length > 0
             ? (this.client.beta.messages.stream(
@@ -1223,19 +1230,12 @@ export class AnthropicProvider implements Provider {
                   betas,
                 } as Anthropic.Beta.Messages.MessageCreateParamsNonStreaming &
                   Anthropic.Beta.Messages.MessageCreateParamsStreaming,
-                {
-                  signal: timeoutSignal,
-                  ...(usageAttributionHeaders
-                    ? { headers: usageAttributionHeaders }
-                    : {}),
-                },
+                requestOptions,
               ) as unknown as UnifiedStream)
-            : (this.client.messages.stream(params, {
-                signal: timeoutSignal,
-                ...(usageAttributionHeaders
-                  ? { headers: usageAttributionHeaders }
-                  : {}),
-              }) as unknown as UnifiedStream);
+            : (this.client.messages.stream(
+                params,
+                requestOptions,
+              ) as unknown as UnifiedStream);
 
         // Buffer streaming text until it's clear the accumulated text isn't
         // going to form a placeholder sentinel. Sentinels are injected into

package/src/providers/connection-resolution.ts

@@ -110,6 +110,13 @@ export async function tryResolveProviderForConnectionName(
       `provider_connection "${connectionName}" has provider="${connection.provider}" but resolving profile declared provider="${expectedProvider}" — set the profile's provider_connection to a row matching its provider`,
     );
   }
+  if (connection.status === "disabled") {
+    log.debug(
+      { connectionName },
+      "provider_connection is disabled — returning null",
+    );
+    return null;
+  }
   // `resolveProviderFromConnection` reaches into auth resolution (credential
   // reads, managed-proxy context). A transient failure there is a soft
   // miss — log and return null so the caller can treat it the same as

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

@@ -23,6 +23,7 @@ import { FireworksProvider } from "../fireworks/client.js";
 import { GeminiProvider } from "../gemini/client.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
 import { OllamaProvider } from "../ollama/client.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
 import { OpenAIResponsesProvider } from "../openai/responses-provider.js";
 import { OpenRouterProvider } from "../openrouter/client.js";
 import { RetryProvider } from "../retry.js";
@@ -52,7 +53,13 @@ type AdapterFactory = (opts: AdapterCreateOpts) => Provider;
  * module-load time.
  */
 const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
-  anthropic: ({ apiKey, model, streamTimeoutMs, baseURL, useNativeWebSearch }) =>
+  anthropic: ({
+    apiKey,
+    model,
+    streamTimeoutMs,
+    baseURL,
+    useNativeWebSearch,
+  }) =>
     new AnthropicProvider(apiKey, model, {
       useNativeWebSearch,
       streamTimeoutMs,
@@ -84,6 +91,27 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       useNativeWebSearch,
       streamTimeoutMs,
     }),
+  zai: ({ apiKey, model, streamTimeoutMs }) =>
+    new OpenAIChatCompletionsProvider(apiKey, model, {
+      providerName: "zai",
+      providerLabel: "z.ai",
+      baseURL: "https://api.z.ai/api/paas/v4/",
+      streamTimeoutMs,
+    }),
+  deepseek: ({ apiKey, model, streamTimeoutMs }) =>
+    new OpenAIChatCompletionsProvider(apiKey, model, {
+      providerName: "deepseek",
+      providerLabel: "DeepSeek",
+      baseURL: "https://api.deepseek.com",
+      streamTimeoutMs,
+    }),
+  minimax: ({ apiKey, model, streamTimeoutMs }) =>
+    new OpenAIChatCompletionsProvider(apiKey, model, {
+      providerName: "minimax",
+      providerLabel: "MiniMax",
+      baseURL: "https://api.minimax.io/v1",
+      streamTimeoutMs,
+    }),
 };
 
 /**
@@ -138,7 +166,11 @@ export function buildProviderAdapter(
 export function createAdapterFromConnection(
   connection: ProviderConnection,
   resolvedAuth: ResolvedAuth,
-  opts: { model: string; streamTimeoutMs?: number; useNativeWebSearch?: boolean },
+  opts: {
+    model: string;
+    streamTimeoutMs?: number;
+    useNativeWebSearch?: boolean;
+  },
 ): Provider | null {
   const { provider } = connection;
   const entry = PROVIDER_CATALOG.find((e) => e.id === provider);
@@ -164,10 +196,15 @@ export function createAdapterFromConnection(
   });
   if (!adapter) return null;
 
-  const isProxy = baseURL !== undefined;
+  // Usage-attribution headers (`X-Vellum-*`) are only meaningful when the
+  // request is routed through the Vellum-managed proxy — they carry billing
+  // metadata for our own backend. Forwarding them to a third-party endpoint
+  // would leak internal Vellum metadata, so gate on the auth type:
+  // `platform` is the only auth that flows through our proxy.
+  const isManagedProxy = connection.auth.type === "platform";
   return new UsageTrackingProvider(
     new RetryProvider(adapter, {
-      forwardUsageAttributionHeaders: isProxy,
+      forwardUsageAttributionHeaders: isManagedProxy,
     }),
   );
 }

package/src/providers/inference/connections.ts

@@ -23,7 +23,11 @@ export function listConnections(
   filter?: { provider?: string },
 ): ProviderConnection[] {
   const rows = filter?.provider
-    ? db.select().from(providerConnections).where(eq(providerConnections.provider, filter.provider)).all()
+    ? db
+        .select()
+        .from(providerConnections)
+        .where(eq(providerConnections.provider, filter.provider))
+        .all()
     : db.select().from(providerConnections).all();
 
   return rows.flatMap((row) => {
@@ -32,15 +36,19 @@ export function listConnections(
     const provider = ConnectionProviderSchema.safeParse(row.provider);
     if (!provider.success) return [];
     const statusResult = ConnectionStatusSchema.safeParse(row.status);
-    const status: ConnectionStatus = statusResult.success ? statusResult.data : "active";
-    return [{
-      ...row,
-      auth: auth.data,
-      provider: provider.data,
-      status,
-      label: row.label ?? null,
-      isManaged: MANAGED_CONNECTION_NAMES.has(row.name),
-    }];
+    const status: ConnectionStatus = statusResult.success
+      ? statusResult.data
+      : "active";
+    return [
+      {
+        ...row,
+        auth: auth.data,
+        provider: provider.data,
+        status,
+        label: row.label ?? null,
+        isManaged: MANAGED_CONNECTION_NAMES.has(row.name),
+      },
+    ];
   });
 }
 
@@ -60,7 +68,9 @@ export function getConnection(
   const provider = ConnectionProviderSchema.safeParse(row.provider);
   if (!provider.success) return null;
   const statusResult = ConnectionStatusSchema.safeParse(row.status);
-  const status: ConnectionStatus = statusResult.success ? statusResult.data : "active";
+  const status: ConnectionStatus = statusResult.success
+    ? statusResult.data
+    : "active";
   return {
     ...row,
     auth: auth.data,
@@ -105,9 +115,14 @@ export type ConnectionDeleteError =
 export function createConnection(
   db: DrizzleDb,
   input: CreateConnectionInput,
-): { ok: true; connection: ProviderConnection } | { ok: false; error: ConnectionCreateError } {
+):
+  | { ok: true; connection: ProviderConnection }
+  | { ok: false; error: ConnectionCreateError } {
   if (!VALID_CONNECTION_PROVIDERS.includes(input.provider as never)) {
-    return { ok: false, error: { code: "invalid_provider", provider: input.provider } };
+    return {
+      ok: false,
+      error: { code: "invalid_provider", provider: input.provider },
+    };
   }
   // Safe cast: VALID_CONNECTION_PROVIDERS.includes() guards above.
   const provider = input.provider as ConnectionProvider;
@@ -130,15 +145,17 @@ export function createConnection(
   const label = input.label ?? null;
 
   const now = Date.now();
-  db.insert(providerConnections).values({
-    name: input.name,
-    provider,
-    auth: JSON.stringify(authResult.data),
-    status,
-    label,
-    createdAt: now,
-    updatedAt: now,
-  }).run();
+  db.insert(providerConnections)
+    .values({
+      name: input.name,
+      provider,
+      auth: JSON.stringify(authResult.data),
+      status,
+      label,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
 
   // Invalidate per-connection adapter cache so subsequent dispatch
   // resolves the freshly-inserted row's auth.
@@ -163,7 +180,9 @@ export function updateConnection(
   db: DrizzleDb,
   name: string,
   input: UpdateConnectionInput,
-): { ok: true; connection: ProviderConnection } | { ok: false; error: ConnectionUpdateError } {
+):
+  | { ok: true; connection: ProviderConnection }
+  | { ok: false; error: ConnectionUpdateError } {
   const existing = getConnection(db, name);
   if (!existing) {
     return { ok: false, error: { code: "not_found" } };
@@ -226,14 +245,20 @@ export function deleteConnection(
     return { ok: false, error: { code: "not_found" } };
   }
 
-  if (!opts.force && opts.referencingProfiles && opts.referencingProfiles.length > 0) {
+  if (
+    !opts.force &&
+    opts.referencingProfiles &&
+    opts.referencingProfiles.length > 0
+  ) {
     return {
       ok: false,
       error: { code: "has_references", count: opts.referencingProfiles.length },
     };
   }
 
-  db.delete(providerConnections).where(eq(providerConnections.name, name)).run();
+  db.delete(providerConnections)
+    .where(eq(providerConnections.name, name))
+    .run();
 
   // Evict cached adapter for the deleted connection name.
   clearConnectionProviderCache();
@@ -251,9 +276,24 @@ const CANONICAL_CONNECTIONS: Array<{
   auth: Auth;
   label: string;
 }> = [
-  { name: "anthropic-managed", provider: "anthropic", auth: { type: "platform" }, label: "Anthropic" },
-  { name: "openai-managed",    provider: "openai",    auth: { type: "platform" }, label: "OpenAI" },
-  { name: "gemini-managed",    provider: "gemini",    auth: { type: "platform" }, label: "Google Gemini" },
+  {
+    name: "anthropic-managed",
+    provider: "anthropic",
+    auth: { type: "platform" },
+    label: "Anthropic",
+  },
+  {
+    name: "openai-managed",
+    provider: "openai",
+    auth: { type: "platform" },
+    label: "OpenAI",
+  },
+  {
+    name: "gemini-managed",
+    provider: "gemini",
+    auth: { type: "platform" },
+    label: "Google Gemini",
+  },
 ];
 
 /**
@@ -323,7 +363,12 @@ export function seedCanonicalConnections(db: DrizzleDb): void {
     // user-set label.
     db.update(providerConnections)
       .set({ label, updatedAt: now })
-      .where(and(eq(providerConnections.name, name), isNull(providerConnections.label)))
+      .where(
+        and(
+          eq(providerConnections.name, name),
+          isNull(providerConnections.label),
+        ),
+      )
       .run();
   }
 }

package/src/providers/inference/resolve-auth.ts

@@ -11,7 +11,7 @@
 import {
   buildManagedBaseUrl,
   resolveManagedProxyContext,
-} from "../../providers/managed-proxy/context.js";
+} from "../../providers/platform-proxy/context.js";
 import { getSecureKeyAsync } from "../../security/secure-keys.js";
 import type { Auth, ResolvedAuth } from "./auth.js";
 
@@ -23,16 +23,24 @@ export type ResolveAuthError =
 export async function resolveAuth(
   auth: Auth,
   provider: string,
-): Promise<{ ok: true; resolved: ResolvedAuth } | { ok: false; error: ResolveAuthError }> {
+): Promise<
+  { ok: true; resolved: ResolvedAuth } | { ok: false; error: ResolveAuthError }
+> {
   switch (auth.type) {
     case "api_key": {
       const value = await getSecureKeyAsync(auth.credential);
       if (!value) {
-        return { ok: false, error: { code: "credential_not_found", credential: auth.credential } };
+        return {
+          ok: false,
+          error: { code: "credential_not_found", credential: auth.credential },
+        };
       }
       return {
         ok: true,
-        resolved: { kind: "header", headers: { Authorization: `Bearer ${value}` } },
+        resolved: {
+          kind: "header",
+          headers: { Authorization: `Bearer ${value}` },
+        },
       };
     }