@providerprotocol/ai 0.0.17 → 0.0.19

package/dist/chunk-DZQHVGNV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/errors.ts"],"sourcesContent":["/**\n * @fileoverview Error types for the Unified Provider Protocol.\n *\n * Provides normalized error codes and a unified error class for handling\n * errors across different AI providers in a consistent manner.\n *\n * @module types/errors\n */\n\n/**\n * Normalized error codes for cross-provider error handling.\n *\n * These codes provide a consistent way to identify and handle errors\n * regardless of which AI provider generated them.\n *\n * @example\n * ```typescript\n * try {\n *   await llm.generate('Hello');\n * } catch (error) {\n *   if (error instanceof UPPError) {\n *     switch (error.code) {\n *       case 'RATE_LIMITED':\n *         await delay(error.retryAfter);\n *         break;\n *       case 'AUTHENTICATION_FAILED':\n *         throw new Error('Invalid API key');\n *     }\n *   }\n * }\n * ```\n */\nexport type ErrorCode =\n  /** API key is invalid or expired */\n  | 'AUTHENTICATION_FAILED'\n  /** Rate limit exceeded, retry after delay */\n  | 'RATE_LIMITED'\n  /** Input exceeds model's context window */\n  | 'CONTEXT_LENGTH_EXCEEDED'\n  /** Requested model does not exist */\n  | 'MODEL_NOT_FOUND'\n  /** Request parameters are malformed */\n  | 'INVALID_REQUEST'\n  /** Provider returned an unexpected response format */\n  | 'INVALID_RESPONSE'\n  /** Content was blocked by safety filters */\n  | 'CONTENT_FILTERED'\n  /** Account quota or credits exhausted */\n  | 'QUOTA_EXCEEDED'\n  /** Provider-specific error not covered by other codes */\n  | 'PROVIDER_ERROR'\n  /** Network connectivity issue */\n  | 'NETWORK_ERROR'\n  /** Request exceeded timeout limit */\n  | 'TIMEOUT'\n  /** Request was cancelled via AbortSignal */\n  | 'CANCELLED';\n\n/**\n * Modality types supported by UPP.\n *\n * Each modality represents a different type of AI capability that\n * can be provided by a UPP-compatible provider.\n */\nexport type Modality =\n  /** Large language model for text generation */\n  | 'llm'\n  /** Text/image embedding model */\n  | 'embedding'\n  /** Image generation model */\n  | 'image'\n  /** Audio processing/generation model */\n  | 'audio'\n  /** Video processing/generation model */\n  | 'video';\n\n/**\n * Unified Provider Protocol Error.\n *\n * All provider-specific errors are normalized to this type, providing\n * a consistent interface for error handling across different AI providers.\n *\n * @example\n * ```typescript\n * throw new UPPError(\n *   'API key is invalid',\n *   'AUTHENTICATION_FAILED',\n *   'openai',\n *   'llm',\n *   401\n * );\n * ```\n *\n * @example\n * ```typescript\n * // Wrapping a provider error\n * try {\n *   await openai.chat.completions.create({ ... });\n * } catch (err) {\n *   throw new UPPError(\n *     'OpenAI request failed',\n *     'PROVIDER_ERROR',\n *     'openai',\n *     'llm',\n *     err.status,\n *     err\n *   );\n * }\n * ```\n */\nexport class UPPError extends Error {\n  /** Normalized error code for programmatic handling */\n  readonly code: ErrorCode;\n\n  /** Name of the provider that generated the error */\n  readonly provider: string;\n\n  /** The modality that was being used when the error occurred */\n  readonly modality: Modality;\n\n  /** HTTP status code from the provider's response, if available */\n  readonly statusCode?: number;\n\n  /** The original error that caused this UPPError, if wrapping another error */\n  override readonly cause?: Error;\n\n  /** Error class name, always 'UPPError' */\n  override readonly name = 'UPPError';\n\n  /**\n   * Creates a new UPPError instance.\n   *\n   * @param message - Human-readable error description\n   * @param code - Normalized error code for programmatic handling\n   * @param provider - Name of the provider that generated the error\n   * @param modality - The modality that was being used\n   * @param statusCode - HTTP status code from the provider's response\n   * @param cause - The original error being wrapped\n   */\n  constructor(\n    message: string,\n    code: ErrorCode,\n    provider: string,\n    modality: Modality,\n    statusCode?: number,\n    cause?: Error\n  ) {\n    super(message);\n    this.code = code;\n    this.provider = provider;\n    this.modality = modality;\n    this.statusCode = statusCode;\n    this.cause = cause;\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, UPPError);\n    }\n  }\n\n  /**\n   * Creates a string representation of the error.\n   *\n   * @returns Formatted error string including code, message, provider, and modality\n   */\n  override toString(): string {\n    let str = `UPPError [${this.code}]: ${this.message}`;\n    str += ` (provider: ${this.provider}, modality: ${this.modality}`;\n    if (this.statusCode) {\n      str += `, status: ${this.statusCode}`;\n    }\n    str += ')';\n    return str;\n  }\n\n  /**\n   * Converts the error to a JSON-serializable object.\n   *\n   * @returns Plain object representation suitable for logging or transmission\n   */\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      message: this.message,\n      code: this.code,\n      provider: this.provider,\n      modality: this.modality,\n      statusCode: this.statusCode,\n      cause: this.cause?.message,\n    };\n  }\n}\n"],"mappings":";AA8GO,IAAM,WAAN,MAAM,kBAAiB,MAAM;AAAA;AAAA,EAEzB;AAAA;AAAA,EAGA;AAAA;AAAA,EAGA;AAAA;AAAA,EAGA;AAAA;AAAA,EAGS;AAAA;AAAA,EAGA,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYzB,YACE,SACA,MACA,UACA,UACA,YACA,OACA;AACA,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,WAAW;AAChB,SAAK,WAAW;AAChB,SAAK,aAAa;AAClB,SAAK,QAAQ;AAEb,QAAI,MAAM,mBAAmB;AAC3B,YAAM,kBAAkB,MAAM,SAAQ;AAAA,IACxC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOS,WAAmB;AAC1B,QAAI,MAAM,aAAa,KAAK,IAAI,MAAM,KAAK,OAAO;AAClD,WAAO,eAAe,KAAK,QAAQ,eAAe,KAAK,QAAQ;AAC/D,QAAI,KAAK,YAAY;AACnB,aAAO,aAAa,KAAK,UAAU;AAAA,IACrC;AACA,WAAO;AACP,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAkC;AAChC,WAAO;AAAA,MACL,MAAM,KAAK;AAAA,MACX,SAAS,KAAK;AAAA,MACd,MAAM,KAAK;AAAA,MACX,UAAU,KAAK;AAAA,MACf,UAAU,KAAK;AAAA,MACf,YAAY,KAAK;AAAA,MACjB,OAAO,KAAK,OAAO;AAAA,IACrB;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-SKY2JLA7.js

@@ -0,0 +1,59 @@
+// 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
+  };
+}
+
+export {
+  createTurn,
+  emptyUsage,
+  aggregateUsage
+};
+//# sourceMappingURL=chunk-SKY2JLA7.js.map

package/dist/chunk-SKY2JLA7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/turn.ts"],"sourcesContent":["/**\n * @fileoverview Turn types for inference results.\n *\n * A Turn represents the complete result of one inference call, including\n * all messages produced during tool execution loops, token usage, and\n * optional structured output data.\n *\n * @module types/turn\n */\n\nimport type { Message, AssistantMessage } from './messages.ts';\nimport type { ToolExecution } from './tool.ts';\nimport type { MessageJSON } from './thread.ts';\n\n/**\n * Token usage information for an inference request.\n *\n * Tracks input and output tokens across all inference cycles,\n * with optional per-cycle breakdown and cache metrics.\n *\n * @example\n * ```typescript\n * const usage: TokenUsage = {\n *   inputTokens: 150,\n *   outputTokens: 50,\n *   totalTokens: 200,\n *   cacheReadTokens: 100,\n *   cacheWriteTokens: 50,\n *   cycles: [\n *     { inputTokens: 100, outputTokens: 30, cacheReadTokens: 0, cacheWriteTokens: 50 },\n *     { inputTokens: 50, outputTokens: 20, cacheReadTokens: 100, cacheWriteTokens: 0 }\n *   ]\n * };\n * ```\n */\nexport interface TokenUsage {\n  /** Total input tokens across all cycles */\n  inputTokens: number;\n\n  /** Total output tokens across all cycles */\n  outputTokens: number;\n\n  /** Sum of input and output tokens */\n  totalTokens: number;\n\n  /**\n   * Tokens read from cache (cache hits).\n   * Returns 0 for providers that don't support or report cache metrics.\n   */\n  cacheReadTokens: number;\n\n  /**\n   * Tokens written to cache (cache misses that were cached).\n   * Only Anthropic reports this metric; returns 0 for other providers.\n   */\n  cacheWriteTokens: number;\n\n  /** Per-cycle token breakdown (if multiple cycles occurred) */\n  cycles?: Array<{\n    inputTokens: number;\n    outputTokens: number;\n    cacheReadTokens: number;\n    cacheWriteTokens: number;\n  }>;\n}\n\n/**\n * A Turn represents the complete result of one inference call.\n *\n * Includes all messages produced during tool execution loops,\n * the final assistant response, token usage, and optional\n * structured output data.\n *\n * @typeParam TData - Type of the structured output data\n *\n * @example\n * ```typescript\n * const turn = await instance.generate('Hello');\n * console.log(turn.response.text);\n * console.log(`Used ${turn.usage.totalTokens} tokens in ${turn.cycles} cycles`);\n *\n * // With structured output\n * interface WeatherData { temperature: number; conditions: string; }\n * const turn = await instance.generate<WeatherData>('Get weather');\n * console.log(turn.data?.temperature);\n * ```\n */\nexport interface Turn<TData = unknown> {\n  /**\n   * All messages produced during this inference, in chronological order.\n   * Includes UserMessage, AssistantMessage (may include toolCalls), and ToolResultMessage.\n   */\n  readonly messages: Message[];\n\n  /** The final assistant response (last AssistantMessage in the turn) */\n  readonly response: AssistantMessage;\n\n  /** Tool executions that occurred during this turn */\n  readonly toolExecutions: ToolExecution[];\n\n  /** Aggregate token usage for the entire turn */\n  readonly usage: TokenUsage;\n\n  /** Total number of inference cycles (1 + number of tool rounds) */\n  readonly cycles: number;\n\n  /**\n   * Structured output data (if a structure schema was provided).\n   * Type is inferred from the schema when using TypeScript.\n   */\n  readonly data?: TData;\n}\n\n/**\n * Turn serialized to JSON format.\n * Messages are converted to MessageJSON, response is omitted (computed from messages).\n */\nexport type TurnJSON = Omit<Turn, 'messages' | 'response'> & {\n  messages: MessageJSON[];\n};\n\n/**\n * Creates a Turn from accumulated inference data.\n *\n * @typeParam TData - Type of the structured output data\n * @param messages - All messages produced during the inference\n * @param toolExecutions - Record of all tool executions\n * @param usage - Aggregate token usage\n * @param cycles - Number of inference cycles\n * @param data - Optional structured output data\n * @returns A complete Turn object\n * @throws Error if no assistant message is found in the messages\n *\n * @example\n * ```typescript\n * const turn = createTurn(\n *   [userMsg, assistantMsg],\n *   [],\n *   { inputTokens: 100, outputTokens: 50, totalTokens: 150 },\n *   1\n * );\n * ```\n */\nexport function createTurn<TData = unknown>(\n  messages: Message[],\n  toolExecutions: ToolExecution[],\n  usage: TokenUsage,\n  cycles: number,\n  data?: TData\n): Turn<TData> {\n  const response = messages\n    .filter((m): m is AssistantMessage => m.type === 'assistant')\n    .pop();\n\n  if (!response) {\n    throw new Error('Turn must contain at least one assistant message');\n  }\n\n  return {\n    messages,\n    response,\n    toolExecutions,\n    usage,\n    cycles,\n    data,\n  };\n}\n\n/**\n * Creates an empty TokenUsage object.\n *\n * @returns A TokenUsage with all values set to zero\n *\n * @example\n * ```typescript\n * const usage = emptyUsage();\n * // { inputTokens: 0, outputTokens: 0, totalTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cycles: [] }\n * ```\n */\nexport function emptyUsage(): TokenUsage {\n  return {\n    inputTokens: 0,\n    outputTokens: 0,\n    totalTokens: 0,\n    cacheReadTokens: 0,\n    cacheWriteTokens: 0,\n    cycles: [],\n  };\n}\n\n/**\n * Aggregates token usage from multiple inference cycles.\n *\n * @param usages - Array of TokenUsage objects to aggregate\n * @returns Combined TokenUsage with per-cycle breakdown\n *\n * @example\n * ```typescript\n * const cycle1 = { inputTokens: 100, outputTokens: 30, totalTokens: 130, cacheReadTokens: 50, cacheWriteTokens: 0 };\n * const cycle2 = { inputTokens: 150, outputTokens: 40, totalTokens: 190, cacheReadTokens: 100, cacheWriteTokens: 0 };\n * const total = aggregateUsage([cycle1, cycle2]);\n * // { inputTokens: 250, outputTokens: 70, totalTokens: 320, cacheReadTokens: 150, cacheWriteTokens: 0, cycles: [...] }\n * ```\n */\nexport function aggregateUsage(usages: TokenUsage[]): TokenUsage {\n  const cycles: TokenUsage['cycles'] = [];\n  let inputTokens = 0;\n  let outputTokens = 0;\n  let cacheReadTokens = 0;\n  let cacheWriteTokens = 0;\n\n  for (const usage of usages) {\n    inputTokens += usage.inputTokens;\n    outputTokens += usage.outputTokens;\n    cacheReadTokens += usage.cacheReadTokens;\n    cacheWriteTokens += usage.cacheWriteTokens;\n    cycles.push({\n      inputTokens: usage.inputTokens,\n      outputTokens: usage.outputTokens,\n      cacheReadTokens: usage.cacheReadTokens,\n      cacheWriteTokens: usage.cacheWriteTokens,\n    });\n  }\n\n  return {\n    inputTokens,\n    outputTokens,\n    totalTokens: inputTokens + outputTokens,\n    cacheReadTokens,\n    cacheWriteTokens,\n    cycles,\n  };\n}\n"],"mappings":";AA+IO,SAAS,WACd,UACA,gBACA,OACA,QACA,MACa;AACb,QAAM,WAAW,SACd,OAAO,CAAC,MAA6B,EAAE,SAAS,WAAW,EAC3D,IAAI;AAEP,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,kDAAkD;AAAA,EACpE;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAaO,SAAS,aAAyB;AACvC,SAAO;AAAA,IACL,aAAa;AAAA,IACb,cAAc;AAAA,IACd,aAAa;AAAA,IACb,iBAAiB;AAAA,IACjB,kBAAkB;AAAA,IAClB,QAAQ,CAAC;AAAA,EACX;AACF;AAgBO,SAAS,eAAe,QAAkC;AAC/D,QAAM,SAA+B,CAAC;AACtC,MAAI,cAAc;AAClB,MAAI,eAAe;AACnB,MAAI,kBAAkB;AACtB,MAAI,mBAAmB;AAEvB,aAAW,SAAS,QAAQ;AAC1B,mBAAe,MAAM;AACrB,oBAAgB,MAAM;AACtB,uBAAmB,MAAM;AACzB,wBAAoB,MAAM;AAC1B,WAAO,KAAK;AAAA,MACV,aAAa,MAAM;AAAA,MACnB,cAAc,MAAM;AAAA,MACpB,iBAAiB,MAAM;AAAA,MACvB,kBAAkB,MAAM;AAAA,IAC1B,CAAC;AAAA,EACH;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,aAAa,cAAc;AAAA,IAC3B;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-SVYROCLD.js → chunk-UMKWXGO3.js}

@@ -152,4 +152,4 @@ export {
   isAssistantMessage,
   isToolResultMessage
 };
-//# sourceMappingURL=chunk-SVYROCLD.js.map
+//# sourceMappingURL=chunk-UMKWXGO3.js.map

package/dist/chunk-UMKWXGO3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/id.ts","../src/types/messages.ts"],"sourcesContent":["/**\n * @fileoverview ID generation utilities for the Universal Provider Protocol.\n *\n * Provides functions for generating unique identifiers used throughout UPP,\n * including message IDs, tool call IDs, and other internal references.\n *\n * @module utils/id\n */\n\n/**\n * Generates a unique UUID v4 identifier.\n *\n * Uses the native `crypto.randomUUID()` when available for cryptographically\n * secure randomness. Falls back to a Math.random-based implementation for\n * environments without Web Crypto API support.\n *\n * @returns A UUID v4 string in the format `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`\n *\n * @example\n * ```typescript\n * const messageId = generateId();\n * // => \"f47ac10b-58cc-4372-a567-0e02b2c3d479\"\n * ```\n */\nexport function generateId(): string {\n  if (typeof crypto !== 'undefined' && crypto.randomUUID) {\n    return crypto.randomUUID();\n  }\n\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n    const r = (Math.random() * 16) | 0;\n    const v = c === 'x' ? r : (r & 0x3) | 0x8;\n    return v.toString(16);\n  });\n}\n\n/**\n * Generates a short alphanumeric identifier.\n *\n * Creates a 12-character random string using alphanumeric characters (a-z, A-Z, 0-9).\n * Useful for tool call IDs and other cases where a full UUID is not required.\n *\n * @param prefix - Optional prefix to prepend to the generated ID\n * @returns A string containing the prefix followed by 12 random alphanumeric characters\n *\n * @example\n * ```typescript\n * const toolCallId = generateShortId('call_');\n * // => \"call_aB3xY9mK2pQr\"\n *\n * const simpleId = generateShortId();\n * // => \"Tz4wN8vL1sHj\"\n * ```\n */\nexport function generateShortId(prefix = ''): string {\n  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  let result = prefix;\n  for (let i = 0; i < 12; i++) {\n    result += chars.charAt(Math.floor(Math.random() * chars.length));\n  }\n  return result;\n}\n","/**\n * @fileoverview Message types for conversation history.\n *\n * Defines the message classes used to represent conversation turns\n * between users and assistants, including support for multimodal\n * content and tool calls.\n *\n * @module types/messages\n */\n\nimport { generateId } from '../utils/id.ts';\nimport type {\n  ContentBlock,\n  TextBlock,\n  ImageBlock,\n  AudioBlock,\n  VideoBlock,\n  UserContent,\n  AssistantContent,\n} from './content.ts';\nimport type { ToolCall, ToolResult } from './tool.ts';\n\n/**\n * Message serialized to JSON format.\n * Picks common fields from Message, converts timestamp to string.\n */\nexport type MessageJSON = Pick<Message, 'id' | 'type' | 'metadata'> & {\n  timestamp: string;\n  content: ContentBlock[];\n  toolCalls?: ToolCall[];\n  results?: ToolResult[];\n};\n\n/**\n * Message type discriminator.\n *\n * Used to distinguish between different message types in a conversation.\n */\nexport type MessageType = 'user' | 'assistant' | 'tool_result';\n\n/**\n * Provider-namespaced metadata for messages.\n *\n * Each provider can attach its own metadata under its namespace,\n * preventing conflicts between different providers.\n *\n * @example\n * ```typescript\n * const metadata: MessageMetadata = {\n *   openai: { model: 'gpt-4', finishReason: 'stop' },\n *   anthropic: { model: 'claude-3', stopReason: 'end_turn' }\n * };\n * ```\n */\nexport interface MessageMetadata {\n  [provider: string]: Record<string, unknown> | undefined;\n}\n\n/**\n * Options for constructing messages.\n */\nexport interface MessageOptions {\n  /** Custom message ID (auto-generated if not provided) */\n  id?: string;\n\n  /** Provider-specific metadata */\n  metadata?: MessageMetadata;\n}\n\n/**\n * Abstract base class for all message types.\n *\n * Provides common functionality for user, assistant, and tool result\n * messages, including content accessors and metadata handling.\n *\n * @example\n * ```typescript\n * // Access text content from any message\n * const text = message.text;\n *\n * // Access images\n * const images = message.images;\n * ```\n */\nexport abstract class Message {\n  /** Unique message identifier */\n  readonly id: string;\n\n  /** Timestamp when the message was created */\n  readonly timestamp: Date;\n\n  /** Provider-specific metadata, namespaced by provider name */\n  readonly metadata?: MessageMetadata;\n\n  /** Message type discriminator (implemented by subclasses) */\n  abstract readonly type: MessageType;\n\n  /**\n   * Returns the content blocks for this message.\n   * Implemented by subclasses to provide type-specific content.\n   */\n  protected abstract getContent(): ContentBlock[];\n\n  /**\n   * Creates a new message instance.\n   *\n   * @param options - Optional message ID and metadata\n   */\n  constructor(options?: MessageOptions) {\n    this.id = options?.id ?? generateId();\n    this.timestamp = new Date();\n    this.metadata = options?.metadata;\n  }\n\n  /**\n   * Concatenated text content from all text blocks.\n   * Blocks are joined with double newlines.\n   */\n  get text(): string {\n    return this.getContent()\n      .filter((block): block is TextBlock => block.type === 'text')\n      .map((block) => block.text)\n      .join('\\n\\n');\n  }\n\n  /**\n   * All image content blocks in this message.\n   */\n  get images(): ImageBlock[] {\n    return this.getContent().filter((block): block is ImageBlock => block.type === 'image');\n  }\n\n  /**\n   * All audio content blocks in this message.\n   */\n  get audio(): AudioBlock[] {\n    return this.getContent().filter((block): block is AudioBlock => block.type === 'audio');\n  }\n\n  /**\n   * All video content blocks in this message.\n   */\n  get video(): VideoBlock[] {\n    return this.getContent().filter((block): block is VideoBlock => block.type === 'video');\n  }\n}\n\n/**\n * User input message.\n *\n * Represents a message from the user, which can contain text and/or\n * multimodal content like images, audio, or video.\n *\n * @example\n * ```typescript\n * // Simple text message\n * const msg = new UserMessage('Hello, world!');\n *\n * // Multimodal message\n * const msg = new UserMessage([\n *   { type: 'text', text: 'What is in this image?' },\n *   { type: 'image', source: { type: 'url', url: '...' }, mimeType: 'image/png' }\n * ]);\n * ```\n */\nexport class UserMessage extends Message {\n  /** Message type discriminator */\n  readonly type = 'user' as const;\n\n  /** Content blocks in this message */\n  readonly content: UserContent[];\n\n  /**\n   * Creates a new user message.\n   *\n   * @param content - String (converted to TextBlock) or array of content blocks\n   * @param options - Optional message ID and metadata\n   */\n  constructor(content: string | UserContent[], options?: MessageOptions) {\n    super(options);\n    if (typeof content === 'string') {\n      this.content = [{ type: 'text', text: content }];\n    } else {\n      this.content = content;\n    }\n  }\n\n  protected getContent(): ContentBlock[] {\n    return this.content;\n  }\n}\n\n/**\n * Assistant response message.\n *\n * Represents a response from the AI assistant, which may contain\n * text, media content, and/or tool call requests.\n *\n * @example\n * ```typescript\n * // Simple text response\n * const msg = new AssistantMessage('Hello! How can I help?');\n *\n * // Response with tool calls\n * const msg = new AssistantMessage(\n *   'Let me check the weather...',\n *   [{ toolCallId: 'call_1', toolName: 'get_weather', arguments: { location: 'NYC' } }]\n * );\n * ```\n */\nexport class AssistantMessage extends Message {\n  /** Message type discriminator */\n  readonly type = 'assistant' as const;\n\n  /** Content blocks in this message */\n  readonly content: AssistantContent[];\n\n  /** Tool calls requested by the model (if any) */\n  readonly toolCalls?: ToolCall[];\n\n  /**\n   * Creates a new assistant message.\n   *\n   * @param content - String (converted to TextBlock) or array of content blocks\n   * @param toolCalls - Tool calls requested by the model\n   * @param options - Optional message ID and metadata\n   */\n  constructor(\n    content: string | AssistantContent[],\n    toolCalls?: ToolCall[],\n    options?: MessageOptions\n  ) {\n    super(options);\n    if (typeof content === 'string') {\n      this.content = [{ type: 'text', text: content }];\n    } else {\n      this.content = content;\n    }\n    this.toolCalls = toolCalls;\n  }\n\n  protected getContent(): ContentBlock[] {\n    return this.content;\n  }\n\n  /**\n   * Whether this message contains tool call requests.\n   */\n  get hasToolCalls(): boolean {\n    return this.toolCalls !== undefined && this.toolCalls.length > 0;\n  }\n}\n\n/**\n * Tool execution result message.\n *\n * Contains the results of executing one or more tool calls,\n * sent back to the model for further processing.\n *\n * @example\n * ```typescript\n * const msg = new ToolResultMessage([\n *   { toolCallId: 'call_1', result: { temperature: 72, conditions: 'sunny' } },\n *   { toolCallId: 'call_2', result: 'File not found', isError: true }\n * ]);\n * ```\n */\nexport class ToolResultMessage extends Message {\n  /** Message type discriminator */\n  readonly type = 'tool_result' as const;\n\n  /** Results from tool executions */\n  readonly results: ToolResult[];\n\n  /**\n   * Creates a new tool result message.\n   *\n   * @param results - Array of tool execution results\n   * @param options - Optional message ID and metadata\n   */\n  constructor(results: ToolResult[], options?: MessageOptions) {\n    super(options);\n    this.results = results;\n  }\n\n  protected getContent(): ContentBlock[] {\n    return this.results.map((result) => ({\n      type: 'text' as const,\n      text:\n        typeof result.result === 'string'\n          ? result.result\n          : JSON.stringify(result.result),\n    }));\n  }\n}\n\n/**\n * Type guard for UserMessage.\n *\n * @param msg - The message to check\n * @returns True if the message is a UserMessage\n *\n * @example\n * ```typescript\n * if (isUserMessage(msg)) {\n *   console.log('User said:', msg.text);\n * }\n * ```\n */\nexport function isUserMessage(msg: Message): msg is UserMessage {\n  return msg.type === 'user';\n}\n\n/**\n * Type guard for AssistantMessage.\n *\n * @param msg - The message to check\n * @returns True if the message is an AssistantMessage\n *\n * @example\n * ```typescript\n * if (isAssistantMessage(msg)) {\n *   console.log('Assistant said:', msg.text);\n *   if (msg.hasToolCalls) {\n *     console.log('Tool calls:', msg.toolCalls);\n *   }\n * }\n * ```\n */\nexport function isAssistantMessage(msg: Message): msg is AssistantMessage {\n  return msg.type === 'assistant';\n}\n\n/**\n * Type guard for ToolResultMessage.\n *\n * @param msg - The message to check\n * @returns True if the message is a ToolResultMessage\n *\n * @example\n * ```typescript\n * if (isToolResultMessage(msg)) {\n *   for (const result of msg.results) {\n *     console.log(`Tool ${result.toolCallId}:`, result.result);\n *   }\n * }\n * ```\n */\nexport function isToolResultMessage(msg: Message): msg is ToolResultMessage {\n  return msg.type === 'tool_result';\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WAKD3OO5.js

@@ -0,0 +1,224 @@
+// src/core/media/Image.ts
+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.");
+  }
+  /**
+   * 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;
+    }
+    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
+    };
+  }
+  /**
+   * 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 { readFile } = await import("fs/promises");
+    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";
+  }
+}
+function detectMimeTypeFromUrl(url) {
+  try {
+    const pathname = new URL(url).pathname;
+    return detectMimeType(pathname);
+  } catch {
+    return "application/octet-stream";
+  }
+}
+
+export {
+  Image
+};
+//# sourceMappingURL=chunk-WAKD3OO5.js.map

package/dist/chunk-WAKD3OO5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/media/Image.ts"],"sourcesContent":["/**\n * @fileoverview Image content handling for the Universal Provider Protocol.\n *\n * Provides a unified Image class for working with images across different sources\n * (file paths, URLs, raw bytes, base64). Supports conversion between formats and\n * integration with UPP message content blocks.\n *\n * @module core/media/Image\n */\n\nimport type { ImageSource, ImageBlock } from '../../types/content.ts';\n\n/**\n * Represents an image that can be used in UPP messages.\n *\n * Images can be created from various sources (files, URLs, bytes, base64) and\n * converted to different formats as needed by providers. The class provides\n * a unified interface regardless of the underlying source type.\n *\n * @example\n * ```typescript\n * // Load from file\n * const fileImage = await Image.fromPath('./photo.jpg');\n *\n * // Reference by URL\n * const urlImage = Image.fromUrl('https://example.com/image.png');\n *\n * // From raw bytes\n * const bytesImage = Image.fromBytes(uint8Array, 'image/png');\n *\n * // Use in a message\n * const message = new UserMessage([image.toBlock()]);\n * ```\n */\nexport class Image {\n  /** The underlying image source (bytes, base64, or URL) */\n  readonly source: ImageSource;\n  /** MIME type of the image (e.g., 'image/jpeg', 'image/png') */\n  readonly mimeType: string;\n  /** Image width in pixels, if known */\n  readonly width?: number;\n  /** Image height in pixels, if known */\n  readonly height?: number;\n\n  private constructor(\n    source: ImageSource,\n    mimeType: string,\n    width?: number,\n    height?: number\n  ) {\n    this.source = source;\n    this.mimeType = mimeType;\n    this.width = width;\n    this.height = height;\n  }\n\n  /**\n   * Whether this image has data loaded in memory.\n   *\n   * Returns `false` for URL-sourced images that reference external resources.\n   * These must be fetched before their data can be accessed.\n   */\n  get hasData(): boolean {\n    return this.source.type !== 'url';\n  }\n\n  /**\n   * Converts the image to a base64-encoded string.\n   *\n   * @returns The image data as a base64 string\n   * @throws {Error} When the source is a URL (data must be fetched first)\n   */\n  toBase64(): string {\n    if (this.source.type === 'base64') {\n      return this.source.data;\n    }\n\n    if (this.source.type === 'bytes') {\n      return btoa(\n        Array.from(this.source.data)\n          .map((b) => String.fromCharCode(b))\n          .join('')\n      );\n    }\n\n    throw new Error('Cannot convert URL image to base64. Fetch the image first.');\n  }\n\n  /**\n   * Converts the image to a data URL suitable for embedding in HTML or CSS.\n   *\n   * @returns A data URL in the format `data:{mimeType};base64,{data}`\n   * @throws {Error} When the source is a URL (data must be fetched first)\n   */\n  toDataUrl(): string {\n    const base64 = this.toBase64();\n    return `data:${this.mimeType};base64,${base64}`;\n  }\n\n  /**\n   * Gets the image data as raw bytes.\n   *\n   * @returns The image data as a Uint8Array\n   * @throws {Error} When the source is a URL (data must be fetched first)\n   */\n  toBytes(): Uint8Array {\n    if (this.source.type === 'bytes') {\n      return this.source.data;\n    }\n\n    if (this.source.type === 'base64') {\n      const binaryString = atob(this.source.data);\n      const bytes = new Uint8Array(binaryString.length);\n      for (let i = 0; i < binaryString.length; i++) {\n        bytes[i] = binaryString.charCodeAt(i);\n      }\n      return bytes;\n    }\n\n    throw new Error('Cannot get bytes from URL image. Fetch the image first.');\n  }\n\n  /**\n   * Gets the URL for URL-sourced images.\n   *\n   * @returns The image URL\n   * @throws {Error} When the source is not a URL\n   */\n  toUrl(): string {\n    if (this.source.type === 'url') {\n      return this.source.url;\n    }\n\n    throw new Error('This image does not have a URL source.');\n  }\n\n  /**\n   * Converts this Image to an ImageBlock for use in UPP messages.\n   *\n   * @returns An ImageBlock that can be included in message content arrays\n   */\n  toBlock(): ImageBlock {\n    return {\n      type: 'image',\n      source: this.source,\n      mimeType: this.mimeType,\n      width: this.width,\n      height: this.height,\n    };\n  }\n\n  /**\n   * Creates an Image by reading a file from disk.\n   *\n   * The file is read into memory as bytes. MIME type is automatically\n   * detected from the file extension.\n   *\n   * @param path - Path to the image file\n   * @returns Promise resolving to an Image with the file contents\n   *\n   * @example\n   * ```typescript\n   * const image = await Image.fromPath('./photos/vacation.jpg');\n   * ```\n   */\n  static async fromPath(path: string): Promise<Image> {\n    // Dynamic import to avoid bundling fs in browser builds\n    const { readFile } = await import('node:fs/promises');\n    const data = await readFile(path);\n    const mimeType = detectMimeType(path);\n\n    return new Image(\n      { type: 'bytes', data: new Uint8Array(data) },\n      mimeType\n    );\n  }\n\n  /**\n   * Creates an Image from a URL reference.\n   *\n   * The URL is stored as a reference and not fetched. Providers will handle\n   * URL-to-data conversion if needed. MIME type is detected from the URL\n   * path if not provided.\n   *\n   * @param url - URL pointing to the image\n   * @param mimeType - Optional MIME type override\n   * @returns An Image referencing the URL\n   *\n   * @example\n   * ```typescript\n   * const image = Image.fromUrl('https://example.com/logo.png');\n   * ```\n   */\n  static fromUrl(url: string, mimeType?: string): Image {\n    const detected = mimeType || detectMimeTypeFromUrl(url);\n    return new Image({ type: 'url', url }, detected);\n  }\n\n  /**\n   * Creates an Image from raw byte data.\n   *\n   * @param data - The image data as a Uint8Array\n   * @param mimeType - The MIME type of the image\n   * @returns An Image containing the byte data\n   *\n   * @example\n   * ```typescript\n   * const image = Image.fromBytes(pngData, 'image/png');\n   * ```\n   */\n  static fromBytes(data: Uint8Array, mimeType: string): Image {\n    return new Image({ type: 'bytes', data }, mimeType);\n  }\n\n  /**\n   * Creates an Image from a base64-encoded string.\n   *\n   * @param base64 - The base64-encoded image data (without data URL prefix)\n   * @param mimeType - The MIME type of the image\n   * @returns An Image containing the base64 data\n   *\n   * @example\n   * ```typescript\n   * const image = Image.fromBase64(base64String, 'image/jpeg');\n   * ```\n   */\n  static fromBase64(base64: string, mimeType: string): Image {\n    return new Image({ type: 'base64', data: base64 }, mimeType);\n  }\n\n  /**\n   * Creates an Image from an existing ImageBlock.\n   *\n   * Useful for converting content blocks received from providers back\n   * into Image instances for further processing.\n   *\n   * @param block - An ImageBlock from message content\n   * @returns An Image with the block's source and metadata\n   */\n  static fromBlock(block: ImageBlock): Image {\n    return new Image(\n      block.source,\n      block.mimeType,\n      block.width,\n      block.height\n    );\n  }\n}\n\n/**\n * Detects the MIME type of an image based on its file extension.\n *\n * Supports common web image formats: JPEG, PNG, GIF, WebP, SVG, BMP, ICO.\n * Returns 'application/octet-stream' for unknown extensions.\n *\n * @param path - File path or filename with extension\n * @returns The detected MIME type string\n */\nfunction detectMimeType(path: string): string {\n  const ext = path.split('.').pop()?.toLowerCase();\n\n  switch (ext) {\n    case 'jpg':\n    case 'jpeg':\n      return 'image/jpeg';\n    case 'png':\n      return 'image/png';\n    case 'gif':\n      return 'image/gif';\n    case 'webp':\n      return 'image/webp';\n    case 'svg':\n      return 'image/svg+xml';\n    case 'bmp':\n      return 'image/bmp';\n    case 'ico':\n      return 'image/x-icon';\n    default:\n      return 'application/octet-stream';\n  }\n}\n\n/**\n * Detects the MIME type of an image from its URL.\n *\n * Extracts the pathname from the URL and delegates to `detectMimeType`.\n * Returns 'application/octet-stream' if the URL cannot be parsed.\n *\n * @param url - Full URL pointing to an image\n * @returns The detected MIME type string\n */\nfunction detectMimeTypeFromUrl(url: string): string {\n  try {\n    const pathname = new URL(url).pathname;\n    return detectMimeType(pathname);\n  } catch {\n    return 'application/octet-stream';\n  }\n}\n"],"mappings":"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","names":[]}

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;
 }
 
 /**