workers-ai-provider 0.1.3 → 0.2.1

package/README.md

@@ -22,8 +22,7 @@ binding = "AI"
 Then in your Worker, import the factory function and create a new AI provider:
 
 ```ts
-// index.ts
-import { createWorkersAI } from "workers-ai-provider";
+import { createWorkersAI } from "../../../packages/workers-ai-provider/src";
 import { streamText } from "ai";
 
 type Env = {
@@ -58,6 +57,25 @@ export default {
 };
 ```
 
+You can also use your Cloudflare credentials to create the provider, for example if you want to use Cloudflare AI outside of the Worker environment. For example, here is how you can use Cloudflare AI in a Node script:
+
+```js
+const workersai = createWorkersAI({
+  accountId: process.env.CLOUDFLARE_ACCOUNT_ID,
+  apiKey: process.env.CLOUDFLARE_API_KEY
+});
+
+const text = await streamText({
+  model: workersai("@cf/meta/llama-2-7b-chat-int8"),
+  messages: [
+    {
+      role: "user",
+      content: "Write an essay about hello world",
+    },
+  ],
+});
+```
+
 For more info, refer to the documentation of the [Vercel AI SDK](https://sdk.vercel.ai/).
 
 ### Credits

package/dist/index.d.ts

@@ -1,11 +1,10 @@
-import { LanguageModelV1 } from '@ai-sdk/provider';
+import { LanguageModelV1, ImageModelV1 } from '@ai-sdk/provider';
 
 interface WorkersAIChatSettings {
     /**
-    Whether to inject a safety prompt before all conversations.
-    
-    Defaults to `false`.
-       */
+     * Whether to inject a safety prompt before all conversations.
+     * Defaults to `false`.
+     */
     safePrompt?: boolean;
     /**
      * Optionally set Cloudflare AI Gateway options.
@@ -18,6 +17,7 @@ interface WorkersAIChatSettings {
  * The names of the BaseAiTextGeneration models.
  */
 type TextGenerationModels = Exclude<value2key<AiModels, BaseAiTextGeneration>, value2key<AiModels, BaseAiTextToImage>>;
+type ImageGenerationModels = value2key<AiModels, BaseAiTextToImage>;
 type value2key<T, V> = {
     [K in keyof T]: T[K] extends V ? K : never;
 }[keyof T];
@@ -40,33 +40,67 @@ declare class WorkersAIChatLanguageModel implements LanguageModelV1 {
     doStream(options: Parameters<LanguageModelV1["doStream"]>[0]): Promise<Awaited<ReturnType<LanguageModelV1["doStream"]>>>;
 }
 
+type WorkersAIImageConfig = {
+    provider: string;
+    binding: Ai;
+    gateway?: GatewayOptions;
+};
+
+type WorkersAIImageSettings = {
+    maxImagesPerCall?: number;
+};
+
+declare class WorkersAIImageModel implements ImageModelV1 {
+    readonly modelId: ImageGenerationModels;
+    readonly settings: WorkersAIImageSettings;
+    readonly config: WorkersAIImageConfig;
+    readonly specificationVersion = "v1";
+    get maxImagesPerCall(): number;
+    get provider(): string;
+    constructor(modelId: ImageGenerationModels, settings: WorkersAIImageSettings, config: WorkersAIImageConfig);
+    doGenerate({ prompt, n, size, aspectRatio, seed, }: Parameters<ImageModelV1["doGenerate"]>[0]): Promise<Awaited<ReturnType<ImageModelV1["doGenerate"]>>>;
+}
+
+type WorkersAISettings = ({
+    /**
+     * Provide a Cloudflare AI binding.
+     */
+    binding: Ai;
+    /**
+     * Credentials must be absent when a binding is given.
+     */
+    accountId?: never;
+    apiKey?: never;
+} | {
+    /**
+     * Provide Cloudflare API credentials directly. Must be used if a binding is not specified.
+     */
+    accountId: string;
+    apiKey: string;
+    /**
+     * Both binding must be absent if credentials are used directly.
+     */
+    binding?: never;
+}) & {
+    /**
+     * Optionally specify a gateway.
+     */
+    gateway?: GatewayOptions;
+};
 interface WorkersAI {
     (modelId: TextGenerationModels, settings?: WorkersAIChatSettings): WorkersAIChatLanguageModel;
     /**
      * Creates a model for text generation.
      **/
     chat(modelId: TextGenerationModels, settings?: WorkersAIChatSettings): WorkersAIChatLanguageModel;
-}
-interface WorkersAISettings {
     /**
-     * Provide an `env.AI` binding to use for the AI inference.
-     * You can set up an AI bindings in your Workers project
-     * by adding the following this to `wrangler.toml`:
-  
-    ```toml
-  [ai]
-  binding = "AI"
-    ```
+     * Creates a model for image generation.
      **/
-    binding: Ai;
-    /**
-     * Optionally set Cloudflare AI Gateway options.
-     */
-    gateway?: GatewayOptions;
+    image(modelId: ImageGenerationModels, settings?: WorkersAIImageSettings): WorkersAIImageModel;
 }
 /**
  * Create a Workers AI provider instance.
- **/
+ */
 declare function createWorkersAI(options: WorkersAISettings): WorkersAI;
 
 export { type WorkersAI, type WorkersAISettings, createWorkersAI };

package/dist/index.js

@@ -1,17 +1,161 @@
 var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+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/workersai-chat-language-model.ts
-import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
-} from "@ai-sdk/provider";
-import { z } from "zod";
+// src/utils.ts
+function createRun(config) {
+  const { accountId, apiKey } = config;
+  return async function run(model, inputs, options) {
+    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    };
+    const body = JSON.stringify(inputs);
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body
+    });
+    if (options?.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;
+  };
+}
+
+// ../../node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name14,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name14;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+_a2 = symbol2;
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+_a3 = symbol3;
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+_a4 = symbol4;
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+_a5 = symbol5;
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+_a6 = symbol6;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+_a7 = symbol7;
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+_a8 = symbol8;
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+_a9 = symbol9;
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+_a10 = symbol10;
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+_a11 = symbol11;
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+_a12 = symbol12;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+_a13 = symbol13;
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var UnsupportedFunctionalityError = class extends AISDKError {
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`
+  }) {
+    super({ name: name13, message });
+    this[_a14] = true;
+    this.functionality = functionality;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker14);
+  }
+};
+_a14 = symbol14;
 
 // src/convert-to-workersai-chat-messages.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
 function convertToWorkersAIChatMessages(prompt) {
   const messages = [];
   for (const { role, content } of prompt) {
@@ -48,7 +192,10 @@ function convertToWorkersAIChatMessages(prompt) {
               break;
             }
             case "tool-call": {
-              text = JSON.stringify({ name: part.toolName, parameters: part.args });
+              text = JSON.stringify({
+                name: part.toolName,
+                parameters: part.args
+              });
               toolCalls.push({
                 id: part.toolCallId,
                 type: "function",
@@ -68,10 +215,10 @@ function convertToWorkersAIChatMessages(prompt) {
         messages.push({
           role: "assistant",
           content: text,
-          tool_calls: toolCalls.length > 0 ? toolCalls.map(({ function: { name, arguments: args } }) => ({
+          tool_calls: toolCalls.length > 0 ? toolCalls.map(({ function: { name: name14, arguments: args } }) => ({
             id: "null",
             type: "function",
-            function: { name, arguments: args }
+            function: { name: name14, arguments: args }
           })) : void 0
         });
         break;
@@ -95,8 +242,98 @@ function convertToWorkersAIChatMessages(prompt) {
   return messages;
 }
 
-// src/workersai-chat-language-model.ts
-import { events } from "fetch-event-stream";
+// ../../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 {
+  /** Constructs a new instance. */
+  constructor(options = { allowCR: false }) {
+    super({
+      transform: (chars, controller) => {
+        chars = __privateGet(this, _currentLine) + chars;
+        while (true) {
+          const lfIndex = chars.indexOf("\n");
+          const crIndex = options.allowCR ? chars.indexOf("\r") : -1;
+          if (crIndex !== -1 && crIndex !== chars.length - 1 && (lfIndex === -1 || lfIndex - 1 > crIndex)) {
+            controller.enqueue(chars.slice(0, crIndex));
+            chars = chars.slice(crIndex + 1);
+            continue;
+          }
+          if (lfIndex === -1)
+            break;
+          const endIndex = chars[lfIndex - 1] === "\r" ? lfIndex - 1 : lfIndex;
+          controller.enqueue(chars.slice(0, endIndex));
+          chars = chars.slice(lfIndex + 1);
+        }
+        __privateSet(this, _currentLine, chars);
+      },
+      flush: (controller) => {
+        if (__privateGet(this, _currentLine) === "")
+          return;
+        const currentLine = options.allowCR && __privateGet(this, _currentLine).endsWith("\r") ? __privateGet(this, _currentLine).slice(0, -1) : __privateGet(this, _currentLine);
+        controller.enqueue(currentLine);
+      }
+    });
+    __privateAdd(this, _currentLine, "");
+  }
+};
+_currentLine = new WeakMap();
+
+// ../../node_modules/fetch-event-stream/esm/utils.js
+function stream(input) {
+  let decoder = new TextDecoderStream();
+  let split2 = new TextLineStream({ allowCR: true });
+  return input.pipeThrough(decoder).pipeThrough(split2);
+}
+function split(input) {
+  let rgx = /[:]\s*/;
+  let match = rgx.exec(input);
+  let idx = match && match.index;
+  if (idx) {
+    return [
+      input.substring(0, idx),
+      input.substring(idx + match[0].length)
+    ];
+  }
+}
+
+// ../../node_modules/fetch-event-stream/esm/mod.js
+async function* events(res, signal) {
+  if (!res.body)
+    return;
+  let iter = stream(res.body);
+  let line, reader = iter.getReader();
+  let event;
+  for (; ; ) {
+    if (signal && signal.aborted) {
+      return reader.cancel();
+    }
+    line = await reader.read();
+    if (line.done)
+      return;
+    if (!line.value) {
+      if (event)
+        yield event;
+      event = void 0;
+      continue;
+    }
+    let [field, value] = split(line.value) || [];
+    if (!field)
+      continue;
+    if (field === "data") {
+      event || (event = {});
+      event[field] = event[field] ? event[field] + "\n" + value : value;
+    } else if (field === "event") {
+      event || (event = {});
+      event[field] = value;
+    } else if (field === "id") {
+      event || (event = {});
+      event[field] = +value || value;
+    } else if (field === "retry") {
+      event || (event = {});
+      event[field] = +value || void 0;
+    }
+  }
+}
 
 // src/map-workersai-usage.ts
 function mapWorkersAIUsage(output) {
@@ -195,7 +432,7 @@ var WorkersAIChatLanguageModel = class {
       // @ts-expect-error - this is unreachable code
       // TODO: fixme
       case "object-grammar": {
-        throw new UnsupportedFunctionalityError2({
+        throw new UnsupportedFunctionalityError({
           functionality: "object-grammar mode"
         });
       }
@@ -325,10 +562,6 @@ var WorkersAIChatLanguageModel = class {
     };
   }
 };
-var workersAIChatResponseSchema = z.object({
-  response: z.string()
-});
-var workersAIChatChunkSchema = z.instanceof(Uint8Array);
 function prepareToolsAndToolChoice(mode) {
   const tools = mode.tools?.length ? mode.tools : void 0;
   if (tools == null) {
@@ -360,9 +593,7 @@ function prepareToolsAndToolChoice(mode) {
     // so we filter the tools and force the tool choice through 'any'
     case "tool":
       return {
-        tools: mappedTools.filter(
-          (tool) => tool.function.name === toolChoice.toolName
-        ),
+        tools: mappedTools.filter((tool) => tool.function.name === toolChoice.toolName),
         tool_choice: "any"
       };
     default: {
@@ -375,22 +606,128 @@ function lastMessageWasUser(messages) {
   return messages.length > 0 && messages[messages.length - 1].role === "user";
 }
 
+// src/workersai-image-model.ts
+var WorkersAIImageModel = class {
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    __publicField(this, "specificationVersion", "v1");
+  }
+  get maxImagesPerCall() {
+    return this.settings.maxImagesPerCall ?? 1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed
+    // headers,
+    // abortSignal,
+  }) {
+    const { width, height } = getDimensionsFromSizeString(size);
+    const warnings = [];
+    if (aspectRatio != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "aspectRatio",
+        details: "This model does not support aspect ratio. Use `size` instead."
+      });
+    }
+    const generateImage = async () => {
+      const outputStream = await this.config.binding.run(
+        this.modelId,
+        {
+          prompt,
+          seed,
+          width,
+          height
+        }
+      );
+      return streamToUint8Array(outputStream);
+    };
+    const images = await Promise.all(
+      Array.from({ length: n }, () => generateImage())
+    );
+    return {
+      images,
+      warnings,
+      response: {
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId,
+        headers: {}
+      }
+    };
+  }
+};
+function getDimensionsFromSizeString(size) {
+  const [width, height] = size?.split("x") ?? [void 0, void 0];
+  return {
+    width: parseInteger(width),
+    height: parseInteger(height)
+  };
+}
+function parseInteger(value) {
+  if (value === "" || !value) return void 0;
+  const number = Number(value);
+  return Number.isInteger(number) ? number : void 0;
+}
+async function streamToUint8Array(stream2) {
+  const reader = stream2.getReader();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    totalLength += value.length;
+  }
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
 // src/index.ts
 function createWorkersAI(options) {
+  let binding;
+  if (options.binding) {
+    binding = options.binding;
+  } else {
+    const { accountId, apiKey } = options;
+    binding = {
+      run: createRun({ accountId, apiKey })
+    };
+  }
+  if (!binding) {
+    throw new Error("Either a binding or credentials must be provided.");
+  }
   const createChatModel = (modelId, settings = {}) => new WorkersAIChatLanguageModel(modelId, settings, {
     provider: "workersai.chat",
-    binding: options.binding,
+    binding,
+    gateway: options.gateway
+  });
+  const createImageModel = (modelId, settings = {}) => new WorkersAIImageModel(modelId, settings, {
+    provider: "workersai.image",
+    binding,
     gateway: options.gateway
   });
-  const provider = function(modelId, settings) {
+  const provider = (modelId, settings) => {
     if (new.target) {
-      throw new Error(
-        "The WorkersAI model function cannot be called with the new keyword."
-      );
+      throw new Error("The WorkersAI model function cannot be called with the new keyword.");
     }
     return createChatModel(modelId, settings);
   };
   provider.chat = createChatModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
   return provider;
 }
 export {