@providerprotocol/ai 0.0.18 → 0.0.20

package/dist/content-DEl3z_W2.d.ts

@@ -0,0 +1,276 @@
+/**
+ * @fileoverview Content block types for multimodal messages.
+ *
+ * Defines the various content block types that can be included in
+ * user and assistant messages, supporting text, images, audio, video,
+ * and arbitrary binary data.
+ *
+ * @module types/content
+ */
+/**
+ * Image source variants for ImageBlock.
+ *
+ * Images can be provided as base64-encoded strings, URLs, or raw bytes.
+ *
+ * @example
+ * ```typescript
+ * // Base64 encoded image
+ * const base64Source: ImageSource = {
+ *   type: 'base64',
+ *   data: 'iVBORw0KGgo...'
+ * };
+ *
+ * // URL reference
+ * const urlSource: ImageSource = {
+ *   type: 'url',
+ *   url: 'https://example.com/image.png'
+ * };
+ *
+ * // Raw bytes
+ * const bytesSource: ImageSource = {
+ *   type: 'bytes',
+ *   data: new Uint8Array([...])
+ * };
+ * ```
+ */
+type ImageSource = {
+    type: 'base64';
+    data: string;
+} | {
+    type: 'url';
+    url: string;
+} | {
+    type: 'bytes';
+    data: Uint8Array;
+};
+/**
+ * Text content block.
+ *
+ * The most common content block type, containing plain text content.
+ *
+ * @example
+ * ```typescript
+ * const textBlock: TextBlock = {
+ *   type: 'text',
+ *   text: 'Hello, world!'
+ * };
+ * ```
+ */
+interface TextBlock {
+    /** Discriminator for text blocks */
+    type: 'text';
+    /** The text content */
+    text: string;
+}
+/**
+ * Image content block.
+ *
+ * Contains an image with its source data and metadata.
+ *
+ * @example
+ * ```typescript
+ * const imageBlock: ImageBlock = {
+ *   type: 'image',
+ *   source: { type: 'url', url: 'https://example.com/photo.jpg' },
+ *   mimeType: 'image/jpeg',
+ *   width: 1920,
+ *   height: 1080
+ * };
+ * ```
+ */
+interface ImageBlock {
+    /** Discriminator for image blocks */
+    type: 'image';
+    /** The image data source */
+    source: ImageSource;
+    /** MIME type of the image (e.g., 'image/png', 'image/jpeg') */
+    mimeType: string;
+    /** Image width in pixels */
+    width?: number;
+    /** Image height in pixels */
+    height?: number;
+}
+/**
+ * Audio content block.
+ *
+ * Contains audio data with its metadata.
+ *
+ * @example
+ * ```typescript
+ * const audioBlock: AudioBlock = {
+ *   type: 'audio',
+ *   data: audioBytes,
+ *   mimeType: 'audio/mp3',
+ *   duration: 120.5
+ * };
+ * ```
+ */
+interface AudioBlock {
+    /** Discriminator for audio blocks */
+    type: 'audio';
+    /** Raw audio data */
+    data: Uint8Array;
+    /** MIME type of the audio (e.g., 'audio/mp3', 'audio/wav') */
+    mimeType: string;
+    /** Duration in seconds */
+    duration?: number;
+}
+/**
+ * Video content block.
+ *
+ * Contains video data with its metadata.
+ *
+ * @example
+ * ```typescript
+ * const videoBlock: VideoBlock = {
+ *   type: 'video',
+ *   data: videoBytes,
+ *   mimeType: 'video/mp4',
+ *   duration: 30,
+ *   width: 1920,
+ *   height: 1080
+ * };
+ * ```
+ */
+interface VideoBlock {
+    /** Discriminator for video blocks */
+    type: 'video';
+    /** Raw video data */
+    data: Uint8Array;
+    /** MIME type of the video (e.g., 'video/mp4', 'video/webm') */
+    mimeType: string;
+    /** Duration in seconds */
+    duration?: number;
+    /** Video width in pixels */
+    width?: number;
+    /** Video height in pixels */
+    height?: number;
+}
+/**
+ * Binary content block for arbitrary data.
+ *
+ * A generic block type for data that doesn't fit other categories.
+ *
+ * @example
+ * ```typescript
+ * const binaryBlock: BinaryBlock = {
+ *   type: 'binary',
+ *   data: pdfBytes,
+ *   mimeType: 'application/pdf',
+ *   metadata: { filename: 'document.pdf', pages: 10 }
+ * };
+ * ```
+ */
+interface BinaryBlock {
+    /** Discriminator for binary blocks */
+    type: 'binary';
+    /** Raw binary data */
+    data: Uint8Array;
+    /** MIME type of the data */
+    mimeType: string;
+    /** Additional metadata about the binary content */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Union of all content block types.
+ *
+ * Used when a function or property can accept any type of content block.
+ */
+type ContentBlock = TextBlock | ImageBlock | AudioBlock | VideoBlock | BinaryBlock;
+/**
+ * Content types allowed in user messages.
+ *
+ * Users can send any type of content block including binary data.
+ */
+type UserContent = TextBlock | ImageBlock | AudioBlock | VideoBlock | BinaryBlock;
+/**
+ * Content types allowed in assistant messages.
+ *
+ * Assistants can generate text and media but not arbitrary binary data.
+ */
+type AssistantContent = TextBlock | ImageBlock | AudioBlock | VideoBlock;
+/**
+ * Creates a text content block from a string.
+ *
+ * @param content - The text content
+ * @returns A TextBlock containing the provided text
+ *
+ * @example
+ * ```typescript
+ * const block = text('Hello, world!');
+ * // { type: 'text', text: 'Hello, world!' }
+ * ```
+ */
+declare function text(content: string): TextBlock;
+/**
+ * Type guard for TextBlock.
+ *
+ * @param block - The content block to check
+ * @returns True if the block is a TextBlock
+ *
+ * @example
+ * ```typescript
+ * if (isTextBlock(block)) {
+ *   console.log(block.text);
+ * }
+ * ```
+ */
+declare function isTextBlock(block: ContentBlock): block is TextBlock;
+/**
+ * Type guard for ImageBlock.
+ *
+ * @param block - The content block to check
+ * @returns True if the block is an ImageBlock
+ *
+ * @example
+ * ```typescript
+ * if (isImageBlock(block)) {
+ *   console.log(block.mimeType, block.width, block.height);
+ * }
+ * ```
+ */
+declare function isImageBlock(block: ContentBlock): block is ImageBlock;
+/**
+ * Type guard for AudioBlock.
+ *
+ * @param block - The content block to check
+ * @returns True if the block is an AudioBlock
+ *
+ * @example
+ * ```typescript
+ * if (isAudioBlock(block)) {
+ *   console.log(block.mimeType, block.duration);
+ * }
+ * ```
+ */
+declare function isAudioBlock(block: ContentBlock): block is AudioBlock;
+/**
+ * Type guard for VideoBlock.
+ *
+ * @param block - The content block to check
+ * @returns True if the block is a VideoBlock
+ *
+ * @example
+ * ```typescript
+ * if (isVideoBlock(block)) {
+ *   console.log(block.mimeType, block.duration);
+ * }
+ * ```
+ */
+declare function isVideoBlock(block: ContentBlock): block is VideoBlock;
+/**
+ * Type guard for BinaryBlock.
+ *
+ * @param block - The content block to check
+ * @returns True if the block is a BinaryBlock
+ *
+ * @example
+ * ```typescript
+ * if (isBinaryBlock(block)) {
+ *   console.log(block.mimeType, block.metadata);
+ * }
+ * ```
+ */
+declare function isBinaryBlock(block: ContentBlock): block is BinaryBlock;
+
+export { type AssistantContent as A, type BinaryBlock as B, type ContentBlock as C, type ImageBlock as I, type TextBlock as T, type UserContent as U, type VideoBlock as V, type AudioBlock as a, type ImageSource as b, isImageBlock as c, isAudioBlock as d, isVideoBlock as e, isBinaryBlock as f, isTextBlock as i, text as t };

package/dist/google/index.d.ts

@@ -1,4 +1,4 @@
-import { d as Provider } from '../provider-D5MO3-pS.js';
+import { d as Provider } from '../provider-BBMBZuGn.js';
 
 /**
  * Provider-specific parameters for Google Gemini API requests.
@@ -864,6 +864,8 @@ interface GoogleEmbedParams {
     title?: string;
     /** Output dimensionality */
     outputDimensionality?: number;
+    /** Whether to automatically truncate inputs exceeding token limits (default: true) */
+    autoTruncate?: boolean;
 }
 
 /**

package/dist/google/index.js

@@ -1,6 +1,9 @@
 import {
   createProvider
 } from "../chunk-MSR5P65T.js";
+import {
+  Image
+} from "../chunk-WAKD3OO5.js";
 import {
   AssistantMessage,
   isAssistantMessage,
@@ -11,14 +14,14 @@ import {
   parseSSEStream
 } from "../chunk-Z7RBRCRN.js";
 import {
-  doFetch,
-  doStreamFetch,
-  normalizeHttpError,
   resolveApiKey
-} from "../chunk-5FEAOEXV.js";
+} from "../chunk-P5IRTEM5.js";
 import {
-  UPPError
-} from "../chunk-DZQHVGNV.js";
+  UPPError,
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError
+} from "../chunk-U3FZWV4U.js";
 
 // src/providers/google/transform.ts
 function transformRequest(request, modelId) {
@@ -579,6 +582,9 @@ function createEmbeddingHandler() {
             if (request.params?.outputDimensionality !== void 0) {
               embedRequest.outputDimensionality = request.params.outputDimensionality;
             }
+            if (request.params?.autoTruncate !== void 0) {
+              embedRequest.autoTruncate = request.params.autoTruncate;
+            }
             return embedRequest;
           });
           const url = `${baseUrl}/models/${modelId}:batchEmbedContents?key=${apiKey}`;
@@ -622,6 +628,115 @@ function createEmbeddingHandler() {
   };
 }
 
+// src/providers/google/image.ts
+var GOOGLE_AI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+function getCapabilities() {
+  return {
+    generate: true,
+    streaming: false,
+    edit: false,
+    maxImages: 4
+  };
+}
+function createImageHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider().",
+          "INVALID_REQUEST",
+          "google",
+          "image"
+        );
+      }
+      const capabilities = getCapabilities();
+      const model = {
+        modelId,
+        capabilities,
+        get provider() {
+          return providerRef;
+        },
+        async generate(request) {
+          return executeGenerate(modelId, request);
+        }
+      };
+      return model;
+    }
+  };
+}
+async function executeGenerate(modelId, request) {
+  const apiKey = await resolveApiKey(
+    request.config,
+    "GOOGLE_API_KEY",
+    "google",
+    "image"
+  );
+  const baseUrl = request.config.baseUrl?.replace(/\/$/, "") ?? GOOGLE_AI_BASE_URL;
+  const url = `${baseUrl}/models/${modelId}:predict`;
+  const body = {
+    instances: [{
+      prompt: request.prompt
+    }],
+    parameters: buildParameters(request.params)
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    "x-goog-api-key": apiKey
+  };
+  if (request.config.headers) {
+    for (const [key, value] of Object.entries(request.config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
+  }
+  const response = await doFetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: request.signal
+  }, request.config, "google", "image");
+  const data = await response.json();
+  return transformResponse2(data);
+}
+function buildParameters(params) {
+  const parameters = {};
+  if (!params) return parameters;
+  if (params.sampleCount !== void 0) parameters.sampleCount = params.sampleCount;
+  if (params.imageSize !== void 0) parameters.imageSize = params.imageSize;
+  if (params.aspectRatio !== void 0) parameters.aspectRatio = params.aspectRatio;
+  if (params.personGeneration !== void 0) parameters.personGeneration = params.personGeneration;
+  if (params.safetyFilterLevel !== void 0) parameters.safetyFilterLevel = params.safetyFilterLevel;
+  if (params.addWatermark !== void 0) parameters.addWatermark = params.addWatermark;
+  if (params.negativePrompt !== void 0) parameters.negativePrompt = params.negativePrompt;
+  return parameters;
+}
+function transformResponse2(data) {
+  if (!data.predictions || data.predictions.length === 0) {
+    throw new UPPError(
+      "No images in response",
+      "PROVIDER_ERROR",
+      "google",
+      "image"
+    );
+  }
+  const images = data.predictions.map((prediction) => {
+    const mimeType = prediction.mimeType ?? "image/png";
+    const image = Image.fromBase64(prediction.bytesBase64Encoded, mimeType);
+    return { image };
+  });
+  return {
+    images,
+    usage: {
+      imagesGenerated: images.length
+    }
+  };
+}
+
 // src/providers/google/cache.ts
 var CACHE_API_BASE = "https://generativelanguage.googleapis.com/v1beta/cachedContents";
 async function create(options) {
@@ -757,7 +872,8 @@ var baseProvider = createProvider({
   version: "1.0.0",
   modalities: {
     llm: createLLMHandler(),
-    embedding: createEmbeddingHandler()
+    embedding: createEmbeddingHandler(),
+    image: createImageHandler()
   }
 });
 var google = Object.assign(baseProvider, { cache });