@wrongstack/providers 0.77.0 → 0.84.1

package/dist/index.d.ts

@@ -57,10 +57,10 @@ declare abstract class WireAdapter implements Provider {
 
 interface AnthropicProviderOptions {
     apiKey: string;
-    baseUrl?: string;
-    apiVersion?: string;
-    beta?: string[];
-    fetchImpl?: typeof fetch;
+    baseUrl?: string | undefined;
+    apiVersion?: string | undefined;
+    beta?: string[] | undefined;
+    fetchImpl?: typeof fetch | undefined;
 }
 declare class AnthropicProvider extends WireAdapter {
     readonly id = "anthropic";
@@ -86,10 +86,10 @@ interface OpenAIToolSchema {
 declare function toolsToOpenAI(tools: Tool[]): OpenAIToolSchema[];
 interface OpenAIMessage {
     role: 'system' | 'user' | 'assistant' | 'tool';
-    content?: string | OpenAIContent[];
-    tool_calls?: OpenAIToolCall[];
-    tool_call_id?: string;
-    name?: string;
+    content?: string | OpenAIContent[] | undefined;
+    tool_calls?: OpenAIToolCall[] | undefined;
+    tool_call_id?: string | undefined;
+    name?: string | undefined;
     /**
      * DeepSeek (and other OpenAI-compatible thinking-mode models) require the
      * previous assistant's chain-of-thought to be echoed back on the next
@@ -99,13 +99,13 @@ interface OpenAIMessage {
      * back to the API". Vanilla OpenAI ignores this field, so emitting it
      * unconditionally is safe.
      */
-    reasoning_content?: string;
+    reasoning_content?: string | undefined;
 }
 interface OpenAIContent {
     type: 'text' | 'image_url';
-    text?: string;
+    text?: string | undefined;
     image_url?: {
-        url: string;
+        url: string | undefined;
     };
 }
 interface OpenAIToolCall {
@@ -117,24 +117,24 @@ interface OpenAIToolCall {
     };
 }
 interface ConvertOptions {
-    flattenContentToString?: boolean;
-    stripCacheControl?: boolean;
-    systemAsMessage?: boolean;
-    emptyToolCallContent?: 'null' | 'empty_string';
+    flattenContentToString?: boolean | undefined;
+    stripCacheControl?: boolean | undefined;
+    systemAsMessage?: boolean | undefined;
+    emptyToolCallContent?: 'null' | 'empty_string' | undefined;
 }
 declare function messagesToOpenAI(system: TextBlock[] | undefined, messages: Message[], opts?: ConvertOptions): OpenAIMessage[];
 
 interface OpenAIProviderOptions {
     apiKey: string;
-    baseUrl?: string;
-    organization?: string;
-    fetchImpl?: typeof fetch;
+    baseUrl?: string | undefined;
+    organization?: string | undefined;
+    fetchImpl?: typeof fetch | undefined;
     quirks?: ConvertOptions & {
-        parallelToolsDisabled?: boolean;
-        jsonArgumentsBuggy?: boolean;
-    };
-    id?: string;
-    capabilities?: Partial<Capabilities>;
+        parallelToolsDisabled?: boolean | undefined;
+        jsonArgumentsBuggy?: boolean | undefined;
+    } | undefined;
+    id?: string | undefined;
+    capabilities?: Partial<Capabilities> | undefined;
 }
 declare class OpenAIProvider extends WireAdapter {
     readonly id: string;
@@ -157,28 +157,28 @@ declare class OpenAIProvider extends WireAdapter {
 }
 
 interface CompatibilityQuirks {
-    stripCacheControl?: boolean;
-    systemAsMessage?: boolean;
-    flattenContentToString?: boolean;
-    preserveToolCallIds?: boolean;
-    parallelToolsDisabled?: boolean;
-    jsonArgumentsBuggy?: boolean;
-    emptyToolCallContent?: 'null' | 'empty_string';
+    stripCacheControl?: boolean | undefined;
+    systemAsMessage?: boolean | undefined;
+    flattenContentToString?: boolean | undefined;
+    preserveToolCallIds?: boolean | undefined;
+    parallelToolsDisabled?: boolean | undefined;
+    jsonArgumentsBuggy?: boolean | undefined;
+    emptyToolCallContent?: 'null' | 'empty_string' | undefined;
 }
 interface OpenAICompatibleOptions {
     id: string;
     apiKey: string;
     baseUrl: string;
-    headers?: Record<string, string>;
-    quirks?: CompatibilityQuirks;
-    capabilities?: Partial<Capabilities>;
-    fetchImpl?: typeof fetch;
+    headers?: Record<string, string> | undefined;
+    quirks?: CompatibilityQuirks | undefined;
+    capabilities?: Partial<Capabilities> | undefined;
+    fetchImpl?: typeof fetch | undefined;
     /**
      * Optional override for URL construction. Receives the base URL and request,
      * returns the full URL to use. Allows custom providers with non-standard
      * URL structures (e.g. Google with model-in-path, Anthropic with /v1/messages).
      */
-    urlOverride?: (baseUrl: string, req: Request) => string;
+    urlOverride?: ((baseUrl: string, req: Request) => string) | undefined;
 }
 declare class OpenAICompatibleProvider extends OpenAIProvider {
     private readonly extraHeaders?;
@@ -208,10 +208,10 @@ declare class OpenAICompatibleProvider extends OpenAIProvider {
  */
 interface GoogleProviderOptions {
     apiKey: string;
-    baseUrl?: string;
-    fetchImpl?: typeof fetch;
-    id?: string;
-    capabilities?: Partial<Capabilities>;
+    baseUrl?: string | undefined;
+    fetchImpl?: typeof fetch | undefined;
+    id?: string | undefined;
+    capabilities?: Partial<Capabilities> | undefined;
 }
 declare class GoogleProvider extends WireAdapter {
     readonly id: string;
@@ -285,8 +285,8 @@ declare class WireFormatProvider<S = Record<string, unknown>> extends WireAdapte
     private readonly cfg;
     constructor(cfg: WireFormatConfig<S>, opts: {
         apiKey: string;
-        baseUrl?: string;
-        fetchImpl?: typeof fetch;
+        baseUrl?: string | undefined;
+        fetchImpl?: typeof fetch | undefined;
     });
     protected buildUrl(req: Request): string;
     protected buildHeaders(req: Request): Record<string, string>;
@@ -313,9 +313,9 @@ interface WireFactoryOptions {
      * reads `cfg.apiKey` (passed in at create time by the registry / config
      * loader). Setting this here is useful in tests.
      */
-    apiKey?: string;
+    apiKey?: string | undefined;
     /** Override the base URL at factory build time. */
-    baseUrl?: string;
+    baseUrl?: string | undefined;
 }
 /**
  * Build a `ProviderFactory` from a declarative wire-format. Plug into
@@ -328,8 +328,8 @@ interface MistralStreamState {
     model: string;
     started: boolean;
     toolCalls: Map<number, {
-        id?: string;
-        name?: string;
+        id?: string | undefined;
+        name?: string | undefined;
         partial: string;
         emittedStart: boolean;
         emittedArgLength: number;
@@ -346,8 +346,8 @@ interface AnthropicStreamState {
     stopped: boolean;
     blocks: Map<number, {
         kind: BlockKind;
-        id?: string;
-        name?: string;
+        id?: string | undefined;
+        name?: string | undefined;
         partial: string;
     }>;
 }
@@ -361,8 +361,8 @@ interface OpenAIStreamState {
     textOpen: boolean;
     thinkingOpen: boolean;
     toolByIndex: Map<number, {
-        id?: string;
-        name?: string;
+        id?: string | undefined;
+        name?: string | undefined;
         argBuf: string;
         emittedStart: boolean;
         emittedArgLength: number;
@@ -419,20 +419,20 @@ declare function toolsToAnthropic(tools: Tool[]): AnthropicToolSchema[];
 
 interface AnthropicBlock {
     type: string;
-    text?: string;
-    id?: string;
-    name?: string;
-    input?: unknown;
-    content?: unknown;
-    tool_use_id?: string;
-    is_error?: boolean;
-    thinking?: string;
-    signature?: string;
+    text?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    input?: unknown | undefined;
+    content?: unknown | undefined;
+    tool_use_id?: string | undefined;
+    is_error?: boolean | undefined;
+    thinking?: string | undefined;
+    signature?: string | undefined;
     source?: {
-        type?: 'base64' | 'url';
-        media_type?: string;
-        data?: string;
-        url?: string;
+        type?: 'base64' | 'url' | undefined;
+        media_type?: string | undefined;
+        data?: string | undefined;
+        url?: string | undefined;
     };
 }
 interface FromAnthropicOptions {
@@ -452,7 +452,7 @@ interface OpenAIChoice {
     message: {
         role: string;
         content: string | null;
-        tool_calls?: OpenAIToolCall[];
+        tool_calls?: OpenAIToolCall[] | undefined;
     };
     finish_reason: string | null;
 }
@@ -462,7 +462,7 @@ interface FromOpenAIOptions {
      * backward compatibility; the value is ignored.
      * TODO(breaking): remove in next major release.
      */
-    jsonArgumentsBuggy?: boolean;
+    jsonArgumentsBuggy?: boolean | undefined;
     /**
      * Called when a tool call's `arguments` field can't be parsed even after
      * the sanitizer pass. Callers can use this to emit a structured event,
@@ -482,7 +482,7 @@ declare function contentFromOpenAI(choice: OpenAIChoice, opts?: FromOpenAIOption
 interface BuildFactoriesOptions {
     registry: ModelsRegistry;
     /** Used to log unsupported families during boot. */
-    log?: Logger;
+    log?: Logger | undefined;
 }
 /**
  * Build one ProviderFactory per provider known to models.dev. The factory's

package/dist/index.js

@@ -1,4 +1,4 @@
-import { ProviderError, safeParse, sanitizeJsonString } from '@wrongstack/core';
+import { ProviderError, safeParse, sanitizeJsonString, WrongStackError, ERROR_CODES } from '@wrongstack/core';
 import { randomUUID } from 'crypto';
 
 var __defProp = Object.defineProperty;
@@ -129,6 +129,12 @@ var aggregate_exports = {};
 __export(aggregate_exports, {
   aggregateStream: () => aggregateStream
 });
+function expectDefined(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected value to be defined");
+  }
+  return value;
+}
 async function aggregateStream(stream, onEvent) {
   let model = "";
   let stopReason = "end_turn";
@@ -187,7 +193,7 @@ async function aggregateStream(stream, onEvent) {
           thinkingBuffers.push({ textBuf: "" });
         }
         if (ev.providerMeta && currentThinkingIndex >= 0) {
-          thinkingBuffers[currentThinkingIndex].providerMeta = ev.providerMeta;
+          expectDefined(thinkingBuffers[currentThinkingIndex]).providerMeta = ev.providerMeta;
         }
         blockOrder.push({ kind: "thinking", idx: currentThinkingIndex });
         break;
@@ -968,9 +974,11 @@ async function* parseGoogleStream(body, fallbackModel) {
       if (typeof part.text === "string" && part.text.length > 0) {
         yield { type: "text_delta", text: part.text };
       } else if (part.functionCall) {
+        const name = part.functionCall.name;
+        if (typeof name !== "string" || name.length === 0) continue;
         sawFunctionCall = true;
         const id = randomUUID();
-        yield { type: "tool_use_start", id, name: part.functionCall.name };
+        yield { type: "tool_use_start", id, name };
         const providerMeta = typeof part.thoughtSignature === "string" ? { "google.thoughtSignature": part.thoughtSignature } : void 0;
         yield {
           type: "tool_use_stop",
@@ -1291,6 +1299,29 @@ async function* parseOpenAIStream(body, fallbackModel) {
 }
 
 // src/openai-compatible.ts
+var VALID_QUIRK_KEYS = /* @__PURE__ */ new Set([
+  "stripCacheControl",
+  "systemAsMessage",
+  "flattenContentToString",
+  "preserveToolCallIds",
+  "parallelToolsDisabled",
+  "jsonArgumentsBuggy",
+  "emptyToolCallContent"
+]);
+function isCompatibilityQuirks(value) {
+  if (value === void 0) return true;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const obj = value;
+  for (const [key, v] of Object.entries(obj)) {
+    if (!VALID_QUIRK_KEYS.has(key)) return false;
+    if (key === "emptyToolCallContent") {
+      if (v !== "null" && v !== "empty_string") return false;
+    } else if (typeof v !== "boolean") {
+      return false;
+    }
+  }
+  return true;
+}
 var OpenAICompatibleProvider = class extends OpenAIProvider {
   extraHeaders;
   urlOverride;
@@ -1887,9 +1918,11 @@ var googleWireFormat = defineWireFormat({
       if (typeof part.text === "string" && part.text.length > 0) {
         out.push({ type: "text_delta", text: part.text });
       } else if (part.functionCall) {
+        const name = part.functionCall.name;
+        if (typeof name !== "string" || name.length === 0) continue;
         state.sawFunctionCall = true;
-        const id = `${part.functionCall.name}_${randomUUID().slice(0, 8)}`;
-        out.push({ type: "tool_use_start", id, name: part.functionCall.name });
+        const id = `${name}_${randomUUID().slice(0, 8)}`;
+        out.push({ type: "tool_use_start", id, name });
         const providerMeta = typeof part.thoughtSignature === "string" ? { "google.thoughtSignature": part.thoughtSignature } : void 0;
         out.push({
           type: "tool_use_stop",
@@ -2190,6 +2223,12 @@ function parseToolArguments(raw, toolName, toolCallId, opts) {
 }
 
 // src/index.ts
+function expectDefined2(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected value to be defined");
+  }
+  return value;
+}
 async function buildProviderFactoriesFromRegistry(opts) {
   const providers = await opts.registry.listProviders();
   const factories = [];
@@ -2213,7 +2252,7 @@ async function buildProviderFactoriesFromRegistry(opts) {
       apiKey: requireKey(cfg),
       baseUrl: cfg.baseUrl ?? "",
       headers: cfg.headers,
-      quirks: cfg.quirks
+      quirks: validateQuirks("openai-compatible", cfg.quirks)
     })
   });
   if (unsupported.length > 0 && opts.log) {
@@ -2245,24 +2284,24 @@ function makeProvider(p, cfg) {
   }
   switch (family) {
     case "anthropic":
-      return new AnthropicProvider({ apiKey, baseUrl });
+      return new AnthropicProvider({ apiKey: expectDefined2(apiKey), baseUrl });
     case "openai":
       return new OpenAIProvider({
-        apiKey,
+        apiKey: expectDefined2(apiKey),
         baseUrl,
         id: p.id,
-        quirks: cfg.quirks
+        quirks: validateQuirks(p.id, cfg.quirks)
       });
     case "openai-compatible":
       return new OpenAICompatibleProvider({
         id: p.id,
-        apiKey,
+        apiKey: expectDefined2(apiKey),
         baseUrl: baseUrl ?? "",
         headers: cfg.headers,
-        quirks: cfg.quirks
+        quirks: validateQuirks(p.id, cfg.quirks)
       });
     case "google":
-      return new GoogleProvider({ id: p.id, apiKey, baseUrl });
+      return new GoogleProvider({ id: p.id, apiKey: expectDefined2(apiKey), baseUrl });
   }
 }
 function makeProviderFromConfig(id, cfg) {
@@ -2292,6 +2331,15 @@ function requireKey(cfg) {
   if (cfg.apiKey) return cfg.apiKey;
   throw new Error("Provider config requires apiKey (or set the corresponding env var).");
 }
+function validateQuirks(providerId, quirks) {
+  if (quirks === void 0) return void 0;
+  if (isCompatibilityQuirks(quirks)) return quirks;
+  throw new WrongStackError({
+    message: `Invalid quirks for provider "${providerId}". Expected CompatibilityQuirks.`,
+    code: ERROR_CODES.CONFIG_INVALID,
+    subsystem: "provider"
+  });
+}
 
 export { AnthropicProvider, CAPABILITIES_BY_FAMILY, GoogleProvider, OpenAICompatibleProvider, OpenAIProvider, WireAdapter, WireFormatProvider, anthropicWireFormat, buildProviderFactoriesFromRegistry, capabilitiesFor, capabilitiesForFamily, contentFromAnthropic, contentFromOpenAI, createWireFormatFactory, defineWireFormat, googleWireFormat, makeProviderFromConfig, messagesToOpenAI, mistralWireFormat, normalizeAnthropic, normalizeOpenAI, openaiWireFormat, parseProviderHttpError, toolsToAnthropic, toolsToOpenAI };
 //# sourceMappingURL=index.js.map