@providerprotocol/ai 0.0.21 → 0.0.23

package/dist/index.js

@@ -2,13 +2,26 @@ import {
   aggregateUsage,
   createTurn,
   emptyUsage
-} from "./chunk-SKY2JLA7.js";
+} from "./chunk-MKDLXV4O.js";
 import {
   Image
 } from "./chunk-WAKD3OO5.js";
+import {
+  StreamEventType,
+  contentBlockStart,
+  contentBlockStop,
+  createStreamResult,
+  messageStart,
+  messageStop,
+  textDelta,
+  toolCallDelta,
+  toolExecutionEnd,
+  toolExecutionStart
+} from "./chunk-73IIE3QT.js";
 import {
   AssistantMessage,
   Message,
+  MessageRole,
   ToolResultMessage,
   UserMessage,
   createProvider,
@@ -19,91 +32,65 @@ import {
   resolveEmbeddingHandler,
   resolveImageHandler,
   resolveLLMHandler
-} from "./chunk-M4BMM5IB.js";
+} from "./chunk-MF5ETY5O.js";
 import {
   ExponentialBackoff,
   LinearBackoff,
   NoRetry,
   RetryAfterStrategy,
   TokenBucket
-} from "./chunk-Z4ILICF5.js";
-import "./chunk-Z7RBRCRN.js";
+} from "./chunk-SBCATNHA.js";
+import "./chunk-NWS5IKNR.js";
 import {
   DynamicKey,
   RoundRobinKeys,
   WeightedKeys
-} from "./chunk-Y3GBJNA2.js";
+} from "./chunk-55X3W2MN.js";
 import {
-  UPPError
-} from "./chunk-EDENPF3E.js";
+  ErrorCode,
+  ModalityType,
+  UPPError,
+  toError
+} from "./chunk-QNJO7DSD.js";
 
-// src/types/stream.ts
-function createStreamResult(generator, turnPromise, abortController) {
-  return {
-    [Symbol.asyncIterator]() {
-      return generator;
-    },
-    turn: turnPromise,
-    abort() {
-      abortController.abort();
-    }
-  };
-}
-function textDelta(text2, index = 0) {
-  return {
-    type: "text_delta",
-    index,
-    delta: { text: text2 }
-  };
-}
-function toolCallDelta(toolCallId, toolName, argumentsJson, index = 0) {
-  return {
-    type: "tool_call_delta",
-    index,
-    delta: { toolCallId, toolName, argumentsJson }
-  };
-}
-function messageStart() {
-  return {
-    type: "message_start",
-    index: 0,
-    delta: {}
-  };
+// src/types/content.ts
+var ContentBlockType = {
+  /** Text content */
+  Text: "text",
+  /** Image content */
+  Image: "image",
+  /** Audio content */
+  Audio: "audio",
+  /** Video content */
+  Video: "video",
+  /** Binary/arbitrary data content */
+  Binary: "binary"
+};
+var ImageSourceType = {
+  /** Base64-encoded image data */
+  Base64: "base64",
+  /** URL reference to image */
+  Url: "url",
+  /** Raw bytes image data */
+  Bytes: "bytes"
+};
+function text(content) {
+  return { type: ContentBlockType.Text, text: content };
 }
-function messageStop() {
-  return {
-    type: "message_stop",
-    index: 0,
-    delta: {}
-  };
+function isTextBlock(block) {
+  return block.type === ContentBlockType.Text;
 }
-function contentBlockStart(index) {
-  return {
-    type: "content_block_start",
-    index,
-    delta: {}
-  };
+function isImageBlock(block) {
+  return block.type === ContentBlockType.Image;
 }
-function contentBlockStop(index) {
-  return {
-    type: "content_block_stop",
-    index,
-    delta: {}
-  };
+function isAudioBlock(block) {
+  return block.type === ContentBlockType.Audio;
 }
-function toolExecutionStart(toolCallId, toolName, timestamp, index = 0) {
-  return {
-    type: "tool_execution_start",
-    index,
-    delta: { toolCallId, toolName, timestamp }
-  };
+function isVideoBlock(block) {
+  return block.type === ContentBlockType.Video;
 }
-function toolExecutionEnd(toolCallId, toolName, result, isError, timestamp, index = 0) {
-  return {
-    type: "tool_execution_end",
-    index,
-    delta: { toolCallId, toolName, result, isError, timestamp }
-  };
+function isBinaryBlock(block) {
+  return block.type === ContentBlockType.Binary;
 }
 
 // src/core/llm.ts
@@ -124,9 +111,9 @@ function llm(options) {
   if (!llmHandler) {
     throw new UPPError(
       `Provider '${provider.name}' does not support LLM modality`,
-      "INVALID_REQUEST",
+      ErrorCode.InvalidRequest,
       provider.name,
-      "llm"
+      ModalityType.LLM
     );
   }
   const boundModel = llmHandler.bind(modelRef.modelId);
@@ -134,17 +121,17 @@ function llm(options) {
   if (structure && !capabilities.structuredOutput) {
     throw new UPPError(
       `Provider '${provider.name}' does not support structured output`,
-      "INVALID_REQUEST",
+      ErrorCode.InvalidRequest,
       provider.name,
-      "llm"
+      ModalityType.LLM
     );
   }
   if (tools && tools.length > 0 && !capabilities.tools) {
     throw new UPPError(
       `Provider '${provider.name}' does not support tools`,
-      "INVALID_REQUEST",
+      ErrorCode.InvalidRequest,
       provider.name,
-      "llm"
+      ModalityType.LLM
     );
   }
   const instance = {
@@ -170,9 +157,9 @@ function llm(options) {
       if (!capabilities.streaming) {
         throw new UPPError(
           `Provider '${provider.name}' does not support streaming`,
-          "INVALID_REQUEST",
+          ErrorCode.InvalidRequest,
           provider.name,
-          "llm"
+          ModalityType.LLM
         );
       }
       const { history, messages } = parseInputs(historyOrInput, inputs);
@@ -195,10 +182,21 @@ function isMessageInstance(value) {
   if (value instanceof Message) {
     return true;
   }
-  if (typeof value === "object" && value !== null && "timestamp" in value && "type" in value && "id" in value) {
+  if (typeof value === "object" && value !== null) {
     const obj = value;
-    const messageTypes = ["user", "assistant", "tool_result"];
-    return messageTypes.includes(obj.type);
+    const type = obj.type;
+    const id = obj.id;
+    const timestamp = obj.timestamp;
+    const hasValidTimestamp = timestamp instanceof Date || typeof timestamp === "string" && !Number.isNaN(Date.parse(timestamp));
+    if (typeof id !== "string" || id.length === 0 || !hasValidTimestamp) {
+      return false;
+    }
+    if (type === "user" || type === "assistant") {
+      return Array.isArray(obj.content);
+    }
+    if (type === "tool_result") {
+      return Array.isArray(obj.results);
+    }
   }
   return false;
 }
@@ -230,11 +228,17 @@ function inputToMessage(input) {
   if ("type" in input && "id" in input && "timestamp" in input) {
     return input;
   }
+  if (typeof input !== "object" || input === null || !("type" in input)) {
+    throw new Error("Invalid inference input");
+  }
   const block = input;
-  if (block.type === "text") {
+  if (isTextBlock(block)) {
     return new UserMessage(block.text);
   }
-  return new UserMessage([block]);
+  if (isImageBlock(block) || isAudioBlock(block) || isVideoBlock(block) || isBinaryBlock(block)) {
+    return new UserMessage([block]);
+  }
+  throw new Error("Invalid inference input");
 }
 async function executeGenerate(model, config, system, params, tools, toolStrategy, structure, history, newMessages) {
   validateMediaCapabilities(
@@ -272,9 +276,9 @@ async function executeGenerate(model, config, system, params, tools, toolStrateg
         await toolStrategy?.onMaxIterations?.(maxIterations);
         throw new UPPError(
           `Tool execution exceeded maximum iterations (${maxIterations})`,
-          "INVALID_REQUEST",
+          ErrorCode.InvalidRequest,
           model.provider.name,
-          "llm"
+          ModalityType.LLM
         );
       }
       const results = await executeTools(
@@ -310,20 +314,47 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
   let cycles = 0;
   let generatorError = null;
   let structuredData;
+  let generatorCompleted = false;
   let resolveGenerator;
   let rejectGenerator;
+  let generatorSettled = false;
   const generatorDone = new Promise((resolve, reject) => {
-    resolveGenerator = resolve;
-    rejectGenerator = reject;
+    resolveGenerator = () => {
+      if (!generatorSettled) {
+        generatorSettled = true;
+        resolve();
+      }
+    };
+    rejectGenerator = (error) => {
+      if (!generatorSettled) {
+        generatorSettled = true;
+        reject(error);
+      }
+    };
+  });
+  void generatorDone.catch((error) => {
+    if (!generatorError) {
+      generatorError = toError(error);
+    }
   });
   const maxIterations = toolStrategy?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const onAbort = () => {
+    const error = new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM);
+    generatorError = error;
+    rejectGenerator(error);
+  };
+  abortController.signal.addEventListener("abort", onAbort, { once: true });
+  const ensureNotAborted = () => {
+    if (abortController.signal.aborted) {
+      throw new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM);
+    }
+  };
   async function* generateStream() {
     try {
-      if (abortController.signal.aborted) {
-        throw new UPPError("Stream cancelled", "CANCELLED", model.provider.name, "llm");
-      }
+      ensureNotAborted();
       while (cycles < maxIterations + 1) {
         cycles++;
+        ensureNotAborted();
         const request = {
           messages: allMessages,
           system,
@@ -335,6 +366,7 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
         };
         const streamResult = model.stream(request);
         for await (const event of streamResult) {
+          ensureNotAborted();
           yield event;
         }
         const response = await streamResult.response;
@@ -351,9 +383,9 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
             await toolStrategy?.onMaxIterations?.(maxIterations);
             throw new UPPError(
               `Tool execution exceeded maximum iterations (${maxIterations})`,
-              "INVALID_REQUEST",
+              ErrorCode.InvalidRequest,
               model.provider.name,
-              "llm"
+              ModalityType.LLM
             );
           }
           const toolEvents = [];
@@ -365,6 +397,7 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
             (event) => toolEvents.push(event)
           );
           for (const event of toolEvents) {
+            ensureNotAborted();
             yield event;
           }
           allMessages.push(new ToolResultMessage(results));
@@ -372,14 +405,26 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
         }
         break;
       }
+      generatorCompleted = true;
       resolveGenerator();
     } catch (error) {
-      generatorError = error;
-      rejectGenerator(error);
-      throw error;
+      const err = toError(error);
+      generatorError = err;
+      rejectGenerator(err);
+      throw err;
+    } finally {
+      abortController.signal.removeEventListener("abort", onAbort);
+      if (!generatorCompleted && !generatorSettled) {
+        const error = new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM);
+        generatorError = error;
+        if (!abortController.signal.aborted) {
+          abortController.abort();
+        }
+        rejectGenerator(error);
+      }
     }
   }
-  const turnPromise = (async () => {
+  const createTurnPromise = async () => {
     await generatorDone;
     if (generatorError) {
       throw generatorError;
@@ -392,8 +437,8 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
       cycles,
       data
     );
-  })();
-  return createStreamResult(generateStream(), turnPromise, abortController);
+  };
+  return createStreamResult(generateStream(), createTurnPromise, abortController);
 }
 async function executeTools(message, tools, toolStrategy, executions, onEvent) {
   const toolCalls = message.toolCalls ?? [];
@@ -401,41 +446,57 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
   const toolMap = new Map(tools.map((t) => [t.name, t]));
   const promises = toolCalls.map(async (call, index) => {
     const tool = toolMap.get(call.toolName);
-    if (!tool) {
+    const toolName = tool?.name ?? call.toolName;
+    const startTime = Date.now();
+    onEvent?.(toolExecutionStart(call.toolCallId, toolName, startTime, index));
+    let effectiveParams = call.arguments;
+    const endWithError = async (message2, approved2) => {
+      const endTime = Date.now();
+      if (tool) {
+        await toolStrategy?.onError?.(tool, effectiveParams, new Error(message2));
+      }
+      const execution = {
+        toolName,
+        toolCallId: call.toolCallId,
+        arguments: effectiveParams,
+        result: message2,
+        isError: true,
+        duration: endTime - startTime,
+        approved: approved2
+      };
+      executions.push(execution);
+      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, message2, true, endTime, index));
       return {
         toolCallId: call.toolCallId,
-        result: `Tool '${call.toolName}' not found`,
+        result: message2,
         isError: true
       };
+    };
+    if (!tool) {
+      return endWithError(`Tool '${call.toolName}' not found`);
+    }
+    try {
+      await toolStrategy?.onToolCall?.(tool, effectiveParams);
+    } catch (error) {
+      return endWithError(toError(error).message);
     }
-    const startTime = Date.now();
-    onEvent?.(toolExecutionStart(call.toolCallId, tool.name, startTime, index));
-    let effectiveParams = call.arguments;
-    await toolStrategy?.onToolCall?.(tool, effectiveParams);
     if (toolStrategy?.onBeforeCall) {
-      const beforeResult = await toolStrategy.onBeforeCall(tool, effectiveParams);
+      let beforeResult;
+      try {
+        beforeResult = await toolStrategy.onBeforeCall(tool, effectiveParams);
+      } catch (error) {
+        return endWithError(toError(error).message);
+      }
       const isBeforeCallResult = (value) => typeof value === "object" && value !== null && "proceed" in value;
       if (isBeforeCallResult(beforeResult)) {
         if (!beforeResult.proceed) {
-          const endTime = Date.now();
-          onEvent?.(toolExecutionEnd(call.toolCallId, tool.name, "Tool execution skipped", true, endTime, index));
-          return {
-            toolCallId: call.toolCallId,
-            result: "Tool execution skipped",
-            isError: true
-          };
+          return endWithError("Tool execution skipped");
         }
         if (beforeResult.params !== void 0) {
           effectiveParams = beforeResult.params;
         }
       } else if (!beforeResult) {
-        const endTime = Date.now();
-        onEvent?.(toolExecutionEnd(call.toolCallId, tool.name, "Tool execution skipped", true, endTime, index));
-        return {
-          toolCallId: call.toolCallId,
-          result: "Tool execution skipped",
-          isError: true
-        };
+        return endWithError("Tool execution skipped");
       }
     }
     let approved = true;
@@ -443,13 +504,13 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
       try {
         approved = await tool.approval(effectiveParams);
       } catch (error) {
-        throw error;
+        return endWithError(toError(error).message);
       }
     }
     if (!approved) {
       const endTime = Date.now();
       const execution = {
-        toolName: tool.name,
+        toolName,
         toolCallId: call.toolCallId,
         arguments: effectiveParams,
         result: "Tool execution denied",
@@ -458,7 +519,7 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
         approved: false
       };
       executions.push(execution);
-      onEvent?.(toolExecutionEnd(call.toolCallId, tool.name, "Tool execution denied by approval handler", true, endTime, index));
+      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, "Tool execution denied by approval handler", true, endTime, index));
       return {
         toolCallId: call.toolCallId,
         result: "Tool execution denied by approval handler",
@@ -476,7 +537,7 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
         }
       }
       const execution = {
-        toolName: tool.name,
+        toolName,
         toolCallId: call.toolCallId,
         arguments: effectiveParams,
         result,
@@ -485,7 +546,7 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
         approved
       };
       executions.push(execution);
-      onEvent?.(toolExecutionEnd(call.toolCallId, tool.name, result, false, endTime, index));
+      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, result, false, endTime, index));
       return {
         toolCallId: call.toolCallId,
         result,
@@ -493,22 +554,22 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
       };
     } catch (error) {
       const endTime = Date.now();
-      await toolStrategy?.onError?.(tool, effectiveParams, error);
-      const errorMessage = error instanceof Error ? error.message : String(error);
+      const err = toError(error);
+      await toolStrategy?.onError?.(tool, effectiveParams, err);
       const execution = {
-        toolName: tool.name,
+        toolName,
         toolCallId: call.toolCallId,
         arguments: effectiveParams,
-        result: errorMessage,
+        result: err.message,
         isError: true,
         duration: endTime - startTime,
         approved
       };
       executions.push(execution);
-      onEvent?.(toolExecutionEnd(call.toolCallId, tool.name, errorMessage, true, endTime, index));
+      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, err.message, true, endTime, index));
       return {
         toolCallId: call.toolCallId,
-        result: errorMessage,
+        result: err.message,
         isError: true
       };
     }
@@ -523,25 +584,25 @@ function validateMediaCapabilities(messages, capabilities, providerName) {
       if (block.type === "image" && !capabilities.imageInput) {
         throw new UPPError(
           `Provider '${providerName}' does not support image input`,
-          "INVALID_REQUEST",
+          ErrorCode.InvalidRequest,
           providerName,
-          "llm"
+          ModalityType.LLM
         );
       }
       if (block.type === "video" && !capabilities.videoInput) {
         throw new UPPError(
           `Provider '${providerName}' does not support video input`,
-          "INVALID_REQUEST",
+          ErrorCode.InvalidRequest,
           providerName,
-          "llm"
+          ModalityType.LLM
         );
       }
       if (block.type === "audio" && !capabilities.audioInput) {
         throw new UPPError(
           `Provider '${providerName}' does not support audio input`,
-          "INVALID_REQUEST",
+          ErrorCode.InvalidRequest,
           providerName,
-          "llm"
+          ModalityType.LLM
         );
       }
     }
@@ -550,15 +611,24 @@ function validateMediaCapabilities(messages, capabilities, providerName) {
 
 // src/core/embedding.ts
 function embedding(options) {
-  const { model: modelRef, config = {}, params } = options;
+  const { model: modelRef, config: explicitConfig = {}, params } = options;
+  const providerConfig = modelRef.providerConfig ?? {};
+  const config = {
+    ...providerConfig,
+    ...explicitConfig,
+    headers: {
+      ...providerConfig.headers,
+      ...explicitConfig.headers
+    }
+  };
   const provider = modelRef.provider;
   const handler = resolveEmbeddingHandler(provider);
   if (!handler) {
     throw new UPPError(
       `Provider '${provider.name}' does not support embedding modality`,
-      "INVALID_REQUEST",
+      ErrorCode.InvalidRequest,
       provider.name,
-      "embedding"
+      ModalityType.Embedding
     );
   }
   const boundModel = handler.bind(modelRef.modelId);
@@ -619,9 +689,9 @@ function decodeBase64(b64, providerName) {
     const cause = error instanceof Error ? error : new Error("Failed to decode base64 vector");
     throw new UPPError(
       "Invalid base64 embedding vector",
-      "INVALID_RESPONSE",
+      ErrorCode.InvalidResponse,
       providerName,
-      "embedding",
+      ModalityType.Embedding,
       void 0,
       cause
     );
@@ -633,33 +703,59 @@ function createChunkedStream(model, inputs, params, config, options) {
   const concurrency = options.concurrency ?? 1;
   let resolveResult;
   let rejectResult;
+  let settled = false;
   const resultPromise = new Promise((resolve, reject) => {
-    resolveResult = resolve;
-    rejectResult = reject;
+    resolveResult = (result) => {
+      if (!settled) {
+        settled = true;
+        resolve(result);
+      }
+    };
+    rejectResult = (error) => {
+      if (!settled) {
+        settled = true;
+        reject(error);
+      }
+    };
   });
+  const cancelError = () => new UPPError(
+    "Embedding cancelled",
+    ErrorCode.Cancelled,
+    model.provider.name,
+    ModalityType.Embedding
+  );
+  const onAbort = () => {
+    rejectResult(cancelError());
+  };
+  abortController.signal.addEventListener("abort", onAbort, { once: true });
+  const onExternalAbort = () => abortController.abort();
+  if (options.signal) {
+    options.signal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  const cleanupAbortListeners = () => {
+    abortController.signal.removeEventListener("abort", onAbort);
+    if (options.signal) {
+      options.signal.removeEventListener("abort", onExternalAbort);
+    }
+  };
   async function* generate() {
     const total = inputs.length;
     const allEmbeddings = [];
     let totalTokens = 0;
     const batches = [];
     for (let i = 0; i < inputs.length; i += batchSize) {
-      batches.push(inputs.slice(i, i + batchSize));
+      batches.push({ inputs: inputs.slice(i, i + batchSize), startIndex: i });
     }
     try {
       for (let i = 0; i < batches.length; i += concurrency) {
         if (abortController.signal.aborted || options.signal?.aborted) {
-          throw new UPPError(
-            "Embedding cancelled",
-            "CANCELLED",
-            model.provider.name,
-            "embedding"
-          );
+          throw cancelError();
         }
         const chunk = batches.slice(i, i + concurrency);
         const responses = await Promise.all(
           chunk.map(
             (batch) => model.embed({
-              inputs: batch,
+              inputs: batch.inputs,
               params,
               config: config ?? {},
               signal: abortController.signal
@@ -667,13 +763,17 @@ function createChunkedStream(model, inputs, params, config, options) {
           )
         );
         const batchEmbeddings = [];
-        for (const response of responses) {
-          for (const vec of response.embeddings) {
+        for (let responseIndex = 0; responseIndex < responses.length; responseIndex += 1) {
+          const response = responses[responseIndex];
+          const batch = chunk[responseIndex];
+          for (let vecIndex = 0; vecIndex < response.embeddings.length; vecIndex += 1) {
+            const vec = response.embeddings[vecIndex];
             const vector = normalizeVector(vec.vector, model.provider.name);
+            const resolvedIndex = batch.startIndex + (vec.index ?? vecIndex);
             const emb = {
               vector,
               dimensions: vector.length,
-              index: allEmbeddings.length + batchEmbeddings.length,
+              index: resolvedIndex,
               tokens: vec.tokens,
               metadata: vec.metadata
             };
@@ -689,13 +789,19 @@ function createChunkedStream(model, inputs, params, config, options) {
           percent: allEmbeddings.length / total * 100
         };
       }
+      const orderedEmbeddings = [...allEmbeddings].sort(
+        (left, right) => left.index - right.index
+      );
       resolveResult({
-        embeddings: allEmbeddings,
+        embeddings: orderedEmbeddings,
         usage: { totalTokens }
       });
     } catch (error) {
-      rejectResult(error);
-      throw error;
+      const err = toError(error);
+      rejectResult(err);
+      throw err;
+    } finally {
+      cleanupAbortListeners();
     }
   }
   const generator = generate();
@@ -708,36 +814,56 @@ function createChunkedStream(model, inputs, params, config, options) {
 
 // src/core/image.ts
 function image(options) {
-  const { model: modelRef, config = {}, params } = options;
+  const { model: modelRef, config: explicitConfig = {}, params } = options;
+  const providerConfig = modelRef.providerConfig ?? {};
+  const config = {
+    ...providerConfig,
+    ...explicitConfig,
+    headers: {
+      ...providerConfig.headers,
+      ...explicitConfig.headers
+    }
+  };
   const provider = modelRef.provider;
   const imageHandler = resolveImageHandler(provider);
   if (!imageHandler) {
     throw new UPPError(
       `Provider '${provider.name}' does not support image modality`,
-      "INVALID_REQUEST",
+      ErrorCode.InvalidRequest,
       provider.name,
-      "image"
+      ModalityType.Image
     );
   }
   const boundModel = imageHandler.bind(modelRef.modelId);
   const capabilities = boundModel.capabilities;
+  const normalizeImageError = (error) => {
+    if (error instanceof UPPError) {
+      return error;
+    }
+    const err = toError(error);
+    return new UPPError(err.message, ErrorCode.ProviderError, provider.name, ModalityType.Image, void 0, err);
+  };
   const instance = {
     model: boundModel,
     params,
     capabilities,
     async generate(input, options2) {
       const prompt = normalizeInput(input);
-      const response = await boundModel.generate({
-        prompt,
-        params,
-        config,
-        signal: options2?.signal
-      });
-      return {
-        images: response.images,
-        metadata: response.metadata,
-        usage: response.usage
-      };
+      try {
+        const response = await boundModel.generate({
+          prompt,
+          params,
+          config,
+          signal: options2?.signal
+        });
+        return {
+          images: response.images,
+          metadata: response.metadata,
+          usage: response.usage
+        };
+      } catch (error) {
+        throw normalizeImageError(error);
+      }
     }
   };
   if (capabilities.streaming && boundModel.stream) {
@@ -755,9 +881,20 @@ function image(options) {
         images: response.images,
         metadata: response.metadata,
         usage: response.usage
-      }));
+      })).catch((error) => {
+        throw normalizeImageError(error);
+      });
+      async function* wrappedStream() {
+        try {
+          for await (const event of providerStream) {
+            yield event;
+          }
+        } catch (error) {
+          throw normalizeImageError(error);
+        }
+      }
       return {
-        [Symbol.asyncIterator]: () => providerStream[Symbol.asyncIterator](),
+        [Symbol.asyncIterator]: () => wrappedStream(),
         result: resultPromise,
         abort: () => abortController.abort()
       };
@@ -766,18 +903,22 @@ function image(options) {
   if (capabilities.edit && boundModel.edit) {
     const edit = boundModel.edit;
     instance.edit = async function(input) {
-      const response = await edit({
-        image: input.image,
-        mask: input.mask,
-        prompt: input.prompt,
-        params,
-        config
-      });
-      return {
-        images: response.images,
-        metadata: response.metadata,
-        usage: response.usage
-      };
+      try {
+        const response = await edit({
+          image: input.image,
+          mask: input.mask,
+          prompt: input.prompt,
+          params,
+          config
+        });
+        return {
+          images: response.images,
+          metadata: response.metadata,
+          usage: response.usage
+        };
+      } catch (error) {
+        throw normalizeImageError(error);
+      }
     };
   }
   return instance;
@@ -789,26 +930,6 @@ function normalizeInput(input) {
   return input.prompt;
 }
 
-// src/types/content.ts
-function text(content) {
-  return { type: "text", text: content };
-}
-function isTextBlock(block) {
-  return block.type === "text";
-}
-function isImageBlock(block) {
-  return block.type === "image";
-}
-function isAudioBlock(block) {
-  return block.type === "audio";
-}
-function isVideoBlock(block) {
-  return block.type === "video";
-}
-function isBinaryBlock(block) {
-  return block.type === "binary";
-}
-
 // src/types/thread.ts
 var Thread = class _Thread {
   /** Unique thread identifier */
@@ -1073,14 +1194,20 @@ var ai = {
 };
 export {
   AssistantMessage,
+  ContentBlockType,
   DynamicKey,
+  ErrorCode,
   ExponentialBackoff,
   Image,
+  ImageSourceType,
   LinearBackoff,
   Message,
+  MessageRole,
+  ModalityType,
   NoRetry,
   RetryAfterStrategy,
   RoundRobinKeys,
+  StreamEventType,
   Thread,
   TokenBucket,
   ToolResultMessage,