@providerprotocol/ai 0.0.33 → 0.0.35

package/dist/index.js

@@ -1,3 +1,10 @@
+import {
+  ExponentialBackoff,
+  LinearBackoff,
+  NoRetry,
+  RetryAfterStrategy,
+  TokenBucket
+} from "./chunk-Y5H7C5J4.js";
 import {
   aggregateUsage,
   createTurn,
@@ -5,54 +12,52 @@ import {
 } from "./chunk-NSE7QN3P.js";
 import {
   Image
-} from "./chunk-WAKD3OO5.js";
+} from "./chunk-N5DX5JW3.js";
+import "./chunk-PMK5LZ5Z.js";
 import {
-  StreamEventType,
-  contentBlockStart,
-  contentBlockStop,
-  createStreamResult,
-  messageStart,
-  messageStop,
-  objectDelta,
-  textDelta,
-  toolCallDelta,
-  toolExecutionEnd,
-  toolExecutionStart
-} from "./chunk-6S222DHN.js";
+  DynamicKey,
+  RoundRobinKeys,
+  WeightedKeys
+} from "./chunk-ARVM24K2.js";
+import {
+  createProvider,
+  resolveEmbeddingHandler,
+  resolveImageHandler,
+  resolveLLMHandler
+} from "./chunk-JA3UZALR.js";
 import {
   AssistantMessage,
   Message,
   MessageRole,
   ToolResultMessage,
   UserMessage,
-  createProvider,
   generateId,
   isAssistantMessage,
   isToolResultMessage,
-  isUserMessage,
-  resolveEmbeddingHandler,
-  resolveImageHandler,
-  resolveLLMHandler
-} from "./chunk-ILR2D5PN.js";
-import {
-  ExponentialBackoff,
-  LinearBackoff,
-  NoRetry,
-  RetryAfterStrategy,
-  TokenBucket
-} from "./chunk-KUPF5KHT.js";
-import "./chunk-TOJCZMVU.js";
+  isUserMessage
+} from "./chunk-BRP5XJ6Q.js";
 import {
-  DynamicKey,
-  RoundRobinKeys,
-  WeightedKeys
-} from "./chunk-3D6XGGVG.js";
+  isCancelledError,
+  toError
+} from "./chunk-AY55T37A.js";
 import {
   ErrorCode,
   ModalityType,
-  UPPError,
-  toError
-} from "./chunk-4J6OFUKX.js";
+  UPPError
+} from "./chunk-COS4ON4G.js";
+import {
+  StreamEventType,
+  contentBlockStart,
+  contentBlockStop,
+  createStreamResult,
+  messageStart,
+  messageStop,
+  objectDelta,
+  textDelta,
+  toolCallDelta,
+  toolExecutionEnd,
+  toolExecutionStart
+} from "./chunk-6S222DHN.js";
 
 // src/types/content.ts
 var ContentBlockType = {
@@ -136,6 +141,17 @@ async function runErrorHook(middlewares, error, ctx) {
     }
   }
 }
+async function runAbortHook(middlewares, error, ctx) {
+  for (const mw of middlewares) {
+    if (mw.onAbort) {
+      try {
+        await mw.onAbort(error, ctx);
+      } catch (hookError) {
+        console.error(`[${mw.name}] Error in onAbort hook:`, hookError);
+      }
+    }
+  }
+}
 async function runToolHook(middlewares, hook, tool, data, ctx) {
   for (const mw of middlewares) {
     const fn = mw[hook];
@@ -202,99 +218,44 @@ function createStreamContext(state) {
 
 // src/core/llm.ts
 var DEFAULT_MAX_ITERATIONS = 10;
-function llm(options) {
-  const {
-    model: modelRef,
-    config: explicitConfig = {},
-    params,
-    system,
-    tools,
-    toolStrategy,
-    structure,
-    middleware = []
-  } = options;
-  const providerConfig = modelRef.providerConfig ?? {};
-  const config = {
-    ...providerConfig,
-    ...explicitConfig,
-    headers: {
-      ...providerConfig.headers,
-      ...explicitConfig.headers
-    }
-  };
-  const provider = modelRef.provider;
-  const llmHandler = resolveLLMHandler(provider, modelRef.options);
-  if (!llmHandler) {
-    throw new UPPError(
-      `Provider '${provider.name}' does not support LLM modality`,
-      ErrorCode.InvalidRequest,
-      provider.name,
-      ModalityType.LLM
-    );
-  }
-  const boundModel = llmHandler.bind(modelRef.modelId);
-  const capabilities = boundModel.capabilities;
-  if (structure && !capabilities.structuredOutput) {
-    throw new UPPError(
-      `Provider '${provider.name}' does not support structured output`,
-      ErrorCode.InvalidRequest,
-      provider.name,
-      ModalityType.LLM
-    );
-  }
-  if (tools && tools.length > 0 && !capabilities.tools) {
-    throw new UPPError(
-      `Provider '${provider.name}' does not support tools`,
-      ErrorCode.InvalidRequest,
-      provider.name,
-      ModalityType.LLM
-    );
-  }
-  const instance = {
-    model: boundModel,
-    system,
-    params,
-    capabilities,
-    async generate(historyOrInput, ...inputs) {
-      const { history, messages } = parseInputs(historyOrInput, inputs);
-      return executeGenerate(
-        boundModel,
-        config,
-        system,
-        params,
-        tools,
-        toolStrategy,
-        structure,
-        history,
-        messages,
-        middleware
-      );
-    },
-    stream(historyOrInput, ...inputs) {
-      if (!capabilities.streaming) {
+function validateMediaCapabilities(messages, capabilities, providerName) {
+  for (const msg of messages) {
+    if (!isUserMessage(msg)) continue;
+    for (const block of msg.content) {
+      if (block.type === "image" && !capabilities.imageInput) {
         throw new UPPError(
-          `Provider '${provider.name}' does not support streaming`,
+          `Provider '${providerName}' does not support image input`,
           ErrorCode.InvalidRequest,
-          provider.name,
+          providerName,
+          ModalityType.LLM
+        );
+      }
+      if (block.type === "document" && !capabilities.documentInput) {
+        throw new UPPError(
+          `Provider '${providerName}' does not support document input`,
+          ErrorCode.InvalidRequest,
+          providerName,
+          ModalityType.LLM
+        );
+      }
+      if (block.type === "video" && !capabilities.videoInput) {
+        throw new UPPError(
+          `Provider '${providerName}' does not support video input`,
+          ErrorCode.InvalidRequest,
+          providerName,
+          ModalityType.LLM
+        );
+      }
+      if (block.type === "audio" && !capabilities.audioInput) {
+        throw new UPPError(
+          `Provider '${providerName}' does not support audio input`,
+          ErrorCode.InvalidRequest,
+          providerName,
           ModalityType.LLM
         );
       }
-      const { history, messages } = parseInputs(historyOrInput, inputs);
-      return executeStream(
-        boundModel,
-        config,
-        system,
-        params,
-        tools,
-        toolStrategy,
-        structure,
-        history,
-        messages,
-        middleware
-      );
     }
-  };
-  return instance;
+  }
 }
 function isMessageInstance(value) {
   if (value instanceof Message) {
@@ -318,6 +279,25 @@ function isMessageInstance(value) {
   }
   return false;
 }
+function inputToMessage(input) {
+  if (typeof input === "string") {
+    return new UserMessage(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 (isTextBlock(block)) {
+    return new UserMessage(block.text);
+  }
+  if (isImageBlock(block) || isDocumentBlock(block) || isAudioBlock(block) || isVideoBlock(block) || isBinaryBlock(block)) {
+    return new UserMessage([block]);
+  }
+  throw new Error("Invalid inference input");
+}
 function parseInputs(historyOrInput, inputs) {
   if (typeof historyOrInput === "object" && historyOrInput !== null && "messages" in historyOrInput && Array.isArray(historyOrInput.messages)) {
     const thread = historyOrInput;
@@ -339,61 +319,185 @@ function parseInputs(historyOrInput, inputs) {
   const newMessages = allInputs.map(inputToMessage);
   return { history: [], messages: newMessages };
 }
-function inputToMessage(input) {
-  if (typeof input === "string") {
-    return new UserMessage(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 (isTextBlock(block)) {
-    return new UserMessage(block.text);
-  }
-  if (isImageBlock(block) || isDocumentBlock(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, middleware) {
-  validateMediaCapabilities(
-    [...history, ...newMessages],
-    model.capabilities,
-    model.provider.name
-  );
-  const maxIterations = toolStrategy?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-  const allMessages = [...history, ...newMessages];
-  const toolExecutions = [];
-  const usages = [];
-  let cycles = 0;
-  let structuredData;
-  const initialRequest = {
-    messages: allMessages,
-    system,
-    params,
-    tools,
-    structure,
-    config
-  };
-  const ctx = createMiddlewareContext(
-    "llm",
-    model.modelId,
-    model.provider.name,
-    false,
-    initialRequest
-  );
-  try {
-    await runHook(middleware, "onStart", ctx);
-    await runHook(middleware, "onRequest", ctx);
-    while (cycles < maxIterations + 1) {
-      cycles++;
-      const request = {
-        messages: allMessages,
-        system,
-        params,
+async function executeTools(assistantMessage, tools, toolStrategy, executions, onEvent, middleware = [], ctx) {
+  const toolCalls = assistantMessage.toolCalls ?? [];
+  const results = [];
+  const toolMap = new Map(tools.map((t) => [t.name, t]));
+  const promises = toolCalls.map(async (call, index) => {
+    const tool = toolMap.get(call.toolName);
+    const toolName = tool?.name ?? call.toolName;
+    const startTime = Date.now();
+    onEvent?.(toolExecutionStart(call.toolCallId, toolName, startTime, index));
+    let effectiveParams = call.arguments;
+    const endWithError = async (errorMessage, approved2) => {
+      const endTime = Date.now();
+      if (tool) {
+        await toolStrategy?.onError?.(tool, effectiveParams, new Error(errorMessage));
+      }
+      const execution = {
+        toolName,
+        toolCallId: call.toolCallId,
+        arguments: effectiveParams,
+        result: errorMessage,
+        isError: true,
+        duration: endTime - startTime,
+        approved: approved2
+      };
+      executions.push(execution);
+      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, errorMessage, true, endTime, index));
+      return {
+        toolCallId: call.toolCallId,
+        result: errorMessage,
+        isError: true
+      };
+    };
+    if (!tool) {
+      return endWithError(`Tool '${call.toolName}' not found`);
+    }
+    try {
+      await toolStrategy?.onToolCall?.(tool, effectiveParams);
+      if (ctx) {
+        await runToolHook(middleware, "onToolCall", tool, effectiveParams, ctx);
+      }
+    } catch (error) {
+      return endWithError(toError(error).message);
+    }
+    if (toolStrategy?.onBeforeCall) {
+      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) {
+          return endWithError("Tool execution skipped");
+        }
+        if (beforeResult.params !== void 0) {
+          effectiveParams = beforeResult.params;
+        }
+      } else if (!beforeResult) {
+        return endWithError("Tool execution skipped");
+      }
+    }
+    let approved = true;
+    if (tool.approval) {
+      try {
+        approved = await tool.approval(effectiveParams);
+      } catch (error) {
+        return endWithError(toError(error).message);
+      }
+    }
+    if (!approved) {
+      const endTime = Date.now();
+      const execution = {
+        toolName,
+        toolCallId: call.toolCallId,
+        arguments: effectiveParams,
+        result: "Tool execution denied",
+        isError: true,
+        duration: endTime - startTime,
+        approved: false
+      };
+      executions.push(execution);
+      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",
+        isError: true
+      };
+    }
+    try {
+      let result = await tool.run(effectiveParams);
+      const endTime = Date.now();
+      if (toolStrategy?.onAfterCall) {
+        const afterResult = await toolStrategy.onAfterCall(tool, effectiveParams, result);
+        const isAfterCallResult = (value) => typeof value === "object" && value !== null && "result" in value;
+        if (isAfterCallResult(afterResult)) {
+          result = afterResult.result;
+        }
+      }
+      if (ctx) {
+        await runToolHook(middleware, "onToolResult", tool, result, ctx);
+      }
+      const execution = {
+        toolName,
+        toolCallId: call.toolCallId,
+        arguments: effectiveParams,
+        result,
+        isError: false,
+        duration: endTime - startTime,
+        approved
+      };
+      executions.push(execution);
+      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, result, false, endTime, index));
+      return {
+        toolCallId: call.toolCallId,
+        result,
+        isError: false
+      };
+    } catch (error) {
+      const endTime = Date.now();
+      const err = toError(error);
+      await toolStrategy?.onError?.(tool, effectiveParams, err);
+      const execution = {
+        toolName,
+        toolCallId: call.toolCallId,
+        arguments: effectiveParams,
+        result: err.message,
+        isError: true,
+        duration: endTime - startTime,
+        approved
+      };
+      executions.push(execution);
+      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, err.message, true, endTime, index));
+      return {
+        toolCallId: call.toolCallId,
+        result: err.message,
+        isError: true
+      };
+    }
+  });
+  results.push(...await Promise.all(promises));
+  return results;
+}
+async function executeGenerate(model, config, system, params, tools, toolStrategy, structure, history, newMessages, middleware) {
+  validateMediaCapabilities(
+    [...history, ...newMessages],
+    model.capabilities,
+    model.provider.name
+  );
+  const maxIterations = toolStrategy?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const allMessages = [...history, ...newMessages];
+  const toolExecutions = [];
+  const usages = [];
+  let cycles = 0;
+  let structuredData;
+  const initialRequest = {
+    messages: allMessages,
+    system,
+    params,
+    tools,
+    structure,
+    config
+  };
+  const ctx = createMiddlewareContext(
+    "llm",
+    model.modelId,
+    model.provider.name,
+    false,
+    initialRequest
+  );
+  try {
+    await runHook(middleware, "onStart", ctx);
+    await runHook(middleware, "onRequest", ctx);
+    while (cycles < maxIterations + 1) {
+      cycles++;
+      const request = {
+        messages: allMessages,
+        system,
+        params,
         tools,
         structure,
         config
@@ -602,7 +706,11 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
     } catch (error) {
       const err = toError(error);
       generatorError = err;
-      await runErrorHook(middleware, err, ctx);
+      if (isCancelledError(err)) {
+        await runAbortHook(middleware, err, ctx);
+      } else {
+        await runErrorHook(middleware, err, ctx);
+      }
       rejectGenerator(err);
       throw err;
     } finally {
@@ -613,6 +721,7 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
         if (!abortController.signal.aborted) {
           abortController.abort();
         }
+        await runAbortHook(middleware, error, ctx);
         rejectGenerator(error);
       }
     }
@@ -643,223 +752,143 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
   };
   return createStreamResult(generateStream(), createTurnPromise, abortController);
 }
-async function executeTools(message, tools, toolStrategy, executions, onEvent, middleware = [], ctx) {
-  const toolCalls = message.toolCalls ?? [];
-  const results = [];
-  const toolMap = new Map(tools.map((t) => [t.name, t]));
-  const promises = toolCalls.map(async (call, index) => {
-    const tool = toolMap.get(call.toolName);
-    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: message2,
-        isError: true
-      };
-    };
-    if (!tool) {
-      return endWithError(`Tool '${call.toolName}' not found`);
-    }
-    try {
-      await toolStrategy?.onToolCall?.(tool, effectiveParams);
-      if (ctx) {
-        await runToolHook(middleware, "onToolCall", tool, effectiveParams, ctx);
-      }
-    } catch (error) {
-      return endWithError(toError(error).message);
-    }
-    if (toolStrategy?.onBeforeCall) {
-      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) {
-          return endWithError("Tool execution skipped");
-        }
-        if (beforeResult.params !== void 0) {
-          effectiveParams = beforeResult.params;
-        }
-      } else if (!beforeResult) {
-        return endWithError("Tool execution skipped");
-      }
-    }
-    let approved = true;
-    if (tool.approval) {
-      try {
-        approved = await tool.approval(effectiveParams);
-      } catch (error) {
-        return endWithError(toError(error).message);
-      }
+function llm(options) {
+  const {
+    model: modelRef,
+    config: explicitConfig = {},
+    params,
+    system,
+    tools,
+    toolStrategy,
+    structure,
+    middleware = []
+  } = options;
+  const providerConfig = modelRef.providerConfig ?? {};
+  const config = {
+    ...providerConfig,
+    ...explicitConfig,
+    headers: {
+      ...providerConfig.headers,
+      ...explicitConfig.headers
     }
-    if (!approved) {
-      const endTime = Date.now();
-      const execution = {
-        toolName,
-        toolCallId: call.toolCallId,
-        arguments: effectiveParams,
-        result: "Tool execution denied",
-        isError: true,
-        duration: endTime - startTime,
-        approved: false
-      };
-      executions.push(execution);
-      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",
-        isError: true
-      };
-    }
-    try {
-      let result = await tool.run(effectiveParams);
-      const endTime = Date.now();
-      if (toolStrategy?.onAfterCall) {
-        const afterResult = await toolStrategy.onAfterCall(tool, effectiveParams, result);
-        const isAfterCallResult = (value) => typeof value === "object" && value !== null && "result" in value;
-        if (isAfterCallResult(afterResult)) {
-          result = afterResult.result;
-        }
-      }
-      if (ctx) {
-        await runToolHook(middleware, "onToolResult", tool, result, ctx);
-      }
-      const execution = {
-        toolName,
-        toolCallId: call.toolCallId,
-        arguments: effectiveParams,
-        result,
-        isError: false,
-        duration: endTime - startTime,
-        approved
-      };
-      executions.push(execution);
-      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, result, false, endTime, index));
-      return {
-        toolCallId: call.toolCallId,
-        result,
-        isError: false
-      };
-    } catch (error) {
-      const endTime = Date.now();
-      const err = toError(error);
-      await toolStrategy?.onError?.(tool, effectiveParams, err);
-      const execution = {
-        toolName,
-        toolCallId: call.toolCallId,
-        arguments: effectiveParams,
-        result: err.message,
-        isError: true,
-        duration: endTime - startTime,
-        approved
-      };
-      executions.push(execution);
-      onEvent?.(toolExecutionEnd(call.toolCallId, toolName, err.message, true, endTime, index));
-      return {
-        toolCallId: call.toolCallId,
-        result: err.message,
-        isError: true
-      };
-    }
-  });
-  results.push(...await Promise.all(promises));
-  return results;
-}
-function validateMediaCapabilities(messages, capabilities, providerName) {
-  for (const msg of messages) {
-    if (!isUserMessage(msg)) continue;
-    for (const block of msg.content) {
-      if (block.type === "image" && !capabilities.imageInput) {
-        throw new UPPError(
-          `Provider '${providerName}' does not support image input`,
-          ErrorCode.InvalidRequest,
-          providerName,
-          ModalityType.LLM
-        );
-      }
-      if (block.type === "document" && !capabilities.documentInput) {
-        throw new UPPError(
-          `Provider '${providerName}' does not support document input`,
-          ErrorCode.InvalidRequest,
-          providerName,
-          ModalityType.LLM
-        );
-      }
-      if (block.type === "video" && !capabilities.videoInput) {
-        throw new UPPError(
-          `Provider '${providerName}' does not support video input`,
-          ErrorCode.InvalidRequest,
-          providerName,
-          ModalityType.LLM
-        );
-      }
-      if (block.type === "audio" && !capabilities.audioInput) {
+  };
+  const provider = modelRef.provider;
+  const llmHandler = resolveLLMHandler(provider, modelRef.options);
+  if (!llmHandler) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support LLM modality`,
+      ErrorCode.InvalidRequest,
+      provider.name,
+      ModalityType.LLM
+    );
+  }
+  const boundModel = llmHandler.bind(modelRef.modelId);
+  const capabilities = boundModel.capabilities;
+  if (structure && !capabilities.structuredOutput) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support structured output`,
+      ErrorCode.InvalidRequest,
+      provider.name,
+      ModalityType.LLM
+    );
+  }
+  if (tools && tools.length > 0 && !capabilities.tools) {
+    throw new UPPError(
+      `Provider '${provider.name}' does not support tools`,
+      ErrorCode.InvalidRequest,
+      provider.name,
+      ModalityType.LLM
+    );
+  }
+  const instance = {
+    model: boundModel,
+    system,
+    params,
+    capabilities,
+    async generate(historyOrInput, ...inputs) {
+      const { history, messages } = parseInputs(historyOrInput, inputs);
+      return executeGenerate(
+        boundModel,
+        config,
+        system,
+        params,
+        tools,
+        toolStrategy,
+        structure,
+        history,
+        messages,
+        middleware
+      );
+    },
+    stream(historyOrInput, ...inputs) {
+      if (!capabilities.streaming) {
         throw new UPPError(
-          `Provider '${providerName}' does not support audio input`,
+          `Provider '${provider.name}' does not support streaming`,
           ErrorCode.InvalidRequest,
-          providerName,
+          provider.name,
           ModalityType.LLM
         );
       }
+      const { history, messages } = parseInputs(historyOrInput, inputs);
+      return executeStream(
+        boundModel,
+        config,
+        system,
+        params,
+        tools,
+        toolStrategy,
+        structure,
+        history,
+        messages,
+        middleware
+      );
     }
-  }
+  };
+  return instance;
 }
 
 // src/core/embedding.ts
-function embedding(options) {
-  const { model: modelRef, config: explicitConfig = {}, params, middleware = [] } = options;
-  const providerConfig = modelRef.providerConfig ?? {};
-  const config = {
-    ...providerConfig,
-    ...explicitConfig,
-    headers: {
-      ...providerConfig.headers,
-      ...explicitConfig.headers
+function decodeBase64(b64, providerName) {
+  try {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
     }
-  };
-  const provider = modelRef.provider;
-  const handler = resolveEmbeddingHandler(provider);
-  if (!handler) {
+    const floats = new Float32Array(bytes.buffer);
+    return Array.from(floats);
+  } catch (error) {
+    const cause = error instanceof Error ? error : new Error("Failed to decode base64 vector");
     throw new UPPError(
-      `Provider '${provider.name}' does not support embedding modality`,
-      ErrorCode.InvalidRequest,
-      provider.name,
-      ModalityType.Embedding
+      "Invalid base64 embedding vector",
+      ErrorCode.InvalidResponse,
+      providerName,
+      ModalityType.Embedding,
+      void 0,
+      cause
     );
   }
-  const boundModel = handler.bind(modelRef.modelId);
-  function embed(input, embedOptions) {
-    const inputs = Array.isArray(input) ? input : [input];
-    if (embedOptions?.chunked) {
-      return createChunkedStream(boundModel, inputs, params, config, embedOptions, middleware);
-    }
-    return executeEmbed(boundModel, inputs, params, config, embedOptions?.signal, embedOptions?.inputType, middleware);
+}
+function normalizeVector(vector, providerName) {
+  if (Array.isArray(vector)) {
+    return vector;
   }
+  return decodeBase64(vector, providerName);
+}
+function normalizeResponse(response, providerName) {
   return {
-    model: boundModel,
-    params,
-    embed
+    embeddings: response.embeddings.map((vec, i) => {
+      const vector = normalizeVector(vec.vector, providerName);
+      return {
+        vector,
+        dimensions: vector.length,
+        index: vec.index ?? i,
+        tokens: vec.tokens,
+        metadata: vec.metadata
+      };
+    }),
+    usage: response.usage,
+    metadata: response.metadata
   };
 }
 async function executeEmbed(model, inputs, params, config, signal, inputType, middleware = []) {
@@ -881,59 +910,16 @@ async function executeEmbed(model, inputs, params, config, signal, inputType, mi
     await runHook(middleware, "onStart", ctx);
     await runHook(middleware, "onRequest", ctx);
     const response = await model.embed(request);
-    const result = normalizeResponse(response, model.provider.name);
-    ctx.response = response;
-    ctx.endTime = Date.now();
-    await runHook(middleware, "onResponse", ctx, true);
-    await runHook(middleware, "onEnd", ctx, true);
-    return result;
-  } catch (error) {
-    const err = toError(error);
-    await runErrorHook(middleware, err, ctx);
-    throw err;
-  }
-}
-function normalizeResponse(response, providerName) {
-  return {
-    embeddings: response.embeddings.map((vec, i) => {
-      const vector = normalizeVector(vec.vector, providerName);
-      return {
-        vector,
-        dimensions: vector.length,
-        index: vec.index ?? i,
-        tokens: vec.tokens,
-        metadata: vec.metadata
-      };
-    }),
-    usage: response.usage,
-    metadata: response.metadata
-  };
-}
-function normalizeVector(vector, providerName) {
-  if (Array.isArray(vector)) {
-    return vector;
-  }
-  return decodeBase64(vector, providerName);
-}
-function decodeBase64(b64, providerName) {
-  try {
-    const binary = atob(b64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    const floats = new Float32Array(bytes.buffer);
-    return Array.from(floats);
+    const result = normalizeResponse(response, model.provider.name);
+    ctx.response = response;
+    ctx.endTime = Date.now();
+    await runHook(middleware, "onResponse", ctx, true);
+    await runHook(middleware, "onEnd", ctx, true);
+    return result;
   } catch (error) {
-    const cause = error instanceof Error ? error : new Error("Failed to decode base64 vector");
-    throw new UPPError(
-      "Invalid base64 embedding vector",
-      ErrorCode.InvalidResponse,
-      providerName,
-      ModalityType.Embedding,
-      void 0,
-      cause
-    );
+    const err = toError(error);
+    await runErrorHook(middleware, err, ctx);
+    throw err;
   }
 }
 function createChunkedStream(model, inputs, params, config, options, middleware = []) {
@@ -1072,8 +1058,49 @@ function createChunkedStream(model, inputs, params, config, options, middleware
     abort: () => abortController.abort()
   };
 }
+function embedding(options) {
+  const { model: modelRef, config: explicitConfig = {}, params, middleware = [] } = 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`,
+      ErrorCode.InvalidRequest,
+      provider.name,
+      ModalityType.Embedding
+    );
+  }
+  const boundModel = handler.bind(modelRef.modelId);
+  function embed(input, embedOptions) {
+    const inputs = Array.isArray(input) ? input : [input];
+    if (embedOptions?.chunked) {
+      return createChunkedStream(boundModel, inputs, params, config, embedOptions, middleware);
+    }
+    return executeEmbed(boundModel, inputs, params, config, embedOptions?.signal, embedOptions?.inputType, middleware);
+  }
+  return {
+    model: boundModel,
+    params,
+    embed
+  };
+}
 
 // src/core/image.ts
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  return input.prompt;
+}
 function image(options) {
   const { model: modelRef, config: explicitConfig = {}, params, middleware = [] } = options;
   const providerConfig = modelRef.providerConfig ?? {};
@@ -1108,13 +1135,13 @@ function image(options) {
     model: boundModel,
     params,
     capabilities,
-    async generate(input, options2) {
+    async generate(input, generateOptions) {
       const prompt = normalizeInput(input);
       const request = {
         prompt,
         params,
         config,
-        signal: options2?.signal
+        signal: generateOptions?.signal
       };
       const ctx = createMiddlewareContext(
         "image",
@@ -1225,14 +1252,22 @@ function image(options) {
   }
   return instance;
 }
-function normalizeInput(input) {
-  if (typeof input === "string") {
-    return input;
-  }
-  return input.prompt;
-}
 
 // src/core/media/document.ts
+function detectMimeType(path) {
+  const ext = path.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "pdf":
+      return "application/pdf";
+    case "txt":
+    case "text":
+    case "md":
+    case "markdown":
+      return "text/plain";
+    default:
+      return "application/octet-stream";
+  }
+}
 var Document = class _Document {
   /** The underlying document source (base64, url, or text) */
   source;
@@ -1443,22 +1478,33 @@ var Document = class _Document {
     );
   }
 };
-function detectMimeType(path) {
+
+// src/core/media/Audio.ts
+function detectMimeType2(path) {
   const ext = path.split(".").pop()?.toLowerCase();
   switch (ext) {
-    case "pdf":
-      return "application/pdf";
-    case "txt":
-    case "text":
-    case "md":
-    case "markdown":
-      return "text/plain";
+    case "mp3":
+      return "audio/mp3";
+    case "wav":
+      return "audio/wav";
+    case "ogg":
+    case "oga":
+      return "audio/ogg";
+    case "flac":
+      return "audio/flac";
+    case "aac":
+      return "audio/aac";
+    case "m4a":
+      return "audio/mp4";
+    case "webm":
+      return "audio/webm";
+    case "aiff":
+    case "aif":
+      return "audio/aiff";
     default:
       return "application/octet-stream";
   }
 }
-
-// src/core/media/Audio.ts
 var Audio = class _Audio {
   /** The audio data as raw bytes */
   data;
@@ -1609,33 +1655,37 @@ var Audio = class _Audio {
     );
   }
 };
-function detectMimeType2(path) {
+
+// src/core/media/Video.ts
+function detectMimeType3(path) {
   const ext = path.split(".").pop()?.toLowerCase();
   switch (ext) {
-    case "mp3":
-      return "audio/mp3";
-    case "wav":
-      return "audio/wav";
-    case "ogg":
-    case "oga":
-      return "audio/ogg";
-    case "flac":
-      return "audio/flac";
-    case "aac":
-      return "audio/aac";
-    case "m4a":
-      return "audio/mp4";
+    case "mp4":
+    case "m4v":
+      return "video/mp4";
     case "webm":
-      return "audio/webm";
-    case "aiff":
-    case "aif":
-      return "audio/aiff";
+      return "video/webm";
+    case "ogv":
+    case "ogg":
+      return "video/ogg";
+    case "mov":
+      return "video/quicktime";
+    case "avi":
+      return "video/x-msvideo";
+    case "mpeg":
+    case "mpg":
+      return "video/mpeg";
+    case "wmv":
+      return "video/x-ms-wmv";
+    case "3gp":
+    case "3gpp":
+      return "video/3gpp";
+    case "flv":
+      return "video/x-flv";
     default:
       return "application/octet-stream";
   }
 }
-
-// src/core/media/Video.ts
 var Video = class _Video {
   /** The video data as raw bytes */
   data;
@@ -1800,35 +1850,6 @@ var Video = class _Video {
     );
   }
 };
-function detectMimeType3(path) {
-  const ext = path.split(".").pop()?.toLowerCase();
-  switch (ext) {
-    case "mp4":
-    case "m4v":
-      return "video/mp4";
-    case "webm":
-      return "video/webm";
-    case "ogv":
-    case "ogg":
-      return "video/ogg";
-    case "mov":
-      return "video/quicktime";
-    case "avi":
-      return "video/x-msvideo";
-    case "mpeg":
-    case "mpg":
-      return "video/mpeg";
-    case "wmv":
-      return "video/x-ms-wmv";
-    case "3gp":
-    case "3gpp":
-      return "video/3gpp";
-    case "flv":
-      return "video/x-flv";
-    default:
-      return "application/octet-stream";
-  }
-}
 
 // src/types/thread.ts
 var Thread = class _Thread {
@@ -2091,274 +2112,6 @@ var EmbeddingInputType = {
   Query: "query"
 };
 
-// src/utils/partial-json.ts
-function parsePartialJson(json) {
-  const trimmed = json.trim();
-  if (trimmed === "") {
-    return { value: void 0, isComplete: false };
-  }
-  try {
-    const value = JSON.parse(trimmed);
-    return { value, isComplete: true };
-  } catch {
-  }
-  try {
-    const repaired = repairJson(trimmed);
-    const value = JSON.parse(repaired);
-    return { value, isComplete: false };
-  } catch {
-    return { value: void 0, isComplete: false };
-  }
-}
-function repairJson(json) {
-  let result = json;
-  const stack = [];
-  let inString = false;
-  let escape = false;
-  for (let i = 0; i < result.length; i++) {
-    const char = result[i];
-    if (escape) {
-      escape = false;
-      continue;
-    }
-    if (char === "\\" && inString) {
-      escape = true;
-      continue;
-    }
-    if (char === '"' && !escape) {
-      inString = !inString;
-    }
-    if (!inString) {
-      if (char === "{") {
-        stack.push("{");
-      } else if (char === "[") {
-        stack.push("[");
-      } else if (char === "}") {
-        if (stack.length > 0 && stack[stack.length - 1] === "{") {
-          stack.pop();
-        }
-      } else if (char === "]") {
-        if (stack.length > 0 && stack[stack.length - 1] === "[") {
-          stack.pop();
-        }
-      }
-    }
-  }
-  if (inString) {
-    const unicodeMatch = result.match(/\\u[0-9a-fA-F]{0,3}$/);
-    if (unicodeMatch) {
-      result = result.slice(0, -unicodeMatch[0].length);
-    }
-    if (result.endsWith("\\")) {
-      result = result.slice(0, -1);
-    }
-    result += '"';
-    inString = false;
-  }
-  result = cleanupTrailingIncomplete(result);
-  while (stack.length > 0) {
-    const open = stack.pop();
-    if (open === "{") {
-      result += "}";
-    } else {
-      result += "]";
-    }
-  }
-  return result;
-}
-function cleanupTrailingIncomplete(json) {
-  let result = json.trim();
-  let changed = true;
-  while (changed) {
-    changed = false;
-    const trimmed = result.trim();
-    if (trimmed.endsWith(",")) {
-      result = trimmed.slice(0, -1);
-      changed = true;
-      continue;
-    }
-    if (trimmed.endsWith(":")) {
-      const colonIndex = trimmed.length - 1;
-      let keyStart = colonIndex - 1;
-      while (keyStart >= 0 && /\s/.test(trimmed[keyStart])) {
-        keyStart--;
-      }
-      if (keyStart >= 0 && trimmed[keyStart] === '"') {
-        keyStart--;
-        while (keyStart >= 0 && trimmed[keyStart] !== '"') {
-          keyStart--;
-        }
-        keyStart--;
-        while (keyStart >= 0 && /\s/.test(trimmed[keyStart])) {
-          keyStart--;
-        }
-        if (keyStart >= 0 && trimmed[keyStart] === ",") {
-          result = trimmed.slice(0, keyStart);
-        } else {
-          result = trimmed.slice(0, keyStart + 1);
-        }
-        changed = true;
-        continue;
-      }
-    }
-    const literalMatch = trimmed.match(/(,?\s*)(t(?:r(?:ue?)?)?|f(?:a(?:l(?:se?)?)?)?|n(?:u(?:ll?)?)?)$/i);
-    if (literalMatch && literalMatch[2]) {
-      const partial = literalMatch[2].toLowerCase();
-      const literals = ["true", "false", "null"];
-      const match = literals.find((lit) => lit.startsWith(partial) && partial !== lit);
-      if (match) {
-        result = trimmed.slice(0, -literalMatch[2].length) + match;
-        changed = true;
-        continue;
-      }
-    }
-    const numberMatch = trimmed.match(/(,?\s*)(-?(?:\d+\.|\d*\.?\d+[eE][+-]?|\d+[eE]|-))$/);
-    if (numberMatch && numberMatch[2]) {
-      const partial = numberMatch[2];
-      if (/[.eE+-]$/.test(partial)) {
-        if (partial === "-") {
-          result = trimmed.slice(0, -(numberMatch[0]?.length ?? 0)).trimEnd();
-        } else {
-          result = trimmed.slice(0, -1);
-        }
-        changed = true;
-        continue;
-      }
-    }
-  }
-  return result;
-}
-
-// src/middleware/parsed-object.ts
-var ACCUMULATED_TEXT_KEY = "parsedObject:text";
-var ACCUMULATED_ARGS_KEY = "parsedObject:args";
-function getAccumulatedText(state) {
-  let map = state.get(ACCUMULATED_TEXT_KEY);
-  if (!map) {
-    map = /* @__PURE__ */ new Map();
-    state.set(ACCUMULATED_TEXT_KEY, map);
-  }
-  return map;
-}
-function getAccumulatedArgs(state) {
-  let map = state.get(ACCUMULATED_ARGS_KEY);
-  if (!map) {
-    map = /* @__PURE__ */ new Map();
-    state.set(ACCUMULATED_ARGS_KEY, map);
-  }
-  return map;
-}
-function parsedObjectMiddleware(options = {}) {
-  const { parseObjects = true, parseToolCalls = true } = options;
-  return {
-    name: "parsed-object",
-    onStreamEvent(event, ctx) {
-      if (parseObjects && event.type === StreamEventType.ObjectDelta) {
-        const accumulatedText = getAccumulatedText(ctx.state);
-        const current = accumulatedText.get(event.index) ?? "";
-        const newText = current + (event.delta.text ?? "");
-        accumulatedText.set(event.index, newText);
-        const parseResult = parsePartialJson(newText);
-        const parsedEvent = {
-          ...event,
-          delta: {
-            ...event.delta,
-            parsed: parseResult.value
-          }
-        };
-        return parsedEvent;
-      }
-      if (parseToolCalls && event.type === StreamEventType.ToolCallDelta) {
-        const accumulatedArgs = getAccumulatedArgs(ctx.state);
-        const current = accumulatedArgs.get(event.index) ?? "";
-        const newJson = current + (event.delta.argumentsJson ?? "");
-        accumulatedArgs.set(event.index, newJson);
-        const parseResult = parsePartialJson(newJson);
-        const parsedEvent = {
-          ...event,
-          delta: {
-            ...event.delta,
-            parsed: parseResult.value
-          }
-        };
-        return parsedEvent;
-      }
-      return event;
-    },
-    onStreamEnd(ctx) {
-      ctx.state.delete(ACCUMULATED_TEXT_KEY);
-      ctx.state.delete(ACCUMULATED_ARGS_KEY);
-    }
-  };
-}
-
-// src/middleware/logging.ts
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-function loggingMiddleware(options = {}) {
-  const {
-    level = "info",
-    logStreamEvents = false,
-    logToolCalls = true,
-    logger,
-    prefix = "[PP]"
-  } = options;
-  const minLevel = LOG_LEVELS[level];
-  const log = (logLevel, message, data) => {
-    if (LOG_LEVELS[logLevel] < minLevel) {
-      return;
-    }
-    const fullMessage = `${prefix} ${message}`;
-    if (logger) {
-      logger(logLevel, fullMessage, data);
-    } else {
-      const consoleMethod = logLevel === "error" ? console.error : logLevel === "warn" ? console.warn : console.log;
-      if (data) {
-        consoleMethod(fullMessage, data);
-      } else {
-        consoleMethod(fullMessage);
-      }
-    }
-  };
-  return {
-    name: "logging",
-    onStart(ctx) {
-      const streamingLabel = ctx.streaming ? "(streaming)" : "";
-      log("info", `[${ctx.provider}] Starting ${ctx.modality} request ${streamingLabel}`.trim());
-      log("debug", `[${ctx.provider}] Model: ${ctx.modelId}`);
-    },
-    onEnd(ctx) {
-      const duration = ctx.endTime ? ctx.endTime - ctx.startTime : 0;
-      log("info", `[${ctx.provider}] Completed in ${duration}ms`);
-    },
-    onError(error, ctx) {
-      const duration = Date.now() - ctx.startTime;
-      log("error", `[${ctx.provider}] Error after ${duration}ms: ${error.message}`);
-    },
-    onStreamEvent(event, ctx) {
-      if (logStreamEvents) {
-        log("debug", `Stream event: ${event.type}`, { index: event.index });
-      }
-      return event;
-    },
-    onToolCall(tool, params, ctx) {
-      if (logToolCalls) {
-        log("info", `[${ctx.provider}] Tool call: ${tool.name}`);
-        log("debug", `[${ctx.provider}] Tool params:`, { params });
-      }
-    },
-    onToolResult(tool, result, ctx) {
-      if (logToolCalls) {
-        log("debug", `[${ctx.provider}] Tool result: ${tool.name}`, { result });
-      }
-    }
-  };
-}
-
 // src/index.ts
 var ai = {
   /** LLM instance factory */
@@ -2416,11 +2169,9 @@ export {
   isUserMessage,
   isVideoBlock,
   llm,
-  loggingMiddleware,
   messageStart,
   messageStop,
   objectDelta,
-  parsedObjectMiddleware,
   reasoning,
   text,
   textDelta,