workers-ai-provider 0.2.0 → 0.2.2

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 = {

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,6 +40,27 @@ 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.
@@ -72,6 +93,10 @@ interface WorkersAI {
      * Creates a model for text generation.
      **/
     chat(modelId: TextGenerationModels, settings?: WorkersAIChatSettings): WorkersAIChatLanguageModel;
+    /**
+     * Creates a model for image generation.
+     **/
+    image(modelId: ImageGenerationModels, settings?: WorkersAIImageSettings): WorkersAIImageModel;
 }
 /**
  * Create a Workers AI provider instance.

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"
         });
       }
@@ -307,7 +544,7 @@ var WorkersAIChatLanguageModel = class {
             if (chunk.usage) {
               usage = mapWorkersAIUsage(chunk);
             }
-            chunk.response.length && controller.enqueue({
+            chunk.response?.length && controller.enqueue({
               type: "text-delta",
               textDelta: chunk.response
             });
@@ -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,33 +606,94 @@ function lastMessageWasUser(messages) {
   return messages.length > 0 && messages[messages.length - 1].role === "user";
 }
 
-// src/utils.ts
-function createRun(accountId, apiKey) {
-  return async (model, inputs, options) => {
-    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}`;
-    const body = JSON.stringify(inputs);
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    };
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      body
-    });
-    if (options?.returnRawResponse) {
-      return response;
+// 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."
+      });
     }
-    if (inputs.stream === true) {
-      if (response.body) {
-        return response.body;
+    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: {}
       }
-      throw new Error("No readable body available for streaming.");
-    }
-    const data = await response.json();
-    return data.result;
+    };
+  }
+};
+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) {
@@ -411,28 +703,31 @@ function createWorkersAI(options) {
   } else {
     const { accountId, apiKey } = options;
     binding = {
-      run: createRun(accountId, apiKey)
+      run: createRun({ accountId, apiKey })
     };
   }
   if (!binding) {
-    throw new Error(
-      "Either a binding or credentials must be provided."
-    );
+    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
   });
-  const provider = function(modelId, settings) {
+  const createImageModel = (modelId, settings = {}) => new WorkersAIImageModel(modelId, settings, {
+    provider: "workersai.image",
+    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."
-      );
+      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 {