@providerprotocol/ai 0.0.22 → 0.0.24

package/dist/index.js

@@ -6,9 +6,22 @@ import {
 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,124 +32,73 @@ import {
   resolveEmbeddingHandler,
   resolveImageHandler,
   resolveLLMHandler
-} from "./chunk-M4BMM5IB.js";
+} from "./chunk-6AZVUI6H.js";
 import {
   ExponentialBackoff,
   LinearBackoff,
   NoRetry,
   RetryAfterStrategy,
   TokenBucket
-} from "./chunk-RS7C25LS.js";
-import "./chunk-NWS5IKNR.js";
+} from "./chunk-SBCATNHA.js";
+import "./chunk-TOJCZMVU.js";
 import {
   DynamicKey,
   RoundRobinKeys,
   WeightedKeys
-} from "./chunk-7WYBJPJJ.js";
+} from "./chunk-55X3W2MN.js";
 import {
+  ErrorCode,
+  ModalityType,
   UPPError,
   toError
-} from "./chunk-RFWLEFAB.js";
+} from "./chunk-QNJO7DSD.js";
 
 // src/types/content.ts
+var ContentBlockType = {
+  /** Text content */
+  Text: "text",
+  /** Reasoning/thinking content from extended thinking models */
+  Reasoning: "reasoning",
+  /** 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: "text", text: content };
+  return { type: ContentBlockType.Text, text: content };
+}
+function reasoning(content) {
+  return { type: ContentBlockType.Reasoning, text: content };
 }
 function isTextBlock(block) {
-  return block.type === "text";
+  return block.type === ContentBlockType.Text;
+}
+function isReasoningBlock(block) {
+  return block.type === ContentBlockType.Reasoning;
 }
 function isImageBlock(block) {
-  return block.type === "image";
+  return block.type === ContentBlockType.Image;
 }
 function isAudioBlock(block) {
-  return block.type === "audio";
+  return block.type === ContentBlockType.Audio;
 }
 function isVideoBlock(block) {
-  return block.type === "video";
+  return block.type === ContentBlockType.Video;
 }
 function isBinaryBlock(block) {
-  return block.type === "binary";
-}
-
-// src/types/stream.ts
-function createStreamResult(generator, turnPromiseOrFactory, abortController) {
-  let cachedTurn = null;
-  const getTurn = () => {
-    if (typeof turnPromiseOrFactory === "function") {
-      if (!cachedTurn) {
-        cachedTurn = turnPromiseOrFactory();
-      }
-      return cachedTurn;
-    }
-    return turnPromiseOrFactory;
-  };
-  return {
-    [Symbol.asyncIterator]() {
-      return generator;
-    },
-    get turn() {
-      return getTurn();
-    },
-    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: {}
-  };
-}
-function messageStop() {
-  return {
-    type: "message_stop",
-    index: 0,
-    delta: {}
-  };
-}
-function contentBlockStart(index) {
-  return {
-    type: "content_block_start",
-    index,
-    delta: {}
-  };
-}
-function contentBlockStop(index) {
-  return {
-    type: "content_block_stop",
-    index,
-    delta: {}
-  };
-}
-function toolExecutionStart(toolCallId, toolName, timestamp, index = 0) {
-  return {
-    type: "tool_execution_start",
-    index,
-    delta: { toolCallId, toolName, timestamp }
-  };
-}
-function toolExecutionEnd(toolCallId, toolName, result, isError, timestamp, index = 0) {
-  return {
-    type: "tool_execution_end",
-    index,
-    delta: { toolCallId, toolName, result, isError, timestamp }
-  };
+  return block.type === ContentBlockType.Binary;
 }
 
 // src/core/llm.ts
@@ -157,9 +119,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);
@@ -167,17 +129,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 = {
@@ -203,9 +165,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);
@@ -322,9 +284,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(
@@ -385,14 +347,14 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
   });
   const maxIterations = toolStrategy?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
   const onAbort = () => {
-    const error = new UPPError("Stream cancelled", "CANCELLED", model.provider.name, "llm");
+    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", "CANCELLED", model.provider.name, "llm");
+      throw new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM);
     }
   };
   async function* generateStream() {
@@ -429,9 +391,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 = [];
@@ -461,7 +423,7 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
     } finally {
       abortController.signal.removeEventListener("abort", onAbort);
       if (!generatorCompleted && !generatorSettled) {
-        const error = new UPPError("Stream cancelled", "CANCELLED", model.provider.name, "llm");
+        const error = new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM);
         generatorError = error;
         if (!abortController.signal.aborted) {
           abortController.abort();
@@ -630,25 +592,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
         );
       }
     }
@@ -672,9 +634,9 @@ function embedding(options) {
   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);
@@ -735,9 +697,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
     );
@@ -766,9 +728,9 @@ function createChunkedStream(model, inputs, params, config, options) {
   });
   const cancelError = () => new UPPError(
     "Embedding cancelled",
-    "CANCELLED",
+    ErrorCode.Cancelled,
     model.provider.name,
-    "embedding"
+    ModalityType.Embedding
   );
   const onAbort = () => {
     rejectResult(cancelError());
@@ -875,9 +837,9 @@ function image(options) {
   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);
@@ -887,7 +849,7 @@ function image(options) {
       return error;
     }
     const err = toError(error);
-    return new UPPError(err.message, "PROVIDER_ERROR", provider.name, "image", void 0, err);
+    return new UPPError(err.message, ErrorCode.ProviderError, provider.name, ModalityType.Image, void 0, err);
   };
   const instance = {
     model: boundModel,
@@ -1240,14 +1202,20 @@ var ai = {
 };
 export {
   AssistantMessage,
+  ContentBlockType,
   DynamicKey,
+  ErrorCode,
   ExponentialBackoff,
   Image,
+  ImageSourceType,
   LinearBackoff,
   Message,
+  MessageRole,
+  ModalityType,
   NoRetry,
   RetryAfterStrategy,
   RoundRobinKeys,
+  StreamEventType,
   Thread,
   TokenBucket,
   ToolResultMessage,
@@ -1268,6 +1236,7 @@ export {
   isAudioBlock,
   isBinaryBlock,
   isImageBlock,
+  isReasoningBlock,
   isTextBlock,
   isToolResultMessage,
   isUserMessage,
@@ -1275,6 +1244,7 @@ export {
   llm,
   messageStart,
   messageStop,
+  reasoning,
   text,
   textDelta,
   toolCallDelta