workers-ai-provider 0.0.1

package/dist/index.js

@@ -0,0 +1,614 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// node_modules/secure-json-parse/index.js
+var require_secure_json_parse = __commonJS({
+  "node_modules/secure-json-parse/index.js"(exports, module) {
+    "use strict";
+    var hasBuffer = typeof Buffer !== "undefined";
+    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+    function _parse(text, reviver, options) {
+      if (options == null) {
+        if (reviver !== null && typeof reviver === "object") {
+          options = reviver;
+          reviver = void 0;
+        }
+      }
+      if (hasBuffer && Buffer.isBuffer(text)) {
+        text = text.toString();
+      }
+      if (text && text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+      }
+      const obj = JSON.parse(text, reviver);
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      const protoAction = options && options.protoAction || "error";
+      const constructorAction = options && options.constructorAction || "error";
+      if (protoAction === "ignore" && constructorAction === "ignore") {
+        return obj;
+      }
+      if (protoAction !== "ignore" && constructorAction !== "ignore") {
+        if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
+        if (suspectProtoRx.test(text) === false) {
+          return obj;
+        }
+      } else {
+        if (suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      }
+      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
+    }
+    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+      let next = [obj];
+      while (next.length) {
+        const nodes = next;
+        next = [];
+        for (const node of nodes) {
+          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+            if (safe === true) {
+              return null;
+            } else if (protoAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.__proto__;
+          }
+          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+            if (safe === true) {
+              return null;
+            } else if (constructorAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.constructor;
+          }
+          for (const key in node) {
+            const value = node[key];
+            if (value && typeof value === "object") {
+              next.push(value);
+            }
+          }
+        }
+      }
+      return obj;
+    }
+    function parse(text, reviver, options) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, options);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    function safeParse(text, reviver) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, { safe: true });
+      } catch (_e) {
+        return null;
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    module.exports = parse;
+    module.exports.default = parse;
+    module.exports.parse = parse;
+    module.exports.safeParse = safeParse;
+    module.exports.scan = filter;
+  }
+});
+
+// src/workersai-chat-language-model.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+import { z as z2 } from "zod";
+
+// src/convert-to-workersai-chat-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+function convertToWorkersAIChatMessages(prompt) {
+  const messages = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        messages.push({ role: "system", content });
+        break;
+      }
+      case "user": {
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return part.text;
+              }
+              case "image": {
+                throw new UnsupportedFunctionalityError({
+                  functionality: "image-part"
+                });
+              }
+            }
+          }).join("")
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        const toolCalls = [];
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.args)
+                }
+              });
+              break;
+            }
+            default: {
+              const _exhaustiveCheck = part;
+              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
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          messages.push({
+            role: "tool",
+            name: toolResponse.toolName,
+            content: JSON.stringify(toolResponse.result)
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+
+// node_modules/@ai-sdk/provider-utils/node_modules/nanoid/non-secure/index.js
+var customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = "";
+    let i = size;
+    while (i--) {
+      id += alphabet[Math.random() * alphabet.length | 0];
+    }
+    return id;
+  };
+};
+
+// node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var import_secure_json_parse = __toESM(require_secure_json_parse(), 1);
+import { LoadAPIKeyError } from "@ai-sdk/provider";
+import { LoadSettingError } from "@ai-sdk/provider";
+import { JSONParseError, TypeValidationError as TypeValidationError2 } from "@ai-sdk/provider";
+import { TypeValidationError } from "@ai-sdk/provider";
+import { APICallError } from "@ai-sdk/provider";
+import { APICallError as APICallError2, EmptyResponseBodyError } from "@ai-sdk/provider";
+function extractResponseHeaders(response) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+var generateId = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+var validatorSymbol = Symbol("vercel.ai.validator");
+function validator(validate) {
+  return { [validatorSymbol]: true, validate };
+}
+function isValidator(value) {
+  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+}
+function zodValidator(zodSchema) {
+  return validator((value) => {
+    const result = zodSchema.safeParse(value);
+    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+  });
+}
+function validateTypes({
+  value,
+  schema: inputSchema
+}) {
+  const result = safeValidateTypes({ value, schema: inputSchema });
+  if (!result.success) {
+    throw new TypeValidationError({ value, cause: result.error });
+  }
+  return result.value;
+}
+function safeValidateTypes({
+  value,
+  schema: inputSchema
+}) {
+  const schema = isValidator(inputSchema) ? inputSchema : zodValidator(inputSchema);
+  try {
+    if (schema.validate == null) {
+      return { success: true, value };
+    }
+    const validationResult = schema.validate(value);
+    if (validationResult.success) {
+      return validationResult;
+    }
+    return {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: validationResult.error
+      })
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.isTypeValidationError(error) ? error : new TypeValidationError({ value, cause: error })
+    };
+  }
+}
+function parseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = import_secure_json_parse.default.parse(text);
+    if (schema == null) {
+      return value;
+    }
+    return validateTypes({ value, schema });
+  } catch (error) {
+    if (JSONParseError.isJSONParseError(error) || TypeValidationError2.isTypeValidationError(error)) {
+      throw error;
+    }
+    throw new JSONParseError({ text, cause: error });
+  }
+}
+var createJsonErrorResponseHandler = ({
+  errorSchema,
+  errorToMessage,
+  isRetryable
+}) => async ({ response, url, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const responseHeaders = extractResponseHeaders(response);
+  if (responseBody.trim() === "") {
+    return {
+      responseHeaders,
+      value: new APICallError2({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+  try {
+    const parsedError = parseJSON({
+      text: responseBody,
+      schema: errorSchema
+    });
+    return {
+      responseHeaders,
+      value: new APICallError2({
+        message: errorToMessage(parsedError),
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        data: parsedError,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
+      })
+    };
+  } catch (parseError) {
+    return {
+      responseHeaders,
+      value: new APICallError2({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+};
+
+// src/workersai-error.ts
+import { z } from "zod";
+var workersAIErrorDataSchema = z.object({
+  object: z.literal("error"),
+  message: z.string(),
+  type: z.string(),
+  param: z.string().nullable(),
+  code: z.string().nullable()
+});
+var workersAIFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: workersAIErrorDataSchema,
+  errorToMessage: (data) => data.message
+});
+
+// src/workersai-chat-language-model.ts
+import { events } from "fetch-event-stream";
+var WorkersAIChatLanguageModel = 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,
+    maxTokens,
+    temperature,
+    topP,
+    frequencyPenalty,
+    presencePenalty,
+    seed
+  }) {
+    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,
+      // model specific settings:
+      safe_prompt: this.settings.safePrompt,
+      // standardized settings:
+      max_tokens: maxTokens,
+      temperature,
+      top_p: topP,
+      random_seed: seed,
+      // messages:
+      messages: convertToWorkersAIChatMessages(prompt)
+    };
+    switch (type) {
+      case "regular": {
+        return {
+          args: { ...baseArgs, ...prepareToolsAndToolChoice(mode) },
+          warnings
+        };
+      }
+      case "object-json": {
+        return {
+          args: {
+            ...baseArgs,
+            response_format: { type: "json_object" }
+          },
+          warnings
+        };
+      }
+      case "object-tool": {
+        return {
+          args: {
+            ...baseArgs,
+            tool_choice: "any",
+            tools: [{ type: "function", function: mode.tool }]
+          },
+          warnings
+        };
+      }
+      case "object-grammar": {
+        throw new UnsupportedFunctionalityError2({
+          functionality: "object-grammar mode"
+        });
+      }
+      default: {
+        const _exhaustiveCheck = type;
+        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  async doGenerate(options) {
+    const { args, warnings } = this.getArgs(options);
+    console.warn(warnings);
+    const response = await this.config.binding.run(args.model, {
+      messages: args.messages
+    });
+    return {
+      text: response.response,
+      finishReason: "stop",
+      rawCall: { rawPrompt: args.messages, rawSettings: args },
+      usage: {
+        promptTokens: 0,
+        completionTokens: 0
+      }
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = this.getArgs(options);
+    const response = await this.config.binding.run(args.model, {
+      messages: args.messages,
+      stream: true
+    });
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          async transform(chunk, controller) {
+            const chunkToText = new TextDecoder().decode(
+              chunk
+            );
+            const chunks = events(new Response(chunkToText));
+            for await (const singleChunk of chunks) {
+              if (!singleChunk.data) {
+                continue;
+              }
+              if (singleChunk.data === "[DONE]") {
+                controller.enqueue({
+                  type: "finish",
+                  finishReason: "stop",
+                  usage: {
+                    promptTokens: 0,
+                    completionTokens: 0
+                  }
+                });
+                return;
+              }
+              const data = JSON.parse(singleChunk.data);
+              console.log("data", data);
+              controller.enqueue({
+                type: "text-delta",
+                textDelta: data.response ?? "DATALOSS"
+              });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason: "stop",
+              usage: {
+                promptTokens: 0,
+                completionTokens: 0
+              }
+            });
+          }
+        })
+      ),
+      rawCall: { rawPrompt: args.messages, rawSettings: args },
+      warnings
+    };
+  }
+};
+var workersAIChatResponseSchema = z2.object({
+  response: z2.string()
+});
+var workersAIChatChunkSchema = z2.instanceof(Uint8Array);
+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,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+  const toolChoice = mode.toolChoice;
+  if (toolChoice == null) {
+    return { tools: mappedTools, tool_choice: void 0 };
+  }
+  const type = toolChoice.type;
+  console.log(mode, 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" };
+    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}`);
+    }
+  }
+}
+
+// src/index.ts
+function createWorkersAIProvider(options) {
+  const createChatModel = (modelId, settings = {}) => new WorkersAIChatLanguageModel(modelId, settings, {
+    provider: "workerai.chat",
+    binding: options.binding
+  });
+  const provider = function(modelId, settings) {
+    if (new.target) {
+      throw new Error(
+        "The WorkersAI model function cannot be called with the new keyword."
+      );
+    }
+    return createChatModel(modelId, settings);
+  };
+  provider.chat = createChatModel;
+  return provider;
+}
+export {
+  createWorkersAIProvider
+};
+//# sourceMappingURL=index.js.map