ai 3.1.0-canary.2 → 3.1.0-canary.3

package/provider/dist/index.js

@@ -30,12 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // provider/index.ts
 var provider_exports = {};
 __export(provider_exports, {
-  OpenAI: () => OpenAI
+  OpenAI: () => OpenAI,
+  openai: () => openai
 });
 module.exports = __toCommonJS(provider_exports);
 
 // ai-model-specification/errors/api-call-error.ts
-var ApiCallError = class extends Error {
+var APICallError = class extends Error {
   constructor({
     message,
     url,
@@ -43,7 +44,11 @@ var ApiCallError = class extends Error {
     statusCode,
     responseBody,
     cause,
-    isRetryable = statusCode != null && (statusCode === 429 || statusCode >= 500),
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500),
+    // server error
     data
   }) {
     super(message);
@@ -291,8 +296,8 @@ var postJsonToApi = async ({
 }) => postToApi({
   url,
   headers: {
-    "Content-Type": "application/json",
-    ...headers
+    ...headers,
+    "Content-Type": "application/json"
   },
   body: {
     content: JSON.stringify(body),
@@ -311,9 +316,12 @@ var postToApi = async ({
   abortSignal
 }) => {
   try {
+    const definedHeaders = Object.fromEntries(
+      Object.entries(headers).filter(([_key, value]) => value != null)
+    );
     const response = await fetch(url, {
       method: "POST",
-      headers,
+      headers: definedHeaders,
       body: body.content,
       signal: abortSignal
     });
@@ -326,11 +334,11 @@ var postToApi = async ({
         });
       } catch (error) {
         if (error instanceof Error) {
-          if (error.name === "AbortError" || error instanceof ApiCallError) {
+          if (error.name === "AbortError" || error instanceof APICallError) {
             throw error;
           }
         }
-        throw new ApiCallError({
+        throw new APICallError({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -347,11 +355,11 @@ var postToApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (error.name === "AbortError" || error instanceof ApiCallError) {
+        if (error.name === "AbortError" || error instanceof APICallError) {
           throw error;
         }
       }
-      throw new ApiCallError({
+      throw new APICallError({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -368,12 +376,13 @@ var postToApi = async ({
     if (error instanceof TypeError && error.message === "fetch failed") {
       const cause = error.cause;
       if (cause != null) {
-        throw new ApiCallError({
+        throw new APICallError({
           message: `Cannot connect to API: ${cause.message}`,
           cause,
           url,
           requestBodyValues: body.values,
           isRetryable: true
+          // retry when network error
         });
       }
     }
@@ -390,7 +399,7 @@ var createJsonErrorResponseHandler = ({
 }) => async ({ response, url, requestBodyValues }) => {
   const responseBody = await response.text();
   if (responseBody.trim() === "") {
-    return new ApiCallError({
+    return new APICallError({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -404,7 +413,7 @@ var createJsonErrorResponseHandler = ({
       text: responseBody,
       schema: errorSchema
     });
-    return new ApiCallError({
+    return new APICallError({
       message: errorToMessage(parsedError),
       url,
       requestBodyValues,
@@ -414,7 +423,7 @@ var createJsonErrorResponseHandler = ({
       isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
     });
   } catch (parseError) {
-    return new ApiCallError({
+    return new APICallError({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -452,7 +461,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
     schema: responseSchema
   });
   if (!parsedResult.success) {
-    throw new ApiCallError({
+    throw new APICallError({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -515,7 +524,7 @@ function convertToOpenAIChatMessages(prompt) {
                 return {
                   type: "image_url",
                   image_url: {
-                    url: `data:${(_a = part.mimeType) != null ? _a : "image/jpeg"};base64,${convertUint8ArrayToBase64(part.image)}`
+                    url: part.image instanceof URL ? part.image.toString() : `data:${(_a = part.mimeType) != null ? _a : "image/jpeg"};base64,${convertUint8ArrayToBase64(part.image)}`
                   }
                 };
               }
@@ -588,25 +597,38 @@ var openAIErrorDataSchema = import_zod.z.object({
 });
 var openaiFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: 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 == null ? void 0 : error.error.type) !== "insufficient_quota"
+  errorToMessage: (data) => data.error.message
 });
 
+// provider/openai/map-openai-finish-reason.ts
+function mapOpenAIFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content-filter":
+      return "content-filter";
+    case "function_call":
+    case "tool-calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+
 // provider/openai/openai-chat-language-model.ts
 var OpenAIChatLanguageModel = class {
-  constructor(settings, config) {
+  constructor(modelId, settings, config) {
     this.specificationVersion = "v1";
     this.defaultObjectGenerationMode = "tool";
+    this.modelId = modelId;
     this.settings = settings;
     this.config = config;
   }
   get provider() {
     return this.config.provider;
   }
-  get modelId() {
-    return this.settings.id;
-  }
   getArgs({
     mode,
     prompt,
@@ -620,8 +642,11 @@ var OpenAIChatLanguageModel = class {
     var _a;
     const type = mode.type;
     const baseArgs = {
+      // model id:
+      model: this.modelId,
       // model specific settings:
-      ...this.config.mapSettings(this.settings),
+      logit_bias: this.settings.logitBias,
+      user: this.settings.user,
       // standardized settings:
       max_tokens: maxTokens,
       temperature: scale({
@@ -690,49 +715,54 @@ var OpenAIChatLanguageModel = class {
   }
   async doGenerate(options) {
     var _a, _b;
+    const args = this.getArgs(options);
     const response = await postJsonToApi({
       url: `${this.config.baseUrl}/chat/completions`,
-      headers: {
-        Authorization: `Bearer ${this.config.apiKey()}`
-      },
-      body: {
-        ...this.getArgs(options)
-      },
+      headers: this.config.headers(),
+      body: args,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         openAIChatResponseSchema
-      )
+      ),
+      abortSignal: options.abortSignal
     });
-    const message = response.choices[0].message;
+    const { messages: rawPrompt, ...rawSettings } = args;
+    const choice = response.choices[0];
     return {
-      text: (_a = message.content) != null ? _a : void 0,
-      toolCalls: (_b = message.tool_calls) == null ? void 0 : _b.map((toolCall) => ({
+      text: (_a = choice.message.content) != null ? _a : void 0,
+      toolCalls: (_b = choice.message.tool_calls) == null ? void 0 : _b.map((toolCall) => ({
         toolCallType: "function",
         toolCallId: toolCall.id,
         toolName: toolCall.function.name,
         args: toolCall.function.arguments
       })),
+      finishReason: mapOpenAIFinishReason(choice.finish_reason),
+      usage: {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens
+      },
+      rawCall: { rawPrompt, rawSettings },
       warnings: []
     };
   }
   async doStream(options) {
+    const args = this.getArgs(options);
     const response = await postJsonToApi({
       url: `${this.config.baseUrl}/chat/completions`,
-      headers: {
-        Authorization: `Bearer ${this.config.apiKey()}`
-      },
+      headers: this.config.headers(),
       body: {
-        ...this.getArgs(options),
+        ...args,
         stream: true
       },
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
         openaiChatChunkSchema
-      )
+      ),
+      abortSignal: options.abortSignal
     });
+    const { messages: rawPrompt, ...rawSettings } = args;
     const toolCalls = [];
     return {
-      warnings: [],
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
@@ -786,7 +816,9 @@ var OpenAIChatLanguageModel = class {
             }
           }
         })
-      )
+      ),
+      rawCall: { rawPrompt, rawSettings },
+      warnings: []
     };
   }
 };
@@ -932,18 +964,16 @@ ${user}:`]
 
 // provider/openai/openai-completion-language-model.ts
 var OpenAICompletionLanguageModel = class {
-  constructor(settings, config) {
+  constructor(modelId, settings, config) {
     this.specificationVersion = "v1";
     this.defaultObjectGenerationMode = void 0;
+    this.modelId = modelId;
     this.settings = settings;
     this.config = config;
   }
   get provider() {
     return this.config.provider;
   }
-  get modelId() {
-    return this.settings.id;
-  }
   getArgs({
     mode,
     inputFormat,
@@ -963,8 +993,13 @@ var OpenAICompletionLanguageModel = class {
       provider: this.provider
     });
     const baseArgs = {
+      // model id:
+      model: this.modelId,
       // model specific settings:
-      ...this.config.mapSettings(this.settings),
+      echo: this.settings.echo,
+      logit_bias: this.settings.logitBias,
+      suffix: this.settings.suffix,
+      user: this.settings.user,
       // standardized settings:
       max_tokens: maxTokens,
       temperature: scale({
@@ -1028,30 +1063,35 @@ var OpenAICompletionLanguageModel = class {
     }
   }
   async doGenerate(options) {
+    const args = this.getArgs(options);
     const response = await postJsonToApi({
       url: `${this.config.baseUrl}/completions`,
-      headers: {
-        Authorization: `Bearer ${this.config.apiKey()}`
-      },
-      body: {
-        ...this.getArgs(options)
-      },
+      headers: this.config.headers(),
+      body: args,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         openAICompletionResponseSchema
-      )
+      ),
+      abortSignal: options.abortSignal
     });
+    const { prompt: rawPrompt, ...rawSettings } = args;
+    const choice = response.choices[0];
     return {
-      text: response.choices[0].text,
+      text: choice.text,
+      usage: {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens
+      },
+      finishReason: mapOpenAIFinishReason(choice.finish_reason),
+      rawCall: { rawPrompt, rawSettings },
       warnings: []
     };
   }
   async doStream(options) {
+    const args = this.getArgs(options);
     const response = await postJsonToApi({
       url: `${this.config.baseUrl}/completions`,
-      headers: {
-        Authorization: `Bearer ${this.config.apiKey()}`
-      },
+      headers: this.config.headers(),
       body: {
         ...this.getArgs(options),
         stream: true
@@ -1059,10 +1099,11 @@ var OpenAICompletionLanguageModel = class {
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
         openaiCompletionChunkSchema
-      )
+      ),
+      abortSignal: options.abortSignal
     });
+    const { prompt: rawPrompt, ...rawSettings } = args;
     return {
-      warnings: [],
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
@@ -1080,7 +1121,9 @@ var OpenAICompletionLanguageModel = class {
             }
           }
         })
-      )
+      ),
+      rawCall: { rawPrompt, rawSettings },
+      warnings: []
     };
   }
 };
@@ -1109,48 +1152,43 @@ var openaiCompletionChunkSchema = import_zod3.z.object({
 
 // provider/openai/openai-facade.ts
 var OpenAI = class {
-  constructor({ baseUrl, apiKey } = {}) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.organization = options.organization;
   }
-  chat(settings) {
+  get baseConfig() {
     var _a;
-    return new OpenAIChatLanguageModel(settings, {
-      provider: "openai.chat",
+    return {
+      organization: this.organization,
       baseUrl: (_a = this.baseUrl) != null ? _a : "https://api.openai.com/v1",
-      apiKey: () => loadApiKey({
-        apiKey: this.apiKey,
-        environmentVariableName: "OPENAI_API_KEY",
-        description: "OpenAI"
-      }),
-      mapSettings: (settings2) => ({
-        model: settings2.id,
-        logit_bias: settings2.logitBias
-      })
-    });
-  }
-  completion(settings) {
-    var _a;
-    return new OpenAICompletionLanguageModel(
-      settings,
-      {
-        provider: "openai.completion",
-        baseUrl: (_a = this.baseUrl) != null ? _a : "https://api.openai.com/v1",
-        apiKey: () => loadApiKey({
+      headers: () => ({
+        Authorization: `Bearer ${loadApiKey({
           apiKey: this.apiKey,
           environmentVariableName: "OPENAI_API_KEY",
           description: "OpenAI"
-        }),
-        mapSettings: (settings2) => ({
-          model: settings2.id,
-          logit_bias: settings2.logitBias
-        })
-      }
-    );
+        })}`,
+        "OpenAI-Organization": this.organization
+      })
+    };
+  }
+  chat(modelId, settings = {}) {
+    return new OpenAIChatLanguageModel(modelId, settings, {
+      provider: "openai.chat",
+      ...this.baseConfig
+    });
+  }
+  completion(modelId, settings = {}) {
+    return new OpenAICompletionLanguageModel(modelId, settings, {
+      provider: "openai.completion",
+      ...this.baseConfig
+    });
   }
 };
+var openai = new OpenAI();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  OpenAI
+  OpenAI,
+  openai
 });
 //# sourceMappingURL=index.js.map