@providerprotocol/ai 0.0.31 → 0.0.33

package/dist/index.js

@@ -13,11 +13,12 @@ import {
   createStreamResult,
   messageStart,
   messageStop,
+  objectDelta,
   textDelta,
   toolCallDelta,
   toolExecutionEnd,
   toolExecutionStart
-} from "./chunk-73IIE3QT.js";
+} from "./chunk-6S222DHN.js";
 import {
   AssistantMessage,
   Message,
@@ -114,10 +115,104 @@ function isBinaryBlock(block) {
   return block.type === ContentBlockType.Binary;
 }
 
+// src/middleware/runner.ts
+async function runHook(middlewares, hook, ctx, reverse = false) {
+  const ordered = reverse ? [...middlewares].reverse() : middlewares;
+  for (const mw of ordered) {
+    const fn = mw[hook];
+    if (fn) {
+      await fn.call(mw, ctx);
+    }
+  }
+}
+async function runErrorHook(middlewares, error, ctx) {
+  for (const mw of middlewares) {
+    if (mw.onError) {
+      try {
+        await mw.onError(error, ctx);
+      } catch (hookError) {
+        console.error(`[${mw.name}] Error in onError hook:`, hookError);
+      }
+    }
+  }
+}
+async function runToolHook(middlewares, hook, tool, data, ctx) {
+  for (const mw of middlewares) {
+    const fn = mw[hook];
+    if (fn) {
+      await fn.call(mw, tool, data, ctx);
+    }
+  }
+}
+function createStreamTransformer(middlewares, ctx) {
+  const streamMiddlewares = middlewares.filter((mw) => mw.onStreamEvent);
+  if (streamMiddlewares.length === 0) {
+    return (event) => event;
+  }
+  return (event) => {
+    let current = event;
+    for (const mw of streamMiddlewares) {
+      if (current === null) {
+        return null;
+      }
+      if (Array.isArray(current)) {
+        const results = [];
+        for (const e of current) {
+          const result = mw.onStreamEvent(e, ctx);
+          if (result === null) {
+            continue;
+          }
+          if (Array.isArray(result)) {
+            results.push(...result);
+          } else {
+            results.push(result);
+          }
+        }
+        current = results.length > 0 ? results : null;
+      } else {
+        current = mw.onStreamEvent(current, ctx);
+      }
+    }
+    return current;
+  };
+}
+async function runStreamEndHook(middlewares, ctx) {
+  for (const mw of middlewares) {
+    if (mw.onStreamEnd) {
+      await mw.onStreamEnd(ctx);
+    }
+  }
+}
+function createMiddlewareContext(modality, modelId, provider, streaming, request) {
+  return {
+    modality,
+    modelId,
+    provider,
+    streaming,
+    request,
+    response: void 0,
+    state: /* @__PURE__ */ new Map(),
+    startTime: Date.now(),
+    endTime: void 0
+  };
+}
+function createStreamContext(state) {
+  return { state };
+}
+
 // src/core/llm.ts
 var DEFAULT_MAX_ITERATIONS = 10;
 function llm(options) {
-  const { model: modelRef, config: explicitConfig = {}, params, system, tools, toolStrategy, structure } = options;
+  const {
+    model: modelRef,
+    config: explicitConfig = {},
+    params,
+    system,
+    tools,
+    toolStrategy,
+    structure,
+    middleware = []
+  } = options;
   const providerConfig = modelRef.providerConfig ?? {};
   const config = {
     ...providerConfig,
@@ -171,7 +266,8 @@ function llm(options) {
         toolStrategy,
         structure,
         history,
-        messages
+        messages,
+        middleware
       );
     },
     stream(historyOrInput, ...inputs) {
@@ -193,7 +289,8 @@ function llm(options) {
         toolStrategy,
         structure,
         history,
-        messages
+        messages,
+        middleware
       );
     }
   };
@@ -261,7 +358,7 @@ function inputToMessage(input) {
   }
   throw new Error("Invalid inference input");
 }
-async function executeGenerate(model, config, system, params, tools, toolStrategy, structure, history, newMessages) {
+async function executeGenerate(model, config, system, params, tools, toolStrategy, structure, history, newMessages, middleware) {
   validateMediaCapabilities(
     [...history, ...newMessages],
     model.capabilities,
@@ -273,56 +370,92 @@ async function executeGenerate(model, config, system, params, tools, toolStrateg
   const usages = [];
   let cycles = 0;
   let structuredData;
-  while (cycles < maxIterations + 1) {
-    cycles++;
-    const request = {
-      messages: allMessages,
-      system,
-      params,
-      tools,
-      structure,
-      config
-    };
-    const response = await model.complete(request);
-    usages.push(response.usage);
-    allMessages.push(response.message);
-    if (response.data !== void 0) {
-      structuredData = response.data;
-    }
-    if (response.message.hasToolCalls && tools && tools.length > 0) {
+  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
+      };
+      const response = await model.complete(request);
+      usages.push(response.usage);
+      allMessages.push(response.message);
       if (response.data !== void 0) {
-        break;
+        structuredData = response.data;
       }
-      if (cycles >= maxIterations) {
-        await toolStrategy?.onMaxIterations?.(maxIterations);
-        throw new UPPError(
-          `Tool execution exceeded maximum iterations (${maxIterations})`,
-          ErrorCode.InvalidRequest,
-          model.provider.name,
-          ModalityType.LLM
+      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 results = await executeTools(
+          response.message,
+          tools,
+          toolStrategy,
+          toolExecutions,
+          void 0,
+          middleware,
+          ctx
         );
+        allMessages.push(new ToolResultMessage(results));
+        continue;
       }
-      const results = await executeTools(
-        response.message,
-        tools,
-        toolStrategy,
-        toolExecutions
-      );
-      allMessages.push(new ToolResultMessage(results));
-      continue;
+      break;
     }
-    break;
+    const data = structure ? structuredData : void 0;
+    const turn = createTurn(
+      allMessages.slice(history.length),
+      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 runHook(middleware, "onEnd", ctx, true);
+    return turn;
+  } catch (error) {
+    const err = toError(error);
+    await runErrorHook(middleware, err, ctx);
+    throw err;
   }
-  const data = structure ? structuredData : void 0;
-  return createTurn(
-    allMessages.slice(history.length),
-    toolExecutions,
-    aggregateUsage(usages),
-    cycles,
-    data
-  );
 }
-function executeStream(model, config, system, params, tools, toolStrategy, structure, history, newMessages) {
+function executeStream(model, config, system, params, tools, toolStrategy, structure, history, newMessages, middleware) {
   validateMediaCapabilities(
     [...history, ...newMessages],
     model.capabilities,
@@ -336,6 +469,23 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
   let generatorError = null;
   let structuredData;
   let generatorCompleted = false;
+  const initialRequest = {
+    messages: allMessages,
+    system,
+    params,
+    tools,
+    structure,
+    config
+  };
+  const ctx = createMiddlewareContext(
+    "llm",
+    model.modelId,
+    model.provider.name,
+    true,
+    initialRequest
+  );
+  const streamCtx = createStreamContext(ctx.state);
+  const transformer = createStreamTransformer(middleware, streamCtx);
   let resolveGenerator;
   let rejectGenerator;
   let generatorSettled = false;
@@ -373,6 +523,8 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
   async function* generateStream() {
     try {
       ensureNotAborted();
+      await runHook(middleware, "onStart", ctx);
+      await runHook(middleware, "onRequest", ctx);
       while (cycles < maxIterations + 1) {
         cycles++;
         ensureNotAborted();
@@ -388,7 +540,15 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
         const streamResult = model.stream(request);
         for await (const event of streamResult) {
           ensureNotAborted();
-          yield event;
+          const transformed = transformer(event);
+          if (transformed === null) continue;
+          if (Array.isArray(transformed)) {
+            for (const e of transformed) {
+              yield e;
+            }
+          } else {
+            yield transformed;
+          }
         }
         const response = await streamResult.response;
         usages.push(response.usage);
@@ -415,22 +575,34 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
             tools,
             toolStrategy,
             toolExecutions,
-            (event) => toolEvents.push(event)
+            (event) => toolEvents.push(event),
+            middleware,
+            ctx
           );
           for (const event of toolEvents) {
             ensureNotAborted();
-            yield event;
+            const transformed = transformer(event);
+            if (transformed === null) continue;
+            if (Array.isArray(transformed)) {
+              for (const e of transformed) {
+                yield e;
+              }
+            } else {
+              yield transformed;
+            }
           }
           allMessages.push(new ToolResultMessage(results));
           continue;
         }
         break;
       }
+      await runStreamEndHook(middleware, streamCtx);
       generatorCompleted = true;
       resolveGenerator();
     } catch (error) {
       const err = toError(error);
       generatorError = err;
+      await runErrorHook(middleware, err, ctx);
       rejectGenerator(err);
       throw err;
     } finally {
@@ -451,17 +623,27 @@ function executeStream(model, config, system, params, tools, toolStrategy, struc
       throw generatorError;
     }
     const data = structure ? structuredData : void 0;
-    return createTurn(
+    const turn = createTurn(
       allMessages.slice(history.length),
       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 runHook(middleware, "onEnd", ctx, true);
+    return turn;
   };
   return createStreamResult(generateStream(), createTurnPromise, abortController);
 }
-async function executeTools(message, tools, toolStrategy, executions, onEvent) {
+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]));
@@ -498,6 +680,9 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
     }
     try {
       await toolStrategy?.onToolCall?.(tool, effectiveParams);
+      if (ctx) {
+        await runToolHook(middleware, "onToolCall", tool, effectiveParams, ctx);
+      }
     } catch (error) {
       return endWithError(toError(error).message);
     }
@@ -557,6 +742,9 @@ async function executeTools(message, tools, toolStrategy, executions, onEvent) {
           result = afterResult.result;
         }
       }
+      if (ctx) {
+        await runToolHook(middleware, "onToolResult", tool, result, ctx);
+      }
       const execution = {
         toolName,
         toolCallId: call.toolCallId,
@@ -640,7 +828,7 @@ function validateMediaCapabilities(messages, capabilities, providerName) {
 
 // src/core/embedding.ts
 function embedding(options) {
-  const { model: modelRef, config: explicitConfig = {}, params } = options;
+  const { model: modelRef, config: explicitConfig = {}, params, middleware = [] } = options;
   const providerConfig = modelRef.providerConfig ?? {};
   const config = {
     ...providerConfig,
@@ -664,9 +852,9 @@ function embedding(options) {
   function embed(input, embedOptions) {
     const inputs = Array.isArray(input) ? input : [input];
     if (embedOptions?.chunked) {
-      return createChunkedStream(boundModel, inputs, params, config, embedOptions);
+      return createChunkedStream(boundModel, inputs, params, config, embedOptions, middleware);
     }
-    return executeEmbed(boundModel, inputs, params, config, embedOptions?.signal);
+    return executeEmbed(boundModel, inputs, params, config, embedOptions?.signal, embedOptions?.inputType, middleware);
   }
   return {
     model: boundModel,
@@ -674,14 +862,36 @@ function embedding(options) {
     embed
   };
 }
-async function executeEmbed(model, inputs, params, config, signal) {
-  const response = await model.embed({
+async function executeEmbed(model, inputs, params, config, signal, inputType, middleware = []) {
+  const request = {
     inputs,
     params,
     config: config ?? {},
-    signal
-  });
-  return normalizeResponse(response, model.provider.name);
+    signal,
+    inputType
+  };
+  const ctx = createMiddlewareContext(
+    "embedding",
+    model.modelId,
+    model.provider.name,
+    false,
+    request
+  );
+  try {
+    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 {
@@ -726,7 +936,7 @@ function decodeBase64(b64, providerName) {
     );
   }
 }
-function createChunkedStream(model, inputs, params, config, options) {
+function createChunkedStream(model, inputs, params, config, options, middleware = []) {
   const abortController = new AbortController();
   const batchSize = options.batchSize ?? model.maxBatchSize;
   const concurrency = options.concurrency ?? 1;
@@ -767,6 +977,20 @@ function createChunkedStream(model, inputs, params, config, options) {
       options.signal.removeEventListener("abort", onExternalAbort);
     }
   };
+  const request = {
+    inputs,
+    params,
+    config: config ?? {},
+    signal: abortController.signal,
+    inputType: options.inputType
+  };
+  const ctx = createMiddlewareContext(
+    "embedding",
+    model.modelId,
+    model.provider.name,
+    true,
+    request
+  );
   async function* generate() {
     const total = inputs.length;
     const allEmbeddings = [];
@@ -776,6 +1000,8 @@ function createChunkedStream(model, inputs, params, config, options) {
       batches.push({ inputs: inputs.slice(i, i + batchSize), startIndex: i });
     }
     try {
+      await runHook(middleware, "onStart", ctx);
+      await runHook(middleware, "onRequest", ctx);
       for (let i = 0; i < batches.length; i += concurrency) {
         if (abortController.signal.aborted || options.signal?.aborted) {
           throw cancelError();
@@ -821,12 +1047,18 @@ function createChunkedStream(model, inputs, params, config, options) {
       const orderedEmbeddings = [...allEmbeddings].sort(
         (left, right) => left.index - right.index
       );
-      resolveResult({
+      const result = {
         embeddings: orderedEmbeddings,
         usage: { totalTokens }
-      });
+      };
+      ctx.response = { embeddings: orderedEmbeddings.map((e) => ({ vector: e.vector, index: e.index })), usage: { totalTokens } };
+      ctx.endTime = Date.now();
+      await runHook(middleware, "onResponse", ctx, true);
+      await runHook(middleware, "onEnd", ctx, true);
+      resolveResult(result);
     } catch (error) {
       const err = toError(error);
+      await runErrorHook(middleware, err, ctx);
       rejectResult(err);
       throw err;
     } finally {
@@ -843,7 +1075,7 @@ function createChunkedStream(model, inputs, params, config, options) {
 
 // src/core/image.ts
 function image(options) {
-  const { model: modelRef, config: explicitConfig = {}, params } = options;
+  const { model: modelRef, config: explicitConfig = {}, params, middleware = [] } = options;
   const providerConfig = modelRef.providerConfig ?? {};
   const config = {
     ...providerConfig,
@@ -878,47 +1110,88 @@ function image(options) {
     capabilities,
     async generate(input, options2) {
       const prompt = normalizeInput(input);
+      const request = {
+        prompt,
+        params,
+        config,
+        signal: options2?.signal
+      };
+      const ctx = createMiddlewareContext(
+        "image",
+        boundModel.modelId,
+        provider.name,
+        false,
+        request
+      );
       try {
-        const response = await boundModel.generate({
-          prompt,
-          params,
-          config,
-          signal: options2?.signal
-        });
-        return {
+        await runHook(middleware, "onStart", ctx);
+        await runHook(middleware, "onRequest", ctx);
+        const response = await boundModel.generate(request);
+        const result = {
           images: response.images,
           metadata: response.metadata,
           usage: response.usage
         };
+        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 normalizeImageError(error);
       }
     }
   };
   if (capabilities.streaming && boundModel.stream) {
-    const stream = boundModel.stream;
+    const streamFn = boundModel.stream;
     instance.stream = function(input) {
       const prompt = normalizeInput(input);
       const abortController = new AbortController();
-      const providerStream = stream({
+      const request = {
         prompt,
         params,
         config,
         signal: abortController.signal
-      });
-      const resultPromise = providerStream.response.then((response) => ({
-        images: response.images,
-        metadata: response.metadata,
-        usage: response.usage
-      })).catch((error) => {
-        throw normalizeImageError(error);
-      });
+      };
+      const ctx = createMiddlewareContext(
+        "image",
+        boundModel.modelId,
+        provider.name,
+        true,
+        request
+      );
+      const providerStream = streamFn(request);
+      const resultPromise = (async () => {
+        try {
+          const response = await providerStream.response;
+          const result = {
+            images: response.images,
+            metadata: response.metadata,
+            usage: response.usage
+          };
+          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 normalizeImageError(error);
+        }
+      })();
       async function* wrappedStream() {
         try {
+          await runHook(middleware, "onStart", ctx);
+          await runHook(middleware, "onRequest", ctx);
           for await (const event of providerStream) {
             yield event;
           }
         } catch (error) {
+          const err = toError(error);
+          await runErrorHook(middleware, err, ctx);
           throw normalizeImageError(error);
         }
       }
@@ -1818,6 +2091,274 @@ 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 */
@@ -1875,11 +2416,16 @@ export {
   isUserMessage,
   isVideoBlock,
   llm,
+  loggingMiddleware,
   messageStart,
   messageStop,
+  objectDelta,
+  parsedObjectMiddleware,
   reasoning,
   text,
   textDelta,
-  toolCallDelta
+  toolCallDelta,
+  toolExecutionEnd,
+  toolExecutionStart
 };
 //# sourceMappingURL=index.js.map