@providerprotocol/ai 0.0.38 → 0.0.40

package/dist/index.js

@@ -1,10 +1,8 @@
 import {
-  ExponentialBackoff,
-  LinearBackoff,
-  NoRetry,
-  RetryAfterStrategy,
-  TokenBucket
-} from "./chunk-Y5H7C5J4.js";
+  resolveStructure,
+  resolveTools
+} from "./chunk-3Q5VELKG.js";
+import "./chunk-IKJH5ZSJ.js";
 import {
   aggregateUsage,
   createTurn,
@@ -12,23 +10,28 @@ import {
 } from "./chunk-NSE7QN3P.js";
 import {
   Thread
-} from "./chunk-ZKNPQBIE.js";
+} from "./chunk-R3T2IYOU.js";
 import {
   Image
 } from "./chunk-N5DX5JW3.js";
 import "./chunk-PMK5LZ5Z.js";
 import {
-  DynamicKey,
-  RoundRobinKeys,
-  WeightedKeys
-} from "./chunk-ARVM24K2.js";
+  dynamicKey,
+  roundRobinKeys,
+  weightedKeys
+} from "./chunk-EY2LLDGY.js";
 import {
   createProvider,
   resolveEmbeddingHandler,
   resolveImageHandler,
   resolveLLMHandler
 } from "./chunk-JA3UZALR.js";
-import "./chunk-SBGZJVTJ.js";
+import {
+  exponentialBackoff,
+  linearBackoff,
+  noRetry,
+  retryAfterStrategy
+} from "./chunk-VQZPADW6.js";
 import {
   StreamEventType,
   contentBlockStart,
@@ -37,11 +40,12 @@ import {
   messageStart,
   messageStop,
   objectDelta,
+  streamRetry,
   textDelta,
   toolCallDelta,
   toolExecutionEnd,
   toolExecutionStart
-} from "./chunk-MJI74VEJ.js";
+} from "./chunk-F5ENANMJ.js";
 import {
   AssistantMessage,
   Message,
@@ -51,7 +55,8 @@ import {
   isAssistantMessage,
   isToolResultMessage,
   isUserMessage
-} from "./chunk-WU4U6IHF.js";
+} from "./chunk-6QCV4WXF.js";
+import "./chunk-U2G5PHHL.js";
 import {
   isCancelledError,
   toError
@@ -155,6 +160,17 @@ async function runAbortHook(middlewares, error, ctx) {
     }
   }
 }
+async function runRetryHook(middlewares, attempt, error, ctx) {
+  for (const mw of middlewares) {
+    if (mw.onRetry) {
+      try {
+        await mw.onRetry(attempt, error, ctx);
+      } catch (hookError) {
+        console.error(`[${mw.name}] Error in onRetry hook:`, hookError);
+      }
+    }
+  }
+}
 async function runToolHook(middlewares, hook, tool, data, ctx) {
   for (const mw of middlewares) {
     const fn = mw[hook];
@@ -165,11 +181,21 @@ async function runToolHook(middlewares, hook, tool, data, ctx) {
 }
 async function runTurnHook(middlewares, turn, ctx) {
   const ordered = [...middlewares].reverse();
+  let firstError = null;
   for (const mw of ordered) {
     if (mw.onTurn) {
-      await mw.onTurn.call(mw, turn, ctx);
+      try {
+        await mw.onTurn.call(mw, turn, ctx);
+      } catch (err) {
+        if (!firstError) {
+          firstError = err instanceof Error ? err : new Error(String(err));
+        }
+      }
     }
   }
+  if (firstError) {
+    throw firstError;
+  }
 }
 function createStreamTransformer(middlewares, ctx) {
   const streamMiddlewares = middlewares.filter((mw) => mw.onStreamEvent);
@@ -210,7 +236,12 @@ async function runStreamEndHook(middlewares, ctx) {
     }
   }
 }
-function createMiddlewareContext(modality, modelId, provider, streaming, request) {
+var noopEmit = () => {
+};
+function createEmitHolder() {
+  return { fn: noopEmit };
+}
+function createMiddlewareContext(modality, modelId, provider, streaming, request, emitHolder = { fn: noopEmit }) {
   return {
     modality,
     modelId,
@@ -220,7 +251,8 @@ function createMiddlewareContext(modality, modelId, provider, streaming, request
     response: void 0,
     state: /* @__PURE__ */ new Map(),
     startTime: Date.now(),
-    endTime: void 0
+    endTime: void 0,
+    emit: (event) => emitHolder.fn(event)
   };
 }
 function createStreamContext(state) {
@@ -311,6 +343,9 @@ function inputToMessage(input) {
   throw new Error("Invalid inference input");
 }
 function parseInputs(historyOrInput, inputs) {
+  if (historyOrInput === void 0 && inputs.length === 0) {
+    return { history: [], messages: [] };
+  }
   if (typeof historyOrInput === "object" && historyOrInput !== null && "messages" in historyOrInput && Array.isArray(historyOrInput.messages)) {
     const thread = historyOrInput;
     const newMessages2 = inputs.map(inputToMessage);
@@ -625,23 +660,79 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
     structure,
     config
   };
+  const emitHolder = createEmitHolder();
   const ctx = createMiddlewareContext(
     "llm",
     model.modelId,
     model.provider.name,
     true,
-    initialRequest
+    initialRequest,
+    emitHolder
   );
   const streamCtx = createStreamContext(ctx.state);
   const transformer = createStreamTransformer(middleware, streamCtx);
+  const lateEventQueue = [];
+  let lateEventResolver = null;
+  let lateEventsActive = false;
+  let lateEventsClosed = false;
+  const pushLateEvent = (event) => {
+    if (lateEventsClosed) return;
+    lateEventQueue.push(event);
+    if (lateEventResolver) {
+      const resolver = lateEventResolver;
+      lateEventResolver = null;
+      resolver(false);
+    }
+  };
+  const closeLateEvents = () => {
+    lateEventsClosed = true;
+    if (lateEventResolver) {
+      lateEventResolver(true);
+      lateEventResolver = null;
+    }
+  };
+  const waitForLateEvent = () => {
+    if (lateEventQueue.length > 0) {
+      return Promise.resolve(false);
+    }
+    if (lateEventsClosed) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve) => {
+      lateEventResolver = resolve;
+    });
+  };
+  const inlineEventQueue = [];
+  emitHolder.fn = (event) => {
+    const result = transformer(event);
+    if (result === null) return;
+    if (lateEventsActive) {
+      if (Array.isArray(result)) {
+        for (const e of result) pushLateEvent(e);
+      } else {
+        pushLateEvent(result);
+      }
+    } else {
+      if (Array.isArray(result)) {
+        inlineEventQueue.push(...result);
+      } else {
+        inlineEventQueue.push(result);
+      }
+    }
+  };
+  function* drainInlineEvents() {
+    while (inlineEventQueue.length > 0) {
+      yield inlineEventQueue.shift();
+    }
+  }
   let resolveGenerator;
   let rejectGenerator;
   let generatorSettled = false;
   const generatorDone = new Promise((resolve, reject) => {
-    resolveGenerator = () => {
+    resolveGenerator = (turn) => {
       if (!generatorSettled) {
         generatorSettled = true;
-        resolve();
+        resolve(turn);
       }
     };
     rejectGenerator = (error) => {
@@ -657,6 +748,10 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
     }
   });
   const maxIterations = toolStrategy?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const strategy = (config.retryStrategy ?? noRetry())();
+  const strategyMaxAttempts = strategy.maxAttempts ?? 0;
+  let attempt = 1;
+  let retryMessages = [];
   const onAbort = () => {
     const error = new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM);
     generatorError = error;
@@ -672,7 +767,9 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
     try {
       ensureNotAborted();
       await runHook(middleware, "onStart", ctx);
+      yield* drainInlineEvents();
       await runHook(middleware, "onRequest", ctx);
+      yield* drainInlineEvents();
       allMessages = ctx.request.messages;
       const requestMessageCount = allMessages.length;
       const overrideIndex = ctx.state.get(TURN_START_INDEX_KEY);
@@ -684,64 +781,121 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
         typeof overrideIndex === "number" ? overrideIndex : void 0
       );
       validateMediaCapabilities(allMessages, model.capabilities, model.provider.name);
-      while (cycles < maxIterations + 1) {
-        cycles++;
-        ensureNotAborted();
-        const request = {
-          messages: allMessages,
-          system,
-          params,
-          tools,
-          structure,
-          config,
-          signal: abortController.signal
-        };
-        const streamResult = model.stream(request);
-        for await (const event of streamResult) {
-          ensureNotAborted();
-          const transformed = transformer(event);
-          if (transformed === null) continue;
-          if (Array.isArray(transformed)) {
-            for (const e of transformed) {
-              yield e;
+      const retryTurnStartIndex = turnStartIndex;
+      let lastStreamResult;
+      retryLoop: while (true) {
+        try {
+          while (cycles < maxIterations + 1) {
+            cycles++;
+            ensureNotAborted();
+            retryMessages = [...allMessages];
+            if (strategy.beforeRequest) {
+              const beforeDelay = await strategy.beforeRequest();
+              if (beforeDelay > 0) {
+                await new Promise((resolve, reject) => {
+                  const timeoutId = setTimeout(resolve, beforeDelay);
+                  const handleBeforeAbort = () => {
+                    clearTimeout(timeoutId);
+                    reject(new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM));
+                  };
+                  if (abortController.signal.aborted) {
+                    clearTimeout(timeoutId);
+                    reject(new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM));
+                  } else {
+                    abortController.signal.addEventListener("abort", handleBeforeAbort, { once: true });
+                  }
+                });
+              }
+            }
+            const request = {
+              messages: allMessages,
+              system,
+              params,
+              tools,
+              structure,
+              config,
+              signal: abortController.signal
+            };
+            const streamResult = model.stream(request);
+            lastStreamResult = streamResult;
+            for await (const event of streamResult) {
+              ensureNotAborted();
+              const transformed = transformer(event);
+              if (transformed === null) continue;
+              if (Array.isArray(transformed)) {
+                for (const e of transformed) {
+                  yield e;
+                }
+              } else {
+                yield transformed;
+              }
+              yield* drainInlineEvents();
+            }
+            const response = await streamResult.response;
+            attempt = 1;
+            strategy.reset?.();
+            usages.push(response.usage);
+            allMessages.push(response.message);
+            if (response.data !== void 0) {
+              structuredData = response.data;
+            }
+            if (response.message.hasToolCalls && tools && tools.length > 0) {
+              if (response.data !== void 0) {
+                break;
+              }
+              if (cycles >= maxIterations) {
+                await toolStrategy?.onMaxIterations?.(maxIterations);
+                throw new UPPError(
+                  `Tool execution exceeded maximum iterations (${maxIterations})`,
+                  ErrorCode.InvalidRequest,
+                  model.provider.name,
+                  ModalityType.LLM
+                );
+              }
+              const toolEvents = [];
+              const results = await executeTools(
+                response.message,
+                tools,
+                toolStrategy,
+                toolExecutions,
+                (event) => toolEvents.push(event),
+                middleware,
+                ctx
+              );
+              for (const event of toolEvents) {
+                ensureNotAborted();
+                const transformed = transformer(event);
+                if (transformed === null) continue;
+                if (Array.isArray(transformed)) {
+                  for (const e of transformed) {
+                    yield e;
+                  }
+                } else {
+                  yield transformed;
+                }
+                yield* drainInlineEvents();
+              }
+              allMessages.push(new ToolResultMessage(results));
+              continue;
             }
-          } else {
-            yield transformed;
-          }
-        }
-        const response = await streamResult.response;
-        usages.push(response.usage);
-        allMessages.push(response.message);
-        if (response.data !== void 0) {
-          structuredData = response.data;
-        }
-        if (response.message.hasToolCalls && tools && tools.length > 0) {
-          if (response.data !== void 0) {
             break;
           }
-          if (cycles >= maxIterations) {
-            await toolStrategy?.onMaxIterations?.(maxIterations);
-            throw new UPPError(
-              `Tool execution exceeded maximum iterations (${maxIterations})`,
-              ErrorCode.InvalidRequest,
-              model.provider.name,
-              ModalityType.LLM
-            );
+          break retryLoop;
+        } catch (streamError) {
+          const err = toError(streamError);
+          const uppErr = err instanceof UPPError ? err : null;
+          if (!uppErr || isCancelledError(err)) {
+            throw err;
           }
-          const toolEvents = [];
-          const results = await executeTools(
-            response.message,
-            tools,
-            toolStrategy,
-            toolExecutions,
-            (event) => toolEvents.push(event),
-            middleware,
-            ctx
-          );
-          for (const event of toolEvents) {
-            ensureNotAborted();
-            const transformed = transformer(event);
-            if (transformed === null) continue;
+          const delay = await strategy.onRetry(uppErr, attempt);
+          if (delay === null) {
+            throw err;
+          }
+          lastStreamResult?.response.catch(() => {
+          });
+          const retryEvent = streamRetry(attempt, strategyMaxAttempts, err, Date.now());
+          const transformed = transformer(retryEvent);
+          if (transformed !== null) {
             if (Array.isArray(transformed)) {
               for (const e of transformed) {
                 yield e;
@@ -750,14 +904,84 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
               yield transformed;
             }
           }
-          allMessages.push(new ToolResultMessage(results));
-          continue;
+          await runRetryHook(middleware, attempt, err, ctx);
+          yield* drainInlineEvents();
+          allMessages = [...retryMessages];
+          turnStartIndex = retryTurnStartIndex;
+          cycles--;
+          structuredData = void 0;
+          ctx.request = {
+            messages: allMessages,
+            system,
+            params,
+            tools,
+            structure,
+            config
+          };
+          attempt += 1;
+          if (delay > 0) {
+            await new Promise((resolve, reject) => {
+              const timeoutId = setTimeout(resolve, delay);
+              const handleDelayAbort = () => {
+                clearTimeout(timeoutId);
+                reject(new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM));
+              };
+              if (abortController.signal.aborted) {
+                clearTimeout(timeoutId);
+                reject(new UPPError("Stream cancelled", ErrorCode.Cancelled, model.provider.name, ModalityType.LLM));
+              } else {
+                abortController.signal.addEventListener("abort", handleDelayAbort, { once: true });
+              }
+            });
+          }
+          continue retryLoop;
+        }
+      }
+      lateEventsActive = true;
+      let hooksTurn = null;
+      let hooksError = null;
+      const hooksPromise = (async () => {
+        try {
+          await runStreamEndHook(middleware, streamCtx);
+          const data = structure ? structuredData : void 0;
+          const turn = createTurn(
+            allMessages.slice(turnStartIndex),
+            toolExecutions,
+            aggregateUsage(usages),
+            cycles,
+            data
+          );
+          ctx.response = {
+            message: turn.response,
+            usage: turn.usage,
+            stopReason: "end_turn",
+            data
+          };
+          ctx.endTime = Date.now();
+          await runHook(middleware, "onResponse", ctx, true);
+          await runTurnHook(middleware, turn, ctx);
+          await runHook(middleware, "onEnd", ctx, true);
+          hooksTurn = turn;
+        } catch (err) {
+          hooksError = err instanceof Error ? err : new Error(String(err));
+        } finally {
+          lateEventsActive = false;
+          closeLateEvents();
+        }
+      })();
+      while (true) {
+        const done = await waitForLateEvent();
+        if (done) break;
+        while (lateEventQueue.length > 0) {
+          yield lateEventQueue.shift();
         }
-        break;
       }
-      await runStreamEndHook(middleware, streamCtx);
+      await hooksPromise;
+      if (hooksError !== null) {
+        throw toError(hooksError);
+      }
       generatorCompleted = true;
-      resolveGenerator();
+      resolveGenerator(hooksTurn);
     } catch (error) {
       const err = toError(error);
       generatorError = err;
@@ -782,29 +1006,7 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
     }
   }
   const createTurnPromise = async () => {
-    await generatorDone;
-    if (generatorError) {
-      throw generatorError;
-    }
-    const data = structure ? structuredData : void 0;
-    const turn = createTurn(
-      allMessages.slice(turnStartIndex),
-      toolExecutions,
-      aggregateUsage(usages),
-      cycles,
-      data
-    );
-    ctx.response = {
-      message: turn.response,
-      usage: turn.usage,
-      stopReason: "end_turn",
-      data
-    };
-    ctx.endTime = Date.now();
-    await runHook(middleware, "onResponse", ctx, true);
-    await runTurnHook(middleware, turn, ctx);
-    await runHook(middleware, "onEnd", ctx, true);
-    return turn;
+    return generatorDone;
   };
   return createStreamResult(generateStream(), createTurnPromise, abortController);
 }
@@ -814,11 +1016,13 @@ function llm(options) {
     config: explicitConfig = {},
     params,
     system,
-    tools,
+    tools: toolsInput,
     toolStrategy,
-    structure,
+    structure: structureInput,
     middleware = []
   } = options;
+  const structure = structureInput ? resolveStructure(structureInput) : void 0;
+  const tools = toolsInput ? resolveTools(toolsInput) : void 0;
   const providerConfig = modelRef.providerConfig ?? {};
   const config = {
     ...providerConfig,
@@ -1930,27 +2134,19 @@ export {
   ContentBlockType,
   Document,
   DocumentSourceType,
-  DynamicKey,
   EmbeddingInputType,
   ErrorCode,
-  ExponentialBackoff,
   Image,
   ImageSourceType,
-  LinearBackoff,
   Message,
   MessageRole,
   ModalityType,
-  NoRetry,
-  RetryAfterStrategy,
-  RoundRobinKeys,
   StreamEventType,
   Thread,
-  TokenBucket,
   ToolResultMessage,
   UPPError,
   UserMessage,
   Video,
-  WeightedKeys,
   aggregateUsage,
   ai,
   contentBlockStart,
@@ -1958,8 +2154,10 @@ export {
   createProvider,
   createStreamResult,
   createTurn,
+  dynamicKey,
   embedding,
   emptyUsage,
+  exponentialBackoff,
   image,
   isAssistantMessage,
   isAudioBlock,
@@ -1971,15 +2169,20 @@ export {
   isToolResultMessage,
   isUserMessage,
   isVideoBlock,
+  linearBackoff,
   llm,
   messageStart,
   messageStop,
+  noRetry,
   objectDelta,
   reasoning,
+  retryAfterStrategy,
+  roundRobinKeys,
   text,
   textDelta,
   toolCallDelta,
   toolExecutionEnd,
-  toolExecutionStart
+  toolExecutionStart,
+  weightedKeys
 };
 //# sourceMappingURL=index.js.map