workers-ai-provider 0.4.0 → 0.5.0

package/dist/index.js

@@ -9,51 +9,7 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 
-// src/utils.ts
-function createRun(config) {
-  const { accountId, apiKey } = config;
-  return async function run(model, inputs, options) {
-    const { gateway, prefix, extraHeaders, returnRawResponse, ...passthroughOptions } = options || {};
-    const urlParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(passthroughOptions)) {
-      try {
-        const valueStr = value.toString();
-        if (!valueStr) {
-          continue;
-        }
-        urlParams.append(key, valueStr);
-      } catch (error) {
-        throw new Error(
-          `Value for option '${key}' is not able to be coerced into a string.`
-        );
-      }
-    }
-    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}${urlParams ? `?${urlParams}` : ""}`;
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    };
-    const body = JSON.stringify(inputs);
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      body
-    });
-    if (returnRawResponse) {
-      return response;
-    }
-    if (inputs.stream === true) {
-      if (response.body) {
-        return response.body;
-      }
-      throw new Error("No readable body available for streaming.");
-    }
-    const data = await response.json();
-    return data.result;
-  };
-}
-
-// src/workersai-chat-language-model.ts
+// src/autorag-chat-language-model.ts
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
@@ -117,24 +73,18 @@ function convertToWorkersAIChatMessages(prompt) {
             }
             default: {
               const exhaustiveCheck = part;
-              throw new Error(
-                `Unsupported part: ${exhaustiveCheck}`
-              );
+              throw new Error(`Unsupported part: ${exhaustiveCheck}`);
             }
           }
         }
         messages.push({
           role: "assistant",
           content: text,
-          tool_calls: toolCalls.length > 0 ? toolCalls.map(
-            ({
-              function: { name, arguments: args }
-            }) => ({
-              id: "null",
-              type: "function",
-              function: { name, arguments: args }
-            })
-          ) : void 0
+          tool_calls: toolCalls.length > 0 ? toolCalls.map(({ function: { name, arguments: args } }) => ({
+            id: "null",
+            type: "function",
+            function: { name, arguments: args }
+          })) : void 0
         });
         break;
       }
@@ -157,6 +107,18 @@ function convertToWorkersAIChatMessages(prompt) {
   return { messages, images };
 }
 
+// src/map-workersai-usage.ts
+function mapWorkersAIUsage(output) {
+  const usage = output.usage ?? {
+    prompt_tokens: 0,
+    completion_tokens: 0
+  };
+  return {
+    promptTokens: usage.prompt_tokens,
+    completionTokens: usage.completion_tokens
+  };
+}
+
 // ../../node_modules/.pnpm/fetch-event-stream@0.1.5/node_modules/fetch-event-stream/esm/deps/jsr.io/@std/streams/0.221.0/text_line_stream.js
 var _currentLine;
 var TextLineStream = class extends TransformStream {
@@ -250,19 +212,328 @@ async function* events(res, signal) {
   }
 }
 
-// src/map-workersai-usage.ts
-function mapWorkersAIUsage(output) {
-  const usage = output.usage ?? {
-    prompt_tokens: 0,
-    completion_tokens: 0
-  };
-  return {
-    promptTokens: usage.prompt_tokens,
-    completionTokens: usage.completion_tokens
+// src/streaming.ts
+function getMappedStream(response) {
+  const chunkEvent = events(response);
+  let usage = { promptTokens: 0, completionTokens: 0 };
+  return new ReadableStream({
+    async start(controller) {
+      for await (const event of chunkEvent) {
+        if (!event.data) {
+          continue;
+        }
+        if (event.data === "[DONE]") {
+          break;
+        }
+        const chunk = JSON.parse(event.data);
+        if (chunk.usage) {
+          usage = mapWorkersAIUsage(chunk);
+        }
+        chunk.response?.length && controller.enqueue({
+          type: "text-delta",
+          textDelta: chunk.response
+        });
+      }
+      controller.enqueue({
+        type: "finish",
+        finishReason: "stop",
+        usage
+      });
+      controller.close();
+    }
+  });
+}
+
+// src/utils.ts
+function createRun(config) {
+  const { accountId, apiKey } = config;
+  return async function run(model, inputs, options) {
+    const { gateway, prefix, extraHeaders, returnRawResponse, ...passthroughOptions } = options || {};
+    const urlParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(passthroughOptions)) {
+      try {
+        const valueStr = value.toString();
+        if (!valueStr) {
+          continue;
+        }
+        urlParams.append(key, valueStr);
+      } catch (error) {
+        throw new Error(
+          `Value for option '${key}' is not able to be coerced into a string.`
+        );
+      }
+    }
+    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}${urlParams ? `?${urlParams}` : ""}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    };
+    const body = JSON.stringify(inputs);
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body
+    });
+    if (returnRawResponse) {
+      return response;
+    }
+    if (inputs.stream === true) {
+      if (response.body) {
+        return response.body;
+      }
+      throw new Error("No readable body available for streaming.");
+    }
+    const data = await response.json();
+    return data.result;
   };
 }
+function prepareToolsAndToolChoice(mode) {
+  const tools = mode.tools?.length ? mode.tools : void 0;
+  if (tools == null) {
+    return { tools: void 0, tool_choice: 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,
+      // @ts-expect-error - parameters is not a property of tool
+      parameters: tool.parameters
+    }
+  }));
+  const toolChoice = mode.toolChoice;
+  if (toolChoice == null) {
+    return { tools: mappedTools, tool_choice: void 0 };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+      return { tools: mappedTools, tool_choice: type };
+    case "none":
+      return { tools: mappedTools, tool_choice: type };
+    case "required":
+      return { tools: mappedTools, tool_choice: "any" };
+    // 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"
+      };
+    default: {
+      const exhaustiveCheck = type;
+      throw new Error(`Unsupported tool choice type: ${exhaustiveCheck}`);
+    }
+  }
+}
+function lastMessageWasUser(messages) {
+  return messages.length > 0 && messages[messages.length - 1].role === "user";
+}
+function processToolCalls(output) {
+  if (output.tool_calls && Array.isArray(output.tool_calls)) {
+    return output.tool_calls.map((toolCall) => {
+      if (toolCall.function && toolCall.id) {
+        return {
+          toolCallType: "function",
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          args: typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments || {})
+        };
+      }
+      return {
+        toolCallType: "function",
+        toolCallId: toolCall.name,
+        toolName: toolCall.name,
+        args: typeof toolCall.arguments === "string" ? toolCall.arguments : JSON.stringify(toolCall.arguments || {})
+      };
+    });
+  }
+  return [];
+}
+
+// src/autorag-chat-language-model.ts
+var AutoRAGChatLanguageModel = class {
+  constructor(modelId, settings, config) {
+    __publicField(this, "specificationVersion", "v1");
+    __publicField(this, "defaultObjectGenerationMode", "json");
+    __publicField(this, "modelId");
+    __publicField(this, "settings");
+    __publicField(this, "config");
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  getArgs({
+    mode,
+    prompt,
+    frequencyPenalty,
+    presencePenalty
+  }) {
+    const type = mode.type;
+    const warnings = [];
+    if (frequencyPenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "frequencyPenalty"
+      });
+    }
+    if (presencePenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "presencePenalty"
+      });
+    }
+    const baseArgs = {
+      // model id:
+      model: this.modelId,
+      // messages:
+      messages: convertToWorkersAIChatMessages(prompt)
+    };
+    switch (type) {
+      case "regular": {
+        return {
+          args: { ...baseArgs, ...prepareToolsAndToolChoice(mode) },
+          warnings
+        };
+      }
+      case "object-json": {
+        return {
+          args: {
+            ...baseArgs,
+            response_format: {
+              type: "json_schema",
+              json_schema: mode.schema
+            },
+            tools: void 0
+          },
+          warnings
+        };
+      }
+      case "object-tool": {
+        return {
+          args: {
+            ...baseArgs,
+            tool_choice: "any",
+            tools: [{ type: "function", function: mode.tool }]
+          },
+          warnings
+        };
+      }
+      // @ts-expect-error - this is unreachable code
+      // TODO: fixme
+      case "object-grammar": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "object-grammar mode"
+        });
+      }
+      default: {
+        const exhaustiveCheck = type;
+        throw new Error(`Unsupported type: ${exhaustiveCheck}`);
+      }
+    }
+  }
+  async doGenerate(options) {
+    const { args, warnings } = this.getArgs(options);
+    const { messages } = convertToWorkersAIChatMessages(options.prompt);
+    const output = await this.config.binding.aiSearch({
+      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 }
+        }
+      }))
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = this.getArgs(options);
+    const { messages } = convertToWorkersAIChatMessages(options.prompt);
+    const query = messages.map(({ content, role }) => `${role}: ${content}`).join("\n\n");
+    const response = await this.config.binding.aiSearch({
+      query,
+      stream: true
+    });
+    return {
+      stream: getMappedStream(response),
+      rawCall: { rawPrompt: args.messages, rawSettings: args },
+      warnings
+    };
+  }
+};
+
+// src/workers-ai-embedding-model.ts
+import { TooManyEmbeddingValuesForCallError } from "@ai-sdk/provider";
+var WorkersAIEmbeddingModel = class {
+  constructor(modelId, settings, config) {
+    /**
+     * Semantic version of the {@link EmbeddingModelV1} specification implemented
+     * by this class. It never changes.
+     */
+    __publicField(this, "specificationVersion", "v1");
+    __publicField(this, "modelId");
+    __publicField(this, "config");
+    __publicField(this, "settings");
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  /**
+   * Provider name exposed for diagnostics and error reporting.
+   */
+  get provider() {
+    return this.config.provider;
+  }
+  get maxEmbeddingsPerCall() {
+    const maxEmbeddingsPerCall = this.modelId === "@cf/baai/bge-large-en-v1.5" ? 1500 : 3e3;
+    return this.settings.maxEmbeddingsPerCall ?? maxEmbeddingsPerCall;
+  }
+  get supportsParallelCalls() {
+    return this.settings.supportsParallelCalls ?? true;
+  }
+  async doEmbed({
+    values
+  }) {
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const { gateway, ...passthroughOptions } = this.settings;
+    const response = await this.config.binding.run(
+      this.modelId,
+      {
+        text: values
+      },
+      { gateway: this.config.gateway ?? gateway, ...passthroughOptions }
+    );
+    return {
+      embeddings: response.data
+    };
+  }
+};
 
 // src/workersai-chat-language-model.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 var WorkersAIChatLanguageModel = class {
   constructor(modelId, settings, config) {
     __publicField(this, "specificationVersion", "v1");
@@ -344,7 +615,7 @@ var WorkersAIChatLanguageModel = class {
       // @ts-expect-error - this is unreachable code
       // TODO: fixme
       case "object-grammar": {
-        throw new UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError2({
           functionality: "object-grammar mode"
         });
       }
@@ -357,9 +628,7 @@ var WorkersAIChatLanguageModel = class {
   async doGenerate(options) {
     const { args, warnings } = this.getArgs(options);
     const { gateway, safePrompt, ...passthroughOptions } = this.settings;
-    const { messages, images } = convertToWorkersAIChatMessages(
-      options.prompt
-    );
+    const { messages, images } = convertToWorkersAIChatMessages(options.prompt);
     if (images.length !== 0 && images.length !== 1) {
       throw new Error("Multiple images are not yet supported as input");
     }
@@ -395,9 +664,7 @@ var WorkersAIChatLanguageModel = class {
   }
   async doStream(options) {
     const { args, warnings } = this.getArgs(options);
-    const { messages, images } = convertToWorkersAIChatMessages(
-      options.prompt
-    );
+    const { messages, images } = convertToWorkersAIChatMessages(options.prompt);
     if (args.tools?.length && lastMessageWasUser(messages)) {
       const response2 = await this.doGenerate(options);
       if (response2 instanceof ReadableStream) {
@@ -457,106 +724,13 @@ var WorkersAIChatLanguageModel = class {
     if (!(response instanceof ReadableStream)) {
       throw new Error("This shouldn't happen");
     }
-    const chunkEvent = events(new Response(response));
-    let usage = { promptTokens: 0, completionTokens: 0 };
     return {
-      stream: new ReadableStream({
-        async start(controller) {
-          for await (const event of chunkEvent) {
-            if (!event.data) {
-              continue;
-            }
-            if (event.data === "[DONE]") {
-              break;
-            }
-            const chunk = JSON.parse(event.data);
-            if (chunk.usage) {
-              usage = mapWorkersAIUsage(chunk);
-            }
-            chunk.response?.length && controller.enqueue({
-              type: "text-delta",
-              textDelta: chunk.response
-            });
-          }
-          controller.enqueue({
-            type: "finish",
-            finishReason: "stop",
-            usage
-          });
-          controller.close();
-        }
-      }),
+      stream: getMappedStream(new Response(response)),
       rawCall: { rawPrompt: messages, rawSettings: args },
       warnings
     };
   }
 };
-function processToolCalls(output) {
-  if (output.tool_calls && Array.isArray(output.tool_calls)) {
-    return output.tool_calls.map((toolCall) => {
-      if (toolCall.function && toolCall.id) {
-        return {
-          toolCallType: "function",
-          toolCallId: toolCall.id,
-          toolName: toolCall.function.name,
-          args: typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments || {})
-        };
-      }
-      return {
-        toolCallType: "function",
-        toolCallId: toolCall.name,
-        toolName: toolCall.name,
-        args: typeof toolCall.arguments === "string" ? toolCall.arguments : JSON.stringify(toolCall.arguments || {})
-      };
-    });
-  }
-  return [];
-}
-function prepareToolsAndToolChoice(mode) {
-  const tools = mode.tools?.length ? mode.tools : void 0;
-  if (tools == null) {
-    return { tools: void 0, tool_choice: 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,
-      // @ts-expect-error - parameters is not a property of tool
-      parameters: tool.parameters
-    }
-  }));
-  const toolChoice = mode.toolChoice;
-  if (toolChoice == null) {
-    return { tools: mappedTools, tool_choice: void 0 };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-      return { tools: mappedTools, tool_choice: type };
-    case "none":
-      return { tools: mappedTools, tool_choice: type };
-    case "required":
-      return { tools: mappedTools, tool_choice: "any" };
-    // 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"
-      };
-    default: {
-      const exhaustiveCheck = type;
-      throw new Error(`Unsupported tool choice type: ${exhaustiveCheck}`);
-    }
-  }
-}
-function lastMessageWasUser(messages) {
-  return messages.length > 0 && messages[messages.length - 1].role === "user";
-}
 
 // src/workersai-image-model.ts
 var WorkersAIImageModel = class {
@@ -671,6 +845,11 @@ function createWorkersAI(options) {
     binding,
     gateway: options.gateway
   });
+  const createEmbeddingModel = (modelId, settings = {}) => new WorkersAIEmbeddingModel(modelId, settings, {
+    provider: "workersai.embedding",
+    binding,
+    gateway: options.gateway
+  });
   const provider = (modelId, settings) => {
     if (new.target) {
       throw new Error("The WorkersAI model function cannot be called with the new keyword.");
@@ -678,11 +857,30 @@ function createWorkersAI(options) {
     return createChatModel(modelId, settings);
   };
   provider.chat = createChatModel;
+  provider.embedding = createEmbeddingModel;
+  provider.textEmbedding = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
   provider.image = createImageModel;
   provider.imageModel = createImageModel;
   return provider;
 }
+function createAutoRAG(options) {
+  const binding = options.binding;
+  const createChatModel = (settings = {}) => new AutoRAGChatLanguageModel("@cf/meta/llama-3.3-70b-instruct-fp8-fast", settings, {
+    provider: "autorag.chat",
+    binding
+  });
+  const provider = (settings) => {
+    if (new.target) {
+      throw new Error("The WorkersAI model function cannot be called with the new keyword.");
+    }
+    return createChatModel(settings);
+  };
+  provider.chat = createChatModel;
+  return provider;
+}
 export {
+  createAutoRAG,
   createWorkersAI
 };
 //# sourceMappingURL=index.js.map