modelfusion 0.110.0 → 0.111.0

package/model-provider/ollama/OllamaTextEmbeddingModel.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { OllamaApiConfiguration } from "./OllamaApiConfiguration.js";
 import { failedOllamaCallResponseHandler } from "./OllamaError.js";
@@ -33,13 +34,21 @@ export class OllamaTextEmbeddingModel extends AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Ollama embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
+        const api = this.settings.api ?? new OllamaApiConfiguration();
+        const abortSignal = options?.run?.abortSignal;
         return callWithRetryAndThrottle({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callOllamaEmbeddingAPI({
-                ...this.settings,
-                abortSignal: options?.run?.abortSignal,
-                prompt: texts[0],
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => postJsonToApi({
+                url: api.assembleUrl(`/api/embeddings`),
+                headers: api.headers,
+                body: {
+                    model: this.settings.model,
+                    prompt: texts[0],
+                },
+                failedResponseHandler: failedOllamaCallResponseHandler,
+                successfulResponseHandler: createJsonResponseHandler(zodSchema(ollamaTextEmbeddingResponseSchema)),
+                abortSignal,
             }),
         });
     }
@@ -62,13 +71,3 @@ export class OllamaTextEmbeddingModel extends AbstractModel {
 const ollamaTextEmbeddingResponseSchema = z.object({
     embedding: z.array(z.number()),
 });
-async function callOllamaEmbeddingAPI({ api = new OllamaApiConfiguration(), abortSignal, model, prompt, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/api/embeddings`),
-        headers: api.headers,
-        body: { model, prompt },
-        failedResponseHandler: failedOllamaCallResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler(ollamaTextEmbeddingResponseSchema),
-        abortSignal,
-    });
-}

package/model-provider/openai/AbstractOpenAIChatModel.cjs

@@ -232,7 +232,7 @@ const openAIChatResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
-const openaiChatChunkSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({
+const openaiChatChunkSchema = zod_1.z.object({
     object: zod_1.z.literal("chat.completion.chunk"),
     id: zod_1.z.string(),
     choices: zod_1.z.array(zod_1.z.object({
@@ -271,20 +271,20 @@ const openaiChatChunkSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({
     created: zod_1.z.number(),
     model: zod_1.z.string(),
     system_fingerprint: zod_1.z.string().optional().nullable(),
-}));
+});
 exports.OpenAIChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
      */
     json: {
         stream: false,
-        handler: (0, postToApi_js_1.createJsonResponseHandler)(openAIChatResponseSchema),
+        handler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(openAIChatResponseSchema)),
     },
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
     deltaIterable: {
         stream: true,
-        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)(openaiChatChunkSchema),
+        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)((0, ZodSchema_js_1.zodSchema)(openaiChatChunkSchema)),
     },
 };

package/model-provider/openai/AbstractOpenAIChatModel.d.ts

@@ -461,7 +461,153 @@ declare const openAIChatResponseSchema: z.ZodObject<{
     system_fingerprint?: string | null | undefined;
 }>;
 export type OpenAIChatResponse = z.infer<typeof openAIChatResponseSchema>;
-declare const openaiChatChunkSchema: import("../../core/schema/ZodSchema.js").ZodSchema<{
+declare const openaiChatChunkSchema: z.ZodObject<{
+    object: z.ZodLiteral<"chat.completion.chunk">;
+    id: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        delta: z.ZodObject<{
+            role: z.ZodOptional<z.ZodEnum<["assistant", "user"]>>;
+            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            function_call: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                arguments: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            }, {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            }>>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    arguments: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    arguments: string;
+                }, {
+                    name: string;
+                    arguments: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        }, {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        }>;
+        finish_reason: z.ZodOptional<z.ZodNullable<z.ZodEnum<["stop", "length", "tool_calls", "content_filter", "function_call"]>>>;
+        index: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }, {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }>, "many">;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    system_fingerprint: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    object: "chat.completion.chunk";
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }[];
+    system_fingerprint?: string | null | undefined;
+}, {
     object: "chat.completion.chunk";
     model: string;
     id: string;
@@ -488,7 +634,7 @@ declare const openaiChatChunkSchema: import("../../core/schema/ZodSchema.js").Zo
     }[];
     system_fingerprint?: string | null | undefined;
 }>;
-export type OpenAIChatChunk = (typeof openaiChatChunkSchema)["_type"];
+export type OpenAIChatChunk = z.infer<typeof openaiChatChunkSchema>;
 export type OpenAIChatResponseFormatType<T> = {
     stream: boolean;
     handler: ResponseHandler<T>;

package/model-provider/openai/AbstractOpenAIChatModel.js

@@ -228,7 +228,7 @@ const openAIChatResponseSchema = z.object({
         total_tokens: z.number(),
     }),
 });
-const openaiChatChunkSchema = zodSchema(z.object({
+const openaiChatChunkSchema = z.object({
     object: z.literal("chat.completion.chunk"),
     id: z.string(),
     choices: z.array(z.object({
@@ -267,20 +267,20 @@ const openaiChatChunkSchema = zodSchema(z.object({
     created: z.number(),
     model: z.string(),
     system_fingerprint: z.string().optional().nullable(),
-}));
+});
 export const OpenAIChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
      */
     json: {
         stream: false,
-        handler: createJsonResponseHandler(openAIChatResponseSchema),
+        handler: createJsonResponseHandler(zodSchema(openAIChatResponseSchema)),
     },
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
     deltaIterable: {
         stream: true,
-        handler: createEventSourceResponseHandler(openaiChatChunkSchema),
+        handler: createEventSourceResponseHandler(zodSchema(openaiChatChunkSchema)),
     },
 };

package/model-provider/openai/AbstractOpenAICompletionModel.cjs

@@ -34,34 +34,32 @@ class AbstractOpenAICompletionModel extends AbstractModel_js_1.AbstractModel {
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
             retry: api.retry,
             throttle: api.throttle,
-            call: async () => {
-                return (0, postToApi_js_1.postJsonToApi)({
-                    url: api.assembleUrl("/completions"),
-                    headers: api.headers,
-                    body: {
-                        stream: openaiResponseFormat.stream,
-                        model: this.settings.model,
-                        prompt,
-                        suffix: this.settings.suffix,
-                        max_tokens: this.settings.maxGenerationTokens,
-                        temperature: this.settings.temperature,
-                        top_p: this.settings.topP,
-                        n: this.settings.numberOfGenerations,
-                        logprobs: this.settings.logprobs,
-                        echo: this.settings.echo,
-                        stop: stopSequences,
-                        seed: this.settings.seed,
-                        presence_penalty: this.settings.presencePenalty,
-                        frequency_penalty: this.settings.frequencyPenalty,
-                        best_of: this.settings.bestOf,
-                        logit_bias: this.settings.logitBias,
-                        user,
-                    },
-                    failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
-                    successfulResponseHandler: openaiResponseFormat.handler,
-                    abortSignal,
-                });
-            },
+            call: async () => (0, postToApi_js_1.postJsonToApi)({
+                url: api.assembleUrl("/completions"),
+                headers: api.headers,
+                body: {
+                    stream: openaiResponseFormat.stream,
+                    model: this.settings.model,
+                    prompt,
+                    suffix: this.settings.suffix,
+                    max_tokens: this.settings.maxGenerationTokens,
+                    temperature: this.settings.temperature,
+                    top_p: this.settings.topP,
+                    n: this.settings.numberOfGenerations,
+                    logprobs: this.settings.logprobs,
+                    echo: this.settings.echo,
+                    stop: stopSequences,
+                    seed: this.settings.seed,
+                    presence_penalty: this.settings.presencePenalty,
+                    frequency_penalty: this.settings.frequencyPenalty,
+                    best_of: this.settings.bestOf,
+                    logit_bias: this.settings.logitBias,
+                    user,
+                },
+                failedResponseHandler: OpenAIError_js_1.failedOpenAICallResponseHandler,
+                successfulResponseHandler: openaiResponseFormat.handler,
+                abortSignal,
+            }),
         });
     }
     async doGenerateTexts(prompt, options) {
@@ -133,7 +131,7 @@ const OpenAICompletionResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
-const openaiCompletionStreamChunkSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.object({
+const openaiCompletionStreamChunkSchema = zod_1.z.object({
     choices: zod_1.z.array(zod_1.z.object({
         text: zod_1.z.string(),
         finish_reason: zod_1.z
@@ -147,14 +145,14 @@ const openaiCompletionStreamChunkSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.
     model: zod_1.z.string(),
     system_fingerprint: zod_1.z.string().optional(),
     object: zod_1.z.literal("text_completion"),
-}));
+});
 exports.OpenAITextResponseFormat = {
     /**
      * Returns the response as a JSON object.
      */
     json: {
         stream: false,
-        handler: (0, postToApi_js_1.createJsonResponseHandler)(OpenAICompletionResponseSchema),
+        handler: (0, postToApi_js_1.createJsonResponseHandler)((0, ZodSchema_js_1.zodSchema)(OpenAICompletionResponseSchema)),
     },
     /**
      * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
@@ -162,6 +160,6 @@ exports.OpenAITextResponseFormat = {
      */
     deltaIterable: {
         stream: true,
-        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)(openaiCompletionStreamChunkSchema),
+        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)((0, ZodSchema_js_1.zodSchema)(openaiCompletionStreamChunkSchema)),
     },
 };

package/model-provider/openai/AbstractOpenAICompletionModel.js

@@ -31,34 +31,32 @@ export class AbstractOpenAICompletionModel extends AbstractModel {
         return callWithRetryAndThrottle({
             retry: api.retry,
             throttle: api.throttle,
-            call: async () => {
-                return postJsonToApi({
-                    url: api.assembleUrl("/completions"),
-                    headers: api.headers,
-                    body: {
-                        stream: openaiResponseFormat.stream,
-                        model: this.settings.model,
-                        prompt,
-                        suffix: this.settings.suffix,
-                        max_tokens: this.settings.maxGenerationTokens,
-                        temperature: this.settings.temperature,
-                        top_p: this.settings.topP,
-                        n: this.settings.numberOfGenerations,
-                        logprobs: this.settings.logprobs,
-                        echo: this.settings.echo,
-                        stop: stopSequences,
-                        seed: this.settings.seed,
-                        presence_penalty: this.settings.presencePenalty,
-                        frequency_penalty: this.settings.frequencyPenalty,
-                        best_of: this.settings.bestOf,
-                        logit_bias: this.settings.logitBias,
-                        user,
-                    },
-                    failedResponseHandler: failedOpenAICallResponseHandler,
-                    successfulResponseHandler: openaiResponseFormat.handler,
-                    abortSignal,
-                });
-            },
+            call: async () => postJsonToApi({
+                url: api.assembleUrl("/completions"),
+                headers: api.headers,
+                body: {
+                    stream: openaiResponseFormat.stream,
+                    model: this.settings.model,
+                    prompt,
+                    suffix: this.settings.suffix,
+                    max_tokens: this.settings.maxGenerationTokens,
+                    temperature: this.settings.temperature,
+                    top_p: this.settings.topP,
+                    n: this.settings.numberOfGenerations,
+                    logprobs: this.settings.logprobs,
+                    echo: this.settings.echo,
+                    stop: stopSequences,
+                    seed: this.settings.seed,
+                    presence_penalty: this.settings.presencePenalty,
+                    frequency_penalty: this.settings.frequencyPenalty,
+                    best_of: this.settings.bestOf,
+                    logit_bias: this.settings.logitBias,
+                    user,
+                },
+                failedResponseHandler: failedOpenAICallResponseHandler,
+                successfulResponseHandler: openaiResponseFormat.handler,
+                abortSignal,
+            }),
         });
     }
     async doGenerateTexts(prompt, options) {
@@ -129,7 +127,7 @@ const OpenAICompletionResponseSchema = z.object({
         total_tokens: z.number(),
     }),
 });
-const openaiCompletionStreamChunkSchema = zodSchema(z.object({
+const openaiCompletionStreamChunkSchema = z.object({
     choices: z.array(z.object({
         text: z.string(),
         finish_reason: z
@@ -143,14 +141,14 @@ const openaiCompletionStreamChunkSchema = zodSchema(z.object({
     model: z.string(),
     system_fingerprint: z.string().optional(),
     object: z.literal("text_completion"),
-}));
+});
 export const OpenAITextResponseFormat = {
     /**
      * Returns the response as a JSON object.
      */
     json: {
         stream: false,
-        handler: createJsonResponseHandler(OpenAICompletionResponseSchema),
+        handler: createJsonResponseHandler(zodSchema(OpenAICompletionResponseSchema)),
     },
     /**
      * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
@@ -158,6 +156,6 @@ export const OpenAITextResponseFormat = {
      */
     deltaIterable: {
         stream: true,
-        handler: createEventSourceResponseHandler(openaiCompletionStreamChunkSchema),
+        handler: createEventSourceResponseHandler(zodSchema(openaiCompletionStreamChunkSchema)),
     },
 };

package/model-provider/openai/AzureOpenAIApiConfiguration.d.ts

@@ -1,6 +1,14 @@
 import { AbstractApiConfiguration } from "../../core/api/AbstractApiConfiguration.js";
 import { RetryFunction } from "../../core/api/RetryFunction.js";
 import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
+export type AzureOpenAIApiConfigurationOptions = {
+    resourceName: string;
+    deploymentId: string;
+    apiVersion: string;
+    apiKey?: string;
+    retry?: RetryFunction;
+    throttle?: ThrottleFunction;
+};
 /**
  * Configuration for the Azure OpenAI API. This class is responsible for constructing URLs specific to the Azure OpenAI deployment.
  * It creates URLs of the form
@@ -13,13 +21,6 @@ export declare class AzureOpenAIApiConfiguration extends AbstractApiConfiguratio
     readonly deploymentId: string;
     readonly apiVersion: string;
     readonly headers: Record<string, string>;
-    constructor({ resourceName, deploymentId, apiVersion, apiKey, retry, throttle, }: {
-        resourceName: string;
-        deploymentId: string;
-        apiVersion: string;
-        apiKey?: string;
-        retry?: RetryFunction;
-        throttle?: ThrottleFunction;
-    });
+    constructor({ resourceName, deploymentId, apiVersion, apiKey, retry, throttle, }: AzureOpenAIApiConfigurationOptions);
     assembleUrl(path: string): string;
 }

package/model-provider/openai/OpenAIApiConfiguration.cjs

@@ -3,19 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIApiConfiguration = void 0;
 const BaseUrlApiConfiguration_js_1 = require("../../core/api/BaseUrlApiConfiguration.cjs");
 const loadApiKey_js_1 = require("../../core/api/loadApiKey.cjs");
-class OpenAIApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api.openai.com/v1", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the OpenAI API.
+ * It calls the API at https://api.openai.com/v1 and uses the `OPENAI_API_KEY` env variable by default.
+ */
+class OpenAIApiConfiguration extends BaseUrlApiConfiguration_js_1.BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
+            ...settings,
             headers: {
                 Authorization: `Bearer ${(0, loadApiKey_js_1.loadApiKey)({
-                    apiKey,
+                    apiKey: settings.apiKey,
                     environmentVariableName: "OPENAI_API_KEY",
                     description: "OpenAI",
                 })}`,
             },
-            retry,
-            throttle,
+            baseUrlDefaults: {
+                protocol: "https",
+                host: "api.openai.com",
+                port: "443",
+                path: "/v1",
+            },
         });
     }
 }

package/model-provider/openai/OpenAIApiConfiguration.d.ts

@@ -1,11 +1,10 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
-import { RetryFunction } from "../../core/api/RetryFunction.js";
-import { ThrottleFunction } from "../../core/api/ThrottleFunction.js";
-export declare class OpenAIApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl, apiKey, retry, throttle, }?: {
-        baseUrl?: string;
+import { BaseUrlApiConfigurationWithDefaults, PartialBaseUrlPartsApiConfigurationOptions } from "../../core/api/BaseUrlApiConfiguration.js";
+/**
+ * Creates an API configuration for the OpenAI API.
+ * It calls the API at https://api.openai.com/v1 and uses the `OPENAI_API_KEY` env variable by default.
+ */
+export declare class OpenAIApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings?: PartialBaseUrlPartsApiConfigurationOptions & {
         apiKey?: string;
-        retry?: RetryFunction;
-        throttle?: ThrottleFunction;
     });
 }

package/model-provider/openai/OpenAIApiConfiguration.js

@@ -1,18 +1,26 @@
-import { BaseUrlApiConfiguration } from "../../core/api/BaseUrlApiConfiguration.js";
+import { BaseUrlApiConfigurationWithDefaults, } from "../../core/api/BaseUrlApiConfiguration.js";
 import { loadApiKey } from "../../core/api/loadApiKey.js";
-export class OpenAIApiConfiguration extends BaseUrlApiConfiguration {
-    constructor({ baseUrl = "https://api.openai.com/v1", apiKey, retry, throttle, } = {}) {
+/**
+ * Creates an API configuration for the OpenAI API.
+ * It calls the API at https://api.openai.com/v1 and uses the `OPENAI_API_KEY` env variable by default.
+ */
+export class OpenAIApiConfiguration extends BaseUrlApiConfigurationWithDefaults {
+    constructor(settings = {}) {
         super({
-            baseUrl,
+            ...settings,
             headers: {
                 Authorization: `Bearer ${loadApiKey({
-                    apiKey,
+                    apiKey: settings.apiKey,
                     environmentVariableName: "OPENAI_API_KEY",
                     description: "OpenAI",
                 })}`,
             },
-            retry,
-            throttle,
+            baseUrlDefaults: {
+                protocol: "https",
+                host: "api.openai.com",
+                port: "443",
+                path: "/v1",
+            },
         });
     }
 }

package/model-provider/openai/OpenAIError.cjs

@@ -4,19 +4,19 @@ exports.failedOpenAICallResponseHandler = void 0;
 const zod_1 = require("zod");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
-const openAIErrorDataSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
+const openAIErrorDataSchema = zod_1.z.object({
     error: zod_1.z.object({
         message: zod_1.z.string(),
         type: zod_1.z.string(),
         param: zod_1.z.any().nullable(),
         code: zod_1.z.string().nullable(),
     }),
-}));
+});
 exports.failedOpenAICallResponseHandler = (0, postToApi_js_1.createJsonErrorResponseHandler)({
-    errorSchema: openAIErrorDataSchema,
-    errorToMessage: (error) => error.error.message,
-    isRetryable: (error, response) => (response.status === 429 &&
-        // insufficient_quota is also reported as a 429, but it's not retryable:
-        error.error.type !== "insufficient_quota") ||
-        response.status >= 500,
+    errorSchema: (0, ZodSchema_js_1.zodSchema)(openAIErrorDataSchema),
+    errorToMessage: (data) => data.error.message,
+    isRetryable: (response, error) => response.status >= 500 ||
+        (response.status === 429 &&
+            // insufficient_quota is also reported as a 429, but it's not retryable:
+            error?.error.type !== "insufficient_quota"),
 });

package/model-provider/openai/OpenAIError.d.ts

@@ -1,5 +1,29 @@
-import { ZodSchema } from "../../core/schema/ZodSchema.js";
-declare const openAIErrorDataSchema: ZodSchema<{
+import { z } from "zod";
+declare const openAIErrorDataSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        type: z.ZodString;
+        param: z.ZodNullable<z.ZodAny>;
+        code: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        code: string | null;
+        type: string;
+        param?: any;
+    }, {
+        message: string;
+        code: string | null;
+        type: string;
+        param?: any;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        message: string;
+        code: string | null;
+        type: string;
+        param?: any;
+    };
+}, {
     error: {
         message: string;
         code: string | null;
@@ -7,6 +31,6 @@ declare const openAIErrorDataSchema: ZodSchema<{
         param?: any;
     };
 }>;
-export type OpenAIErrorData = (typeof openAIErrorDataSchema)["_type"];
+export type OpenAIErrorData = z.infer<typeof openAIErrorDataSchema>;
 export declare const failedOpenAICallResponseHandler: import("../../core/api/postToApi.js").ResponseHandler<import("../../index.js").ApiCallError>;
 export {};