@providerprotocol/ai 0.0.21 → 0.0.22

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   aggregateUsage,
   createTurn,
   emptyUsage
-} from "./chunk-SKY2JLA7.js";
+} from "./chunk-MKDLXV4O.js";
 import {
   Image
 } from "./chunk-WAKD3OO5.js";
@@ -26,24 +26,57 @@ import {
   NoRetry,
   RetryAfterStrategy,
   TokenBucket
-} from "./chunk-Z4ILICF5.js";
-import "./chunk-Z7RBRCRN.js";
+} from "./chunk-RS7C25LS.js";
+import "./chunk-NWS5IKNR.js";
 import {
   DynamicKey,
   RoundRobinKeys,
   WeightedKeys
-} from "./chunk-Y3GBJNA2.js";
+} from "./chunk-7WYBJPJJ.js";
 import {
-  UPPError
-} from "./chunk-EDENPF3E.js";
+  UPPError,
+  toError
+} from "./chunk-RFWLEFAB.js";
+
+// 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/stream.ts
-function createStreamResult(generator, turnPromise, abortController) {
+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;
     },
-    turn: turnPromise,
+    get turn() {
+      return getTurn();
+    },
     abort() {
       abortController.abort();
     }
@@ -195,10 +228,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 +274,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(
@@ -310,20 +360,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", "CANCELLED", model.provider.name, "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");
+    }
+  };
   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 +412,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;
@@ -365,6 +443,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 +451,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", "CANCELLED", model.provider.name, "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 +483,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 +492,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 +550,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 +565,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 +583,7 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
         }
       }
       const execution = {
-        toolName: tool.name,
+        toolName,
         toolCallId: call.toolCallId,
         arguments: effectiveParams,
         result,
@@ -485,7 +592,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 +600,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
       };
     }
@@ -550,7 +657,16 @@ 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) {
@@ -633,33 +749,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",
+    "CANCELLED",
+    model.provider.name,
+    "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 +809,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 +835,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,7 +860,16 @@ 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) {
@@ -721,23 +882,34 @@ function image(options) {
   }
   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, "PROVIDER_ERROR", provider.name, "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 +927,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 +949,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 +976,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 */