workers-ai-provider 0.6.3 → 0.7.0

package/dist/index.d.ts

@@ -90,7 +90,6 @@ type WorkersAIChatSettings = {
     safePrompt?: boolean;
     /**
      * Optionally set Cloudflare AI Gateway options.
-     * @deprecated
      */
     gateway?: GatewayOptions;
 } & {

package/dist/index.js

@@ -21,12 +21,11 @@ function convertToWorkersAIChatMessages(prompt) {
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
-        messages.push({ role: "system", content });
+        messages.push({ content, role: "system" });
         break;
       }
       case "user": {
         messages.push({
-          role: "user",
           content: content.map((part) => {
             switch (part.type) {
               case "text": {
@@ -35,15 +34,16 @@ function convertToWorkersAIChatMessages(prompt) {
               case "image": {
                 if (part.image instanceof Uint8Array) {
                   images.push({
-                    mimeType: part.mimeType,
                     image: part.image,
+                    mimeType: part.mimeType,
                     providerMetadata: part.providerMetadata
                   });
                 }
                 return "";
               }
             }
-          }).join("\n")
+          }).join("\n"),
+          role: "user"
         });
         break;
       }
@@ -56,34 +56,38 @@ function convertToWorkersAIChatMessages(prompt) {
               text += part.text;
               break;
             }
+            case "reasoning": {
+              text += part.text;
+              break;
+            }
             case "tool-call": {
               text = JSON.stringify({
                 name: part.toolName,
                 parameters: part.args
               });
               toolCalls.push({
-                id: part.toolCallId,
-                type: "function",
                 function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.args)
-                }
+                  arguments: JSON.stringify(part.args),
+                  name: part.toolName
+                },
+                id: part.toolCallId,
+                type: "function"
               });
               break;
             }
             default: {
               const exhaustiveCheck = part;
-              throw new Error(`Unsupported part: ${exhaustiveCheck}`);
+              throw new Error(`Unsupported part type: ${exhaustiveCheck.type}`);
             }
           }
         }
         messages.push({
-          role: "assistant",
           content: text,
+          role: "assistant",
           tool_calls: toolCalls.length > 0 ? toolCalls.map(({ function: { name, arguments: args } }) => ({
+            function: { arguments: args, name },
             id: "null",
-            type: "function",
-            function: { name, arguments: args }
+            type: "function"
           })) : void 0
         });
         break;
@@ -91,9 +95,9 @@ function convertToWorkersAIChatMessages(prompt) {
       case "tool": {
         for (const toolResponse of content) {
           messages.push({
-            role: "tool",
+            content: JSON.stringify(toolResponse.result),
             name: toolResponse.toolName,
-            content: JSON.stringify(toolResponse.result)
+            role: "tool"
           });
         }
         break;
@@ -104,18 +108,18 @@ function convertToWorkersAIChatMessages(prompt) {
       }
     }
   }
-  return { messages, images };
+  return { images, messages };
 }
 
 // src/map-workersai-usage.ts
 function mapWorkersAIUsage(output) {
   const usage = output.usage ?? {
-    prompt_tokens: 0,
-    completion_tokens: 0
+    completion_tokens: 0,
+    prompt_tokens: 0
   };
   return {
-    promptTokens: usage.prompt_tokens,
-    completionTokens: usage.completion_tokens
+    completionTokens: usage.completion_tokens,
+    promptTokens: usage.prompt_tokens
   };
 }
 
@@ -225,7 +229,7 @@ function createRun(config) {
           continue;
         }
         urlParams.append(key, valueStr);
-      } catch (error) {
+      } catch (_error) {
         throw new Error(
           `Value for option '${key}' is not able to be coerced into a string.`
         );
@@ -233,14 +237,14 @@ function createRun(config) {
     }
     const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}${urlParams ? `?${urlParams}` : ""}`;
     const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
     };
     const body = JSON.stringify(inputs);
     const response = await fetch(url, {
-      method: "POST",
+      body,
       headers,
-      body
+      method: "POST"
     });
     if (returnRawResponse) {
       return response;
@@ -258,36 +262,36 @@ function createRun(config) {
 function prepareToolsAndToolChoice(mode) {
   const tools = mode.tools?.length ? mode.tools : void 0;
   if (tools == null) {
-    return { tools: void 0, tool_choice: void 0 };
+    return { tool_choice: void 0, tools: void 0 };
   }
   const mappedTools = tools.map((tool) => ({
-    type: "function",
     function: {
-      name: tool.name,
       // @ts-expect-error - description is not a property of tool
       description: tool.description,
+      name: tool.name,
       // @ts-expect-error - parameters is not a property of tool
       parameters: tool.parameters
-    }
+    },
+    type: "function"
   }));
   const toolChoice = mode.toolChoice;
   if (toolChoice == null) {
-    return { tools: mappedTools, tool_choice: void 0 };
+    return { tool_choice: void 0, tools: mappedTools };
   }
   const type = toolChoice.type;
   switch (type) {
     case "auto":
-      return { tools: mappedTools, tool_choice: type };
+      return { tool_choice: type, tools: mappedTools };
     case "none":
-      return { tools: mappedTools, tool_choice: type };
+      return { tool_choice: type, tools: mappedTools };
     case "required":
-      return { tools: mappedTools, tool_choice: "any" };
+      return { tool_choice: "any", tools: mappedTools };
     // workersAI does not support tool mode directly,
     // so we filter the tools and force the tool choice through 'any'
     case "tool":
       return {
-        tools: mappedTools.filter((tool) => tool.function.name === toolChoice.toolName),
-        tool_choice: "any"
+        tool_choice: "any",
+        tools: mappedTools.filter((tool) => tool.function.name === toolChoice.toolName)
       };
     default: {
       const exhaustiveCheck = type;
@@ -304,12 +308,12 @@ function mergePartialToolCalls(partialCalls) {
     const index = partialCall.index;
     if (!mergedCallsByIndex[index]) {
       mergedCallsByIndex[index] = {
-        id: partialCall.id || "",
-        type: partialCall.type || "",
         function: {
-          name: partialCall.function?.name || "",
-          arguments: ""
-        }
+          arguments: "",
+          name: partialCall.function?.name || ""
+        },
+        id: partialCall.id || "",
+        type: partialCall.type || ""
       };
     } else {
       if (partialCall.id) {
@@ -331,17 +335,17 @@ function mergePartialToolCalls(partialCalls) {
 function processToolCall(toolCall) {
   if (toolCall.function && toolCall.id) {
     return {
-      toolCallType: "function",
+      args: typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments || {}),
       toolCallId: toolCall.id,
-      toolName: toolCall.function.name,
-      args: typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments || {})
+      toolCallType: "function",
+      toolName: toolCall.function.name
     };
   }
   return {
-    toolCallType: "function",
+    args: typeof toolCall.arguments === "string" ? toolCall.arguments : JSON.stringify(toolCall.arguments || {}),
     toolCallId: toolCall.name,
-    toolName: toolCall.name,
-    args: typeof toolCall.arguments === "string" ? toolCall.arguments : JSON.stringify(toolCall.arguments || {})
+    toolCallType: "function",
+    toolName: toolCall.name
   };
 }
 function processToolCalls(output) {
@@ -351,6 +355,12 @@ function processToolCalls(output) {
       return processedToolCall;
     });
   }
+  if (output?.choices?.[0]?.message?.tool_calls && Array.isArray(output.choices[0].message.tool_calls)) {
+    return output.choices[0].message.tool_calls.map((toolCall) => {
+      const processedToolCall = processToolCall(toolCall);
+      return processedToolCall;
+    });
+  }
   return [];
 }
 function processPartialToolCalls(partialToolCalls) {
@@ -361,7 +371,7 @@ function processPartialToolCalls(partialToolCalls) {
 // src/streaming.ts
 function getMappedStream(response) {
   const chunkEvent = events(response);
-  let usage = { promptTokens: 0, completionTokens: 0 };
+  let usage = { completionTokens: 0, promptTokens: 0 };
   const partialToolCalls = [];
   return new ReadableStream({
     async start(controller) {
@@ -380,8 +390,12 @@ function getMappedStream(response) {
           partialToolCalls.push(...chunk.tool_calls);
         }
         chunk.response?.length && controller.enqueue({
-          type: "text-delta",
-          textDelta: chunk.response
+          textDelta: chunk.response,
+          type: "text-delta"
+        });
+        chunk?.choices?.[0]?.delta?.reasoning_content?.length && controller.enqueue({
+          type: "reasoning",
+          textDelta: chunk.choices[0].delta.reasoning_content
         });
       }
       if (partialToolCalls.length > 0) {
@@ -394,8 +408,8 @@ function getMappedStream(response) {
         });
       }
       controller.enqueue({
-        type: "finish",
         finishReason: "stop",
+        type: "finish",
         usage
       });
       controller.close();
@@ -428,21 +442,21 @@ var AutoRAGChatLanguageModel = class {
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "frequencyPenalty"
+        setting: "frequencyPenalty",
+        type: "unsupported-setting"
       });
     }
     if (presencePenalty != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "presencePenalty"
+        setting: "presencePenalty",
+        type: "unsupported-setting"
       });
     }
     const baseArgs = {
-      // model id:
-      model: this.modelId,
       // messages:
-      messages: convertToWorkersAIChatMessages(prompt)
+      messages: convertToWorkersAIChatMessages(prompt),
+      // model id:
+      model: this.modelId
     };
     switch (type) {
       case "regular": {
@@ -456,8 +470,8 @@ var AutoRAGChatLanguageModel = class {
           args: {
             ...baseArgs,
             response_format: {
-              type: "json_schema",
-              json_schema: mode.schema
+              json_schema: mode.schema,
+              type: "json_schema"
             },
             tools: void 0
           },
@@ -469,7 +483,7 @@ var AutoRAGChatLanguageModel = class {
           args: {
             ...baseArgs,
             tool_choice: "any",
-            tools: [{ type: "function", function: mode.tool }]
+            tools: [{ function: mode.tool, type: "function" }]
           },
           warnings
         };
@@ -494,21 +508,21 @@ var AutoRAGChatLanguageModel = class {
       query: messages.map(({ content, role }) => `${role}: ${content}`).join("\n\n")
     });
     return {
-      text: output.response,
-      toolCalls: processToolCalls(output),
       finishReason: "stop",
-      // TODO: mapWorkersAIFinishReason(response.finish_reason),
       rawCall: { rawPrompt: args.messages, rawSettings: args },
-      usage: mapWorkersAIUsage(output),
-      warnings,
       sources: output.data.map(({ file_id, filename, score }) => ({
         id: file_id,
-        sourceType: "url",
-        url: filename,
         providerMetadata: {
           attributes: { score }
-        }
-      }))
+        },
+        sourceType: "url",
+        url: filename
+      })),
+      // TODO: mapWorkersAIFinishReason(response.finish_reason),
+      text: output.response,
+      toolCalls: processToolCalls(output),
+      usage: mapWorkersAIUsage(output),
+      warnings
     };
   }
   async doStream(options) {
@@ -520,8 +534,8 @@ var AutoRAGChatLanguageModel = class {
       stream: true
     });
     return {
-      stream: getMappedStream(response),
       rawCall: { rawPrompt: args.messages, rawSettings: args },
+      stream: getMappedStream(response),
       warnings
     };
   }
@@ -561,9 +575,9 @@ var WorkersAIEmbeddingModel = class {
   }) {
     if (values.length > this.maxEmbeddingsPerCall) {
       throw new TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        modelId: this.modelId,
+        provider: this.provider,
         values
       });
     }
@@ -650,26 +664,26 @@ var WorkersAIChatLanguageModel = class {
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "frequencyPenalty"
+        setting: "frequencyPenalty",
+        type: "unsupported-setting"
       });
     }
     if (presencePenalty != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "presencePenalty"
+        setting: "presencePenalty",
+        type: "unsupported-setting"
       });
     }
     const baseArgs = {
+      // standardized settings:
+      max_tokens: maxTokens,
       // model id:
       model: this.modelId,
+      random_seed: seed,
       // model specific settings:
       safe_prompt: this.settings.safePrompt,
-      // standardized settings:
-      max_tokens: maxTokens,
       temperature,
-      top_p: topP,
-      random_seed: seed
+      top_p: topP
     };
     switch (type) {
       case "regular": {
@@ -683,8 +697,8 @@ var WorkersAIChatLanguageModel = class {
           args: {
             ...baseArgs,
             response_format: {
-              type: "json_schema",
-              json_schema: mode.schema
+              json_schema: mode.schema,
+              type: "json_schema"
             },
             tools: void 0
           },
@@ -696,7 +710,7 @@ var WorkersAIChatLanguageModel = class {
           args: {
             ...baseArgs,
             tool_choice: "any",
-            tools: [{ type: "function", function: mode.tool }]
+            tools: [{ function: mode.tool, type: "function" }]
           },
           warnings
         };
@@ -725,8 +739,8 @@ var WorkersAIChatLanguageModel = class {
     const output = await this.config.binding.run(
       args.model,
       {
-        messages,
         max_tokens: args.max_tokens,
+        messages,
         temperature: args.temperature,
         tools: args.tools,
         top_p: args.top_p,
@@ -742,11 +756,13 @@ var WorkersAIChatLanguageModel = class {
       throw new Error("This shouldn't happen");
     }
     return {
-      text: typeof output.response === "object" && output.response !== null ? JSON.stringify(output.response) : output.response,
-      toolCalls: processToolCalls(output),
       finishReason: mapWorkersAIFinishReason(output),
       rawCall: { rawPrompt: messages, rawSettings: args },
       rawResponse: { body: output },
+      text: typeof output.response === "object" && output.response !== null ? JSON.stringify(output.response) : output.response,
+      toolCalls: processToolCalls(output),
+      // @ts-ignore: Missing types
+      reasoning: output?.choices?.[0]?.message?.reasoning_content,
       usage: mapWorkersAIUsage(output),
       warnings
     };
@@ -760,12 +776,13 @@ var WorkersAIChatLanguageModel = class {
         throw new Error("This shouldn't happen");
       }
       return {
+        rawCall: { rawPrompt: messages, rawSettings: args },
         stream: new ReadableStream({
           async start(controller) {
             if (response2.text) {
               controller.enqueue({
-                type: "text-delta",
-                textDelta: response2.text
+                textDelta: response2.text,
+                type: "text-delta"
               });
             }
             if (response2.toolCalls) {
@@ -776,15 +793,20 @@ var WorkersAIChatLanguageModel = class {
                 });
               }
             }
+            if (response2.reasoning && typeof response2.reasoning === "string") {
+              controller.enqueue({
+                type: "reasoning",
+                textDelta: response2.reasoning
+              });
+            }
             controller.enqueue({
-              type: "finish",
               finishReason: mapWorkersAIFinishReason(response2),
+              type: "finish",
               usage: response2.usage
             });
             controller.close();
           }
         }),
-        rawCall: { rawPrompt: messages, rawSettings: args },
         warnings
       };
     }
@@ -796,8 +818,8 @@ var WorkersAIChatLanguageModel = class {
     const response = await this.config.binding.run(
       args.model,
       {
-        messages,
         max_tokens: args.max_tokens,
+        messages,
         stream: true,
         temperature: args.temperature,
         tools: args.tools,
@@ -814,8 +836,8 @@ var WorkersAIChatLanguageModel = class {
       throw new Error("This shouldn't happen");
     }
     return {
-      stream: getMappedStream(new Response(response)),
       rawCall: { rawPrompt: messages, rawSettings: args },
+      stream: getMappedStream(new Response(response)),
       warnings
     };
   }
@@ -848,19 +870,19 @@ var WorkersAIImageModel = class {
     const warnings = [];
     if (aspectRatio != null) {
       warnings.push({
-        type: "unsupported-setting",
+        details: "This model does not support aspect ratio. Use `size` instead.",
         setting: "aspectRatio",
-        details: "This model does not support aspect ratio. Use `size` instead."
+        type: "unsupported-setting"
       });
     }
     const generateImage = async () => {
       const outputStream = await this.config.binding.run(
         this.modelId,
         {
+          height,
           prompt,
           seed,
-          width,
-          height
+          width
         }
       );
       return streamToUint8Array(outputStream);
@@ -870,20 +892,20 @@ var WorkersAIImageModel = class {
     );
     return {
       images,
-      warnings,
       response: {
-        timestamp: /* @__PURE__ */ new Date(),
+        headers: {},
         modelId: this.modelId,
-        headers: {}
-      }
+        timestamp: /* @__PURE__ */ new Date()
+      },
+      warnings
     };
   }
 };
 function getDimensionsFromSizeString(size) {
   const [width, height] = size?.split("x") ?? [void 0, void 0];
   return {
-    width: parseInteger(width),
-    height: parseInteger(height)
+    height: parseInteger(height),
+    width: parseInteger(width)
   };
 }
 function parseInteger(value) {
@@ -925,19 +947,19 @@ function createWorkersAI(options) {
     throw new Error("Either a binding or credentials must be provided.");
   }
   const createChatModel = (modelId, settings = {}) => new WorkersAIChatLanguageModel(modelId, settings, {
-    provider: "workersai.chat",
     binding,
-    gateway: options.gateway
+    gateway: options.gateway,
+    provider: "workersai.chat"
   });
   const createImageModel = (modelId, settings = {}) => new WorkersAIImageModel(modelId, settings, {
-    provider: "workersai.image",
     binding,
-    gateway: options.gateway
+    gateway: options.gateway,
+    provider: "workersai.image"
   });
   const createEmbeddingModel = (modelId, settings = {}) => new WorkersAIEmbeddingModel(modelId, settings, {
-    provider: "workersai.embedding",
     binding,
-    gateway: options.gateway
+    gateway: options.gateway,
+    provider: "workersai.embedding"
   });
   const provider = (modelId, settings) => {
     if (new.target) {
@@ -958,8 +980,8 @@ function createAutoRAG(options) {
   const createChatModel = (settings = {}) => (
     // @ts-ignore Needs fix from @cloudflare/workers-types for custom types
     new AutoRAGChatLanguageModel("@cf/meta/llama-3.3-70b-instruct-fp8-fast", settings, {
-      provider: "autorag.chat",
-      binding
+      binding,
+      provider: "autorag.chat"
     })
   );
   const provider = (settings) => {