@providerprotocol/ai 0.0.17 → 0.0.19

package/dist/index.js

@@ -1,6 +1,14 @@
+import {
+  aggregateUsage,
+  createTurn,
+  emptyUsage
+} from "./chunk-SKY2JLA7.js";
 import {
   createProvider
 } from "./chunk-MSR5P65T.js";
+import {
+  Image
+} from "./chunk-WAKD3OO5.js";
 import {
   AssistantMessage,
   Message,
@@ -10,7 +18,7 @@ import {
   isAssistantMessage,
   isToolResultMessage,
   isUserMessage
-} from "./chunk-SVYROCLD.js";
+} from "./chunk-UMKWXGO3.js";
 import {
   ExponentialBackoff,
   LinearBackoff,
@@ -22,62 +30,11 @@ import "./chunk-Z7RBRCRN.js";
 import {
   DynamicKey,
   RoundRobinKeys,
-  UPPError,
   WeightedKeys
-} from "./chunk-MOU4U3PO.js";
-
-// src/types/turn.ts
-function createTurn(messages, toolExecutions, usage, cycles, data) {
-  const response = messages.filter((m) => m.type === "assistant").pop();
-  if (!response) {
-    throw new Error("Turn must contain at least one assistant message");
-  }
-  return {
-    messages,
-    response,
-    toolExecutions,
-    usage,
-    cycles,
-    data
-  };
-}
-function emptyUsage() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    cacheReadTokens: 0,
-    cacheWriteTokens: 0,
-    cycles: []
-  };
-}
-function aggregateUsage(usages) {
-  const cycles = [];
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cacheReadTokens = 0;
-  let cacheWriteTokens = 0;
-  for (const usage of usages) {
-    inputTokens += usage.inputTokens;
-    outputTokens += usage.outputTokens;
-    cacheReadTokens += usage.cacheReadTokens;
-    cacheWriteTokens += usage.cacheWriteTokens;
-    cycles.push({
-      inputTokens: usage.inputTokens,
-      outputTokens: usage.outputTokens,
-      cacheReadTokens: usage.cacheReadTokens,
-      cacheWriteTokens: usage.cacheWriteTokens
-    });
-  }
-  return {
-    inputTokens,
-    outputTokens,
-    totalTokens: inputTokens + outputTokens,
-    cacheReadTokens,
-    cacheWriteTokens,
-    cycles
-  };
-}
+} from "./chunk-5FEAOEXV.js";
+import {
+  UPPError
+} from "./chunk-DZQHVGNV.js";
 
 // src/types/stream.ts
 function createStreamResult(generator, turnPromise, abortController) {
@@ -725,223 +682,85 @@ function createChunkedStream(model, inputs, params, config, options) {
 }
 
 // src/core/image.ts
-import { readFile } from "fs/promises";
-var Image = class _Image {
-  /** The underlying image source (bytes, base64, or URL) */
-  source;
-  /** MIME type of the image (e.g., 'image/jpeg', 'image/png') */
-  mimeType;
-  /** Image width in pixels, if known */
-  width;
-  /** Image height in pixels, if known */
-  height;
-  constructor(source, mimeType, width, height) {
-    this.source = source;
-    this.mimeType = mimeType;
-    this.width = width;
-    this.height = height;
-  }
-  /**
-   * Whether this image has data loaded in memory.
-   *
-   * Returns `false` for URL-sourced images that reference external resources.
-   * These must be fetched before their data can be accessed.
-   */
-  get hasData() {
-    return this.source.type !== "url";
-  }
-  /**
-   * Converts the image to a base64-encoded string.
-   *
-   * @returns The image data as a base64 string
-   * @throws {Error} When the source is a URL (data must be fetched first)
-   */
-  toBase64() {
-    if (this.source.type === "base64") {
-      return this.source.data;
-    }
-    if (this.source.type === "bytes") {
-      return btoa(
-        Array.from(this.source.data).map((b) => String.fromCharCode(b)).join("")
-      );
-    }
-    throw new Error("Cannot convert URL image to base64. Fetch the image first.");
-  }
-  /**
-   * Converts the image to a data URL suitable for embedding in HTML or CSS.
-   *
-   * @returns A data URL in the format `data:{mimeType};base64,{data}`
-   * @throws {Error} When the source is a URL (data must be fetched first)
-   */
-  toDataUrl() {
-    const base64 = this.toBase64();
-    return `data:${this.mimeType};base64,${base64}`;
-  }
-  /**
-   * Gets the image data as raw bytes.
-   *
-   * @returns The image data as a Uint8Array
-   * @throws {Error} When the source is a URL (data must be fetched first)
-   */
-  toBytes() {
-    if (this.source.type === "bytes") {
-      return this.source.data;
-    }
-    if (this.source.type === "base64") {
-      const binaryString = atob(this.source.data);
-      const bytes = new Uint8Array(binaryString.length);
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      return bytes;
-    }
-    throw new Error("Cannot get bytes from URL image. Fetch the image first.");
+function image(options) {
+  const { model: modelRef, config = {}, params } = options;
+  const provider = modelRef.provider;
+  if (!provider.modalities.image) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support image modality`,
+      "INVALID_REQUEST",
+      provider.name,
+      "image"
+    );
   }
-  /**
-   * Gets the URL for URL-sourced images.
-   *
-   * @returns The image URL
-   * @throws {Error} When the source is not a URL
-   */
-  toUrl() {
-    if (this.source.type === "url") {
-      return this.source.url;
+  const imageHandler = provider.modalities.image;
+  const boundModel = imageHandler.bind(modelRef.modelId);
+  const capabilities = boundModel.capabilities;
+  const instance = {
+    model: boundModel,
+    params,
+    capabilities,
+    async generate(input) {
+      const prompt = normalizeInput(input);
+      const response = await boundModel.generate({
+        prompt,
+        params,
+        config
+      });
+      return {
+        images: response.images,
+        metadata: response.metadata,
+        usage: response.usage
+      };
     }
-    throw new Error("This image does not have a URL source.");
-  }
-  /**
-   * Converts this Image to an ImageBlock for use in UPP messages.
-   *
-   * @returns An ImageBlock that can be included in message content arrays
-   */
-  toBlock() {
-    return {
-      type: "image",
-      source: this.source,
-      mimeType: this.mimeType,
-      width: this.width,
-      height: this.height
+  };
+  if (capabilities.streaming && boundModel.stream) {
+    const boundModelWithStream = boundModel;
+    instance.stream = function(input) {
+      const prompt = normalizeInput(input);
+      const abortController = new AbortController();
+      const providerStream = boundModelWithStream.stream({
+        prompt,
+        params,
+        config,
+        signal: abortController.signal
+      });
+      const resultPromise = providerStream.response.then((response) => ({
+        images: response.images,
+        metadata: response.metadata,
+        usage: response.usage
+      }));
+      return {
+        [Symbol.asyncIterator]: () => providerStream[Symbol.asyncIterator](),
+        result: resultPromise,
+        abort: () => abortController.abort()
+      };
     };
   }
-  /**
-   * Creates an Image by reading a file from disk.
-   *
-   * The file is read into memory as bytes. MIME type is automatically
-   * detected from the file extension.
-   *
-   * @param path - Path to the image file
-   * @returns Promise resolving to an Image with the file contents
-   *
-   * @example
-   * ```typescript
-   * const image = await Image.fromPath('./photos/vacation.jpg');
-   * ```
-   */
-  static async fromPath(path) {
-    const data = await readFile(path);
-    const mimeType = detectMimeType(path);
-    return new _Image(
-      { type: "bytes", data: new Uint8Array(data) },
-      mimeType
-    );
-  }
-  /**
-   * Creates an Image from a URL reference.
-   *
-   * The URL is stored as a reference and not fetched. Providers will handle
-   * URL-to-data conversion if needed. MIME type is detected from the URL
-   * path if not provided.
-   *
-   * @param url - URL pointing to the image
-   * @param mimeType - Optional MIME type override
-   * @returns An Image referencing the URL
-   *
-   * @example
-   * ```typescript
-   * const image = Image.fromUrl('https://example.com/logo.png');
-   * ```
-   */
-  static fromUrl(url, mimeType) {
-    const detected = mimeType || detectMimeTypeFromUrl(url);
-    return new _Image({ type: "url", url }, detected);
-  }
-  /**
-   * Creates an Image from raw byte data.
-   *
-   * @param data - The image data as a Uint8Array
-   * @param mimeType - The MIME type of the image
-   * @returns An Image containing the byte data
-   *
-   * @example
-   * ```typescript
-   * const image = Image.fromBytes(pngData, 'image/png');
-   * ```
-   */
-  static fromBytes(data, mimeType) {
-    return new _Image({ type: "bytes", data }, mimeType);
-  }
-  /**
-   * Creates an Image from a base64-encoded string.
-   *
-   * @param base64 - The base64-encoded image data (without data URL prefix)
-   * @param mimeType - The MIME type of the image
-   * @returns An Image containing the base64 data
-   *
-   * @example
-   * ```typescript
-   * const image = Image.fromBase64(base64String, 'image/jpeg');
-   * ```
-   */
-  static fromBase64(base64, mimeType) {
-    return new _Image({ type: "base64", data: base64 }, mimeType);
-  }
-  /**
-   * Creates an Image from an existing ImageBlock.
-   *
-   * Useful for converting content blocks received from providers back
-   * into Image instances for further processing.
-   *
-   * @param block - An ImageBlock from message content
-   * @returns An Image with the block's source and metadata
-   */
-  static fromBlock(block) {
-    return new _Image(
-      block.source,
-      block.mimeType,
-      block.width,
-      block.height
-    );
-  }
-};
-function detectMimeType(path) {
-  const ext = path.split(".").pop()?.toLowerCase();
-  switch (ext) {
-    case "jpg":
-    case "jpeg":
-      return "image/jpeg";
-    case "png":
-      return "image/png";
-    case "gif":
-      return "image/gif";
-    case "webp":
-      return "image/webp";
-    case "svg":
-      return "image/svg+xml";
-    case "bmp":
-      return "image/bmp";
-    case "ico":
-      return "image/x-icon";
-    default:
-      return "application/octet-stream";
+  if (capabilities.edit && boundModel.edit) {
+    const boundModelWithEdit = boundModel;
+    instance.edit = async function(input) {
+      const response = await boundModelWithEdit.edit({
+        image: input.image,
+        mask: input.mask,
+        prompt: input.prompt,
+        params,
+        config
+      });
+      return {
+        images: response.images,
+        metadata: response.metadata,
+        usage: response.usage
+      };
+    };
   }
+  return instance;
 }
-function detectMimeTypeFromUrl(url) {
-  try {
-    const pathname = new URL(url).pathname;
-    return detectMimeType(pathname);
-  } catch {
-    return "application/octet-stream";
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return input;
   }
+  return input.prompt;
 }
 
 // src/types/content.ts
@@ -1222,7 +1041,9 @@ var ai = {
   /** LLM instance factory */
   llm,
   /** Embedding instance factory */
-  embedding
+  embedding,
+  /** Image generation instance factory */
+  image
 };
 export {
   AssistantMessage,
@@ -1249,6 +1070,7 @@ export {
   createTurn,
   embedding,
   emptyUsage,
+  image,
   isAssistantMessage,
   isAudioBlock,
   isBinaryBlock,