@providerprotocol/ai 0.0.34 → 0.0.36

package/dist/middleware/logging/index.d.ts

@@ -0,0 +1,76 @@
+import { M as Middleware } from '../../llm-ByUFPcFH.js';
+import '../../stream-S7nwQRqM.js';
+
+/**
+ * @fileoverview Logging middleware for request/response visibility.
+ *
+ * Provides configurable logging for LLM, embedding, and image operations,
+ * including timing, error tracking, and optional event logging.
+ *
+ * @module middleware/logging
+ */
+
+/**
+ * Log levels for filtering output.
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Options for logging middleware.
+ */
+interface LoggingOptions {
+    /**
+     * Minimum log level to output.
+     * @default 'info'
+     */
+    level?: LogLevel;
+    /**
+     * Log individual stream events.
+     * @default false
+     */
+    logStreamEvents?: boolean;
+    /**
+     * Log tool calls and results.
+     * @default true
+     */
+    logToolCalls?: boolean;
+    /**
+     * Custom logger function. If not provided, uses console.log.
+     * @param level - The log level
+     * @param message - The log message
+     * @param data - Optional additional data
+     */
+    logger?(level: LogLevel, message: string, data?: Record<string, unknown>): void;
+    /**
+     * Prefix for all log messages.
+     * @default '[PP]'
+     */
+    prefix?: string;
+}
+/**
+ * Creates a logging middleware for visibility into request lifecycle.
+ *
+ * This middleware logs the start, end, and errors of requests,
+ * with optional logging of stream events and tool calls.
+ *
+ * @param options - Configuration options
+ * @returns A middleware that logs request lifecycle events
+ *
+ * @example
+ * ```typescript
+ * import { llm } from '@providerprotocol/ai';
+ * import { loggingMiddleware } from '@providerprotocol/ai/middleware/logging';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ *
+ * const model = llm({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   middleware: [loggingMiddleware({ level: 'debug' })],
+ * });
+ *
+ * // Logs: [PP] [anthropic] Starting llm request (streaming)
+ * // Logs: [PP] [anthropic] Completed in 1234ms
+ * const result = await model.generate('Hello');
+ * ```
+ */
+declare function loggingMiddleware(options?: LoggingOptions): Middleware;
+
+export { type LogLevel, type LoggingOptions, loggingMiddleware };

package/dist/middleware/logging/index.js

@@ -0,0 +1,74 @@
+// 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}`);
+    },
+    onAbort(error, ctx) {
+      const duration = Date.now() - ctx.startTime;
+      log("warn", `[${ctx.provider}] Aborted 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 });
+      }
+    }
+  };
+}
+export {
+  loggingMiddleware
+};
+//# sourceMappingURL=index.js.map

package/dist/middleware/logging/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middleware/logging.ts"],"sourcesContent":["/**\n * @fileoverview Logging middleware for request/response visibility.\n *\n * Provides configurable logging for LLM, embedding, and image operations,\n * including timing, error tracking, and optional event logging.\n *\n * @module middleware/logging\n */\n\nimport type { Middleware, MiddlewareContext, StreamContext } from '../types/middleware.ts';\nimport type { StreamEvent } from '../types/stream.ts';\n\n/**\n * Log levels for filtering output.\n */\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error';\n\n/**\n * Options for logging middleware.\n */\nexport interface LoggingOptions {\n  /**\n   * Minimum log level to output.\n   * @default 'info'\n   */\n  level?: LogLevel;\n\n  /**\n   * Log individual stream events.\n   * @default false\n   */\n  logStreamEvents?: boolean;\n\n  /**\n   * Log tool calls and results.\n   * @default true\n   */\n  logToolCalls?: boolean;\n\n  /**\n   * Custom logger function. If not provided, uses console.log.\n   * @param level - The log level\n   * @param message - The log message\n   * @param data - Optional additional data\n   */\n  logger?(level: LogLevel, message: string, data?: Record<string, unknown>): void;\n\n  /**\n   * Prefix for all log messages.\n   * @default '[PP]'\n   */\n  prefix?: string;\n}\n\nconst LOG_LEVELS: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\n/**\n * Creates a logging middleware for visibility into request lifecycle.\n *\n * This middleware logs the start, end, and errors of requests,\n * with optional logging of stream events and tool calls.\n *\n * @param options - Configuration options\n * @returns A middleware that logs request lifecycle events\n *\n * @example\n * ```typescript\n * import { llm } from '@providerprotocol/ai';\n * import { loggingMiddleware } from '@providerprotocol/ai/middleware/logging';\n * import { anthropic } from '@providerprotocol/ai/anthropic';\n *\n * const model = llm({\n *   model: anthropic('claude-sonnet-4-20250514'),\n *   middleware: [loggingMiddleware({ level: 'debug' })],\n * });\n *\n * // Logs: [PP] [anthropic] Starting llm request (streaming)\n * // Logs: [PP] [anthropic] Completed in 1234ms\n * const result = await model.generate('Hello');\n * ```\n */\nexport function loggingMiddleware(options: LoggingOptions = {}): Middleware {\n  const {\n    level = 'info',\n    logStreamEvents = false,\n    logToolCalls = true,\n    logger,\n    prefix = '[PP]',\n  } = options;\n\n  const minLevel = LOG_LEVELS[level];\n\n  const log = (logLevel: LogLevel, message: string, data?: Record<string, unknown>) => {\n    if (LOG_LEVELS[logLevel] < minLevel) {\n      return;\n    }\n\n    const fullMessage = `${prefix} ${message}`;\n\n    if (logger) {\n      logger(logLevel, fullMessage, data);\n    } else {\n      const consoleMethod = logLevel === 'error' ? console.error : logLevel === 'warn' ? console.warn : console.log;\n      if (data) {\n        consoleMethod(fullMessage, data);\n      } else {\n        consoleMethod(fullMessage);\n      }\n    }\n  };\n\n  return {\n    name: 'logging',\n\n    onStart(ctx: MiddlewareContext): void {\n      const streamingLabel = ctx.streaming ? '(streaming)' : '';\n      log('info', `[${ctx.provider}] Starting ${ctx.modality} request ${streamingLabel}`.trim());\n      log('debug', `[${ctx.provider}] Model: ${ctx.modelId}`);\n    },\n\n    onEnd(ctx: MiddlewareContext): void {\n      const duration = ctx.endTime ? ctx.endTime - ctx.startTime : 0;\n      log('info', `[${ctx.provider}] Completed in ${duration}ms`);\n    },\n\n    onError(error: Error, ctx: MiddlewareContext): void {\n      const duration = Date.now() - ctx.startTime;\n      log('error', `[${ctx.provider}] Error after ${duration}ms: ${error.message}`);\n    },\n\n    onAbort(error: Error, ctx: MiddlewareContext): void {\n      const duration = Date.now() - ctx.startTime;\n      log('warn', `[${ctx.provider}] Aborted after ${duration}ms: ${error.message}`);\n    },\n\n    onStreamEvent(event: StreamEvent, ctx: StreamContext): StreamEvent {\n      if (logStreamEvents) {\n        log('debug', `Stream event: ${event.type}`, { index: event.index });\n      }\n      return event;\n    },\n\n    onToolCall(tool, params, ctx: MiddlewareContext): void {\n      if (logToolCalls) {\n        log('info', `[${ctx.provider}] Tool call: ${tool.name}`);\n        log('debug', `[${ctx.provider}] Tool params:`, { params });\n      }\n    },\n\n    onToolResult(tool, result, ctx: MiddlewareContext): void {\n      if (logToolCalls) {\n        log('debug', `[${ctx.provider}] Tool result: ${tool.name}`, { result });\n      }\n    },\n  };\n}\n"],"mappings":";AAsDA,IAAM,aAAuC;AAAA,EAC3C,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AACT;AA2BO,SAAS,kBAAkB,UAA0B,CAAC,GAAe;AAC1E,QAAM;AAAA,IACJ,QAAQ;AAAA,IACR,kBAAkB;AAAA,IAClB,eAAe;AAAA,IACf;AAAA,IACA,SAAS;AAAA,EACX,IAAI;AAEJ,QAAM,WAAW,WAAW,KAAK;AAEjC,QAAM,MAAM,CAAC,UAAoB,SAAiB,SAAmC;AACnF,QAAI,WAAW,QAAQ,IAAI,UAAU;AACnC;AAAA,IACF;AAEA,UAAM,cAAc,GAAG,MAAM,IAAI,OAAO;AAExC,QAAI,QAAQ;AACV,aAAO,UAAU,aAAa,IAAI;AAAA,IACpC,OAAO;AACL,YAAM,gBAAgB,aAAa,UAAU,QAAQ,QAAQ,aAAa,SAAS,QAAQ,OAAO,QAAQ;AAC1G,UAAI,MAAM;AACR,sBAAc,aAAa,IAAI;AAAA,MACjC,OAAO;AACL,sBAAc,WAAW;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IAEN,QAAQ,KAA8B;AACpC,YAAM,iBAAiB,IAAI,YAAY,gBAAgB;AACvD,UAAI,QAAQ,IAAI,IAAI,QAAQ,cAAc,IAAI,QAAQ,YAAY,cAAc,GAAG,KAAK,CAAC;AACzF,UAAI,SAAS,IAAI,IAAI,QAAQ,YAAY,IAAI,OAAO,EAAE;AAAA,IACxD;AAAA,IAEA,MAAM,KAA8B;AAClC,YAAM,WAAW,IAAI,UAAU,IAAI,UAAU,IAAI,YAAY;AAC7D,UAAI,QAAQ,IAAI,IAAI,QAAQ,kBAAkB,QAAQ,IAAI;AAAA,IAC5D;AAAA,IAEA,QAAQ,OAAc,KAA8B;AAClD,YAAM,WAAW,KAAK,IAAI,IAAI,IAAI;AAClC,UAAI,SAAS,IAAI,IAAI,QAAQ,iBAAiB,QAAQ,OAAO,MAAM,OAAO,EAAE;AAAA,IAC9E;AAAA,IAEA,QAAQ,OAAc,KAA8B;AAClD,YAAM,WAAW,KAAK,IAAI,IAAI,IAAI;AAClC,UAAI,QAAQ,IAAI,IAAI,QAAQ,mBAAmB,QAAQ,OAAO,MAAM,OAAO,EAAE;AAAA,IAC/E;AAAA,IAEA,cAAc,OAAoB,KAAiC;AACjE,UAAI,iBAAiB;AACnB,YAAI,SAAS,iBAAiB,MAAM,IAAI,IAAI,EAAE,OAAO,MAAM,MAAM,CAAC;AAAA,MACpE;AACA,aAAO;AAAA,IACT;AAAA,IAEA,WAAW,MAAM,QAAQ,KAA8B;AACrD,UAAI,cAAc;AAChB,YAAI,QAAQ,IAAI,IAAI,QAAQ,gBAAgB,KAAK,IAAI,EAAE;AACvD,YAAI,SAAS,IAAI,IAAI,QAAQ,kBAAkB,EAAE,OAAO,CAAC;AAAA,MAC3D;AAAA,IACF;AAAA,IAEA,aAAa,MAAM,QAAQ,KAA8B;AACvD,UAAI,cAAc;AAChB,YAAI,SAAS,IAAI,IAAI,QAAQ,kBAAkB,KAAK,IAAI,IAAI,EAAE,OAAO,CAAC;AAAA,MACxE;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/middleware/parsed-object/index.d.ts

@@ -0,0 +1,45 @@
+import { M as Middleware } from '../../llm-ByUFPcFH.js';
+import { E as EventDelta, S as StreamEvent } from '../../stream-S7nwQRqM.js';
+
+/**
+ * @fileoverview Parsed object middleware for incremental JSON parsing.
+ *
+ * This middleware parses partial JSON from ObjectDelta and ToolCallDelta
+ * stream events, providing incremental structured data during streaming.
+ *
+ * @module middleware/parsed-object
+ */
+
+/**
+ * Event delta with parsed JSON data.
+ * Extended by parsedObjectMiddleware when parsing is enabled.
+ */
+interface ParsedEventDelta extends EventDelta {
+    /** Incrementally parsed JSON value */
+    parsed?: unknown;
+}
+/**
+ * Stream event with parsed JSON data.
+ * Returned by parsedObjectMiddleware for ObjectDelta and ToolCallDelta events.
+ */
+interface ParsedStreamEvent extends Omit<StreamEvent, 'delta'> {
+    delta: ParsedEventDelta;
+}
+/**
+ * Options for parsed object middleware.
+ */
+interface ParsedObjectOptions {
+    /**
+     * Parse ObjectDelta events (structured output responses).
+     * @default true
+     */
+    parseObjects?: boolean;
+    /**
+     * Parse ToolCallDelta events (tool call arguments).
+     * @default true
+     */
+    parseToolCalls?: boolean;
+}
+declare function parsedObjectMiddleware(options?: ParsedObjectOptions): Middleware;
+
+export { type ParsedEventDelta, type ParsedObjectOptions, type ParsedStreamEvent, parsedObjectMiddleware };

package/dist/middleware/parsed-object/index.js

@@ -0,0 +1,73 @@
+import {
+  parsePartialJson
+} from "../../chunk-I53CI6ZZ.js";
+import {
+  StreamEventType
+} from "../../chunk-RJGTRQ47.js";
+
+// 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);
+    }
+  };
+}
+export {
+  parsedObjectMiddleware
+};
+//# sourceMappingURL=index.js.map

package/dist/middleware/parsed-object/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middleware/parsed-object.ts"],"sourcesContent":["/**\n * @fileoverview Parsed object middleware for incremental JSON parsing.\n *\n * This middleware parses partial JSON from ObjectDelta and ToolCallDelta\n * stream events, providing incremental structured data during streaming.\n *\n * @module middleware/parsed-object\n */\n\nimport type { Middleware, StreamContext } from '../types/middleware.ts';\nimport type { EventDelta, StreamEvent } from '../types/stream.ts';\nimport { StreamEventType } from '../types/stream.ts';\nimport { parsePartialJson } from '../utils/partial-json.ts';\n\n/**\n * Event delta with parsed JSON data.\n * Extended by parsedObjectMiddleware when parsing is enabled.\n */\nexport interface ParsedEventDelta extends EventDelta {\n  /** Incrementally parsed JSON value */\n  parsed?: unknown;\n}\n\n/**\n * Stream event with parsed JSON data.\n * Returned by parsedObjectMiddleware for ObjectDelta and ToolCallDelta events.\n */\nexport interface ParsedStreamEvent extends Omit<StreamEvent, 'delta'> {\n  delta: ParsedEventDelta;\n}\n\n/**\n * Options for parsed object middleware.\n */\nexport interface ParsedObjectOptions {\n  /**\n   * Parse ObjectDelta events (structured output responses).\n   * @default true\n   */\n  parseObjects?: boolean;\n\n  /**\n   * Parse ToolCallDelta events (tool call arguments).\n   * @default true\n   */\n  parseToolCalls?: boolean;\n}\n\n/**\n * Creates a middleware that parses partial JSON from stream events.\n *\n * This middleware accumulates text from ObjectDelta events and tool\n * argument JSON from ToolCallDelta events, then parses them incrementally\n * using partial JSON parsing. The parsed result is added to the event's\n * `parsed` field.\n *\n * @param options - Configuration options\n * @returns A middleware that adds parsed JSON to stream events\n *\n * @example\n * ```typescript\n * import { llm } from '@providerprotocol/ai';\n * import { parsedObjectMiddleware } from '@providerprotocol/ai/middleware/parsed-object';\n * import { anthropic } from '@providerprotocol/ai/anthropic';\n *\n * const model = llm({\n *   model: anthropic('claude-sonnet-4-20250514'),\n *   structure: mySchema,\n *   middleware: [parsedObjectMiddleware()],\n * });\n *\n * for await (const event of model.stream('Extract data from this text')) {\n *   if (event.type === 'object_delta') {\n *     // event.delta.parsed contains incrementally parsed object\n *     console.log(event.delta.parsed);\n *   }\n * }\n * ```\n */\n/** State key for accumulated object text */\nconst ACCUMULATED_TEXT_KEY = 'parsedObject:text';\n/** State key for accumulated tool arguments */\nconst ACCUMULATED_ARGS_KEY = 'parsedObject:args';\n\n/**\n * Gets or creates the accumulated text map from state.\n */\nfunction getAccumulatedText(state: Map<string, unknown>): Map<number, string> {\n  let map = state.get(ACCUMULATED_TEXT_KEY) as Map<number, string> | undefined;\n  if (!map) {\n    map = new Map();\n    state.set(ACCUMULATED_TEXT_KEY, map);\n  }\n  return map;\n}\n\n/**\n * Gets or creates the accumulated args map from state.\n */\nfunction getAccumulatedArgs(state: Map<string, unknown>): Map<number, string> {\n  let map = state.get(ACCUMULATED_ARGS_KEY) as Map<number, string> | undefined;\n  if (!map) {\n    map = new Map();\n    state.set(ACCUMULATED_ARGS_KEY, map);\n  }\n  return map;\n}\n\nexport function parsedObjectMiddleware(options: ParsedObjectOptions = {}): Middleware {\n  const { parseObjects = true, parseToolCalls = true } = options;\n\n  return {\n    name: 'parsed-object',\n\n    onStreamEvent(event: StreamEvent, ctx: StreamContext): StreamEvent | StreamEvent[] | null {\n      if (parseObjects && event.type === StreamEventType.ObjectDelta) {\n        const accumulatedText = getAccumulatedText(ctx.state);\n        const current = accumulatedText.get(event.index) ?? '';\n        const newText = current + (event.delta.text ?? '');\n        accumulatedText.set(event.index, newText);\n\n        const parseResult = parsePartialJson(newText);\n\n        const parsedEvent: ParsedStreamEvent = {\n          ...event,\n          delta: {\n            ...event.delta,\n            parsed: parseResult.value,\n          },\n        };\n        return parsedEvent as StreamEvent;\n      }\n\n      if (parseToolCalls && event.type === StreamEventType.ToolCallDelta) {\n        const accumulatedArgs = getAccumulatedArgs(ctx.state);\n        const current = accumulatedArgs.get(event.index) ?? '';\n        const newJson = current + (event.delta.argumentsJson ?? '');\n        accumulatedArgs.set(event.index, newJson);\n\n        const parseResult = parsePartialJson(newJson);\n\n        const parsedEvent: ParsedStreamEvent = {\n          ...event,\n          delta: {\n            ...event.delta,\n            parsed: parseResult.value,\n          },\n        };\n        return parsedEvent as StreamEvent;\n      }\n\n      return event;\n    },\n\n    onStreamEnd(ctx: StreamContext): void {\n      // Clean up accumulated state to prevent memory buildup in long sessions\n      ctx.state.delete(ACCUMULATED_TEXT_KEY);\n      ctx.state.delete(ACCUMULATED_ARGS_KEY);\n    },\n  };\n}\n"],"mappings":";;;;;;;;AAgFA,IAAM,uBAAuB;AAE7B,IAAM,uBAAuB;AAK7B,SAAS,mBAAmB,OAAkD;AAC5E,MAAI,MAAM,MAAM,IAAI,oBAAoB;AACxC,MAAI,CAAC,KAAK;AACR,UAAM,oBAAI,IAAI;AACd,UAAM,IAAI,sBAAsB,GAAG;AAAA,EACrC;AACA,SAAO;AACT;AAKA,SAAS,mBAAmB,OAAkD;AAC5E,MAAI,MAAM,MAAM,IAAI,oBAAoB;AACxC,MAAI,CAAC,KAAK;AACR,UAAM,oBAAI,IAAI;AACd,UAAM,IAAI,sBAAsB,GAAG;AAAA,EACrC;AACA,SAAO;AACT;AAEO,SAAS,uBAAuB,UAA+B,CAAC,GAAe;AACpF,QAAM,EAAE,eAAe,MAAM,iBAAiB,KAAK,IAAI;AAEvD,SAAO;AAAA,IACL,MAAM;AAAA,IAEN,cAAc,OAAoB,KAAwD;AACxF,UAAI,gBAAgB,MAAM,SAAS,gBAAgB,aAAa;AAC9D,cAAM,kBAAkB,mBAAmB,IAAI,KAAK;AACpD,cAAM,UAAU,gBAAgB,IAAI,MAAM,KAAK,KAAK;AACpD,cAAM,UAAU,WAAW,MAAM,MAAM,QAAQ;AAC/C,wBAAgB,IAAI,MAAM,OAAO,OAAO;AAExC,cAAM,cAAc,iBAAiB,OAAO;AAE5C,cAAM,cAAiC;AAAA,UACrC,GAAG;AAAA,UACH,OAAO;AAAA,YACL,GAAG,MAAM;AAAA,YACT,QAAQ,YAAY;AAAA,UACtB;AAAA,QACF;AACA,eAAO;AAAA,MACT;AAEA,UAAI,kBAAkB,MAAM,SAAS,gBAAgB,eAAe;AAClE,cAAM,kBAAkB,mBAAmB,IAAI,KAAK;AACpD,cAAM,UAAU,gBAAgB,IAAI,MAAM,KAAK,KAAK;AACpD,cAAM,UAAU,WAAW,MAAM,MAAM,iBAAiB;AACxD,wBAAgB,IAAI,MAAM,OAAO,OAAO;AAExC,cAAM,cAAc,iBAAiB,OAAO;AAE5C,cAAM,cAAiC;AAAA,UACrC,GAAG;AAAA,UACH,OAAO;AAAA,YACL,GAAG,MAAM;AAAA,YACT,QAAQ,YAAY;AAAA,UACtB;AAAA,QACF;AACA,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT;AAAA,IAEA,YAAY,KAA0B;AAEpC,UAAI,MAAM,OAAO,oBAAoB;AACrC,UAAI,MAAM,OAAO,oBAAoB;AAAA,IACvC;AAAA,EACF;AACF;","names":[]}

package/dist/middleware/pubsub/index.d.ts

@@ -0,0 +1,97 @@
+import { M as Middleware } from '../../llm-ByUFPcFH.js';
+import { M as MemoryAdapterOptions, P as PubSubAdapter, a as PubSubOptions } from '../../types-CE4B7pno.js';
+export { C as CompletionCallback, S as StoredStream, b as SubscriptionCallback, U as Unsubscribe } from '../../types-CE4B7pno.js';
+import '../../stream-S7nwQRqM.js';
+
+/**
+ * @fileoverview In-memory storage adapter for pub-sub middleware.
+ *
+ * Provides a simple Map-based implementation for temporary stream
+ * storage during active generation.
+ *
+ * @module middleware/pubsub/memory-adapter
+ */
+
+/**
+ * Creates an in-memory storage adapter for pub-sub middleware.
+ *
+ * Stores streams in a Map. Throws when maxStreams is exceeded.
+ * Streams are created lazily on first append or subscribe.
+ *
+ * @param options - Adapter configuration
+ * @returns A PubSubAdapter instance
+ *
+ * @example
+ * ```typescript
+ * import { pubsubMiddleware, memoryAdapter } from '@providerprotocol/ai/middleware/pubsub';
+ *
+ * const adapter = memoryAdapter({ maxStreams: 500 });
+ * ```
+ */
+declare function memoryAdapter(options?: MemoryAdapterOptions): PubSubAdapter;
+
+/**
+ * @fileoverview Pub-sub middleware for stream resumption.
+ *
+ * Enables reconnecting clients to catch up on missed events during
+ * active generation. The middleware buffers events and publishes them
+ * to subscribers. Server routes handle reconnection logic using the
+ * exported `createSubscriberStream` utility.
+ *
+ * @module middleware/pubsub
+ */
+
+/**
+ * Gets the stream ID from middleware state.
+ *
+ * @param state - Middleware state map
+ * @returns Stream ID or undefined if not set
+ */
+declare function getStreamId(state: Map<string, unknown>): string | undefined;
+/**
+ * Gets the adapter from middleware state.
+ *
+ * @param state - Middleware state map
+ * @returns Adapter or undefined if not set
+ */
+declare function getAdapter(state: Map<string, unknown>): PubSubAdapter | undefined;
+/**
+ * Creates pub-sub middleware for stream buffering and publishing.
+ *
+ * The middleware:
+ * - Creates stream entries for new requests
+ * - Buffers all stream events
+ * - Publishes events to subscribers
+ * - On stream end: notifies subscribers, then removes from adapter
+ *
+ * Server routes handle reconnection logic using `streamSubscriber`.
+ *
+ * @param options - Middleware configuration
+ * @returns Middleware instance
+ *
+ * @example
+ * ```typescript
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { pubsubMiddleware, memoryAdapter } from '@providerprotocol/ai/middleware/pubsub';
+ * import { h3 } from '@providerprotocol/ai/middleware/pubsub/server';
+ *
+ * const adapter = memoryAdapter();
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const { input, conversationId } = await readBody(event);
+ *
+ *   // Fire and forget - subscriber connects immediately, events flow when ready
+ *   const model = llm({
+ *     model: anthropic('claude-sonnet-4-20250514'),
+ *     middleware: [pubsubMiddleware({ adapter, streamId: conversationId })],
+ *   });
+ *   model.stream(input).then(turn => saveToDatabase(turn));
+ *
+ *   return h3.streamSubscriber(conversationId, adapter, event);
+ * });
+ * ```
+ */
+declare function pubsubMiddleware(options?: PubSubOptions): Middleware;
+
+export { MemoryAdapterOptions, PubSubAdapter, PubSubOptions, getAdapter, getStreamId, memoryAdapter, pubsubMiddleware };

package/dist/middleware/pubsub/index.js

@@ -0,0 +1,160 @@
+// src/middleware/pubsub/memory-adapter.ts
+function memoryAdapter(options = {}) {
+  const { maxStreams = 1e3 } = options;
+  const streams = /* @__PURE__ */ new Map();
+  const eventCursors = /* @__PURE__ */ new WeakMap();
+  const scheduleCallback = (callback) => {
+    queueMicrotask(() => {
+      try {
+        callback();
+      } catch {
+      }
+    });
+  };
+  const getOrCreate = (streamId) => {
+    let entry = streams.get(streamId);
+    if (!entry) {
+      if (streams.size >= maxStreams) {
+        throw new Error(`Maximum concurrent streams (${maxStreams}) exceeded`);
+      }
+      entry = {
+        stream: {
+          streamId,
+          createdAt: Date.now(),
+          events: []
+        },
+        subscribers: /* @__PURE__ */ new Set()
+      };
+      streams.set(streamId, entry);
+    }
+    return entry;
+  };
+  return {
+    async exists(streamId) {
+      return streams.has(streamId);
+    },
+    async append(streamId, event) {
+      const entry = getOrCreate(streamId);
+      entry.stream.events.push(event);
+      eventCursors.set(event, entry.stream.events.length - 1);
+    },
+    async getEvents(streamId) {
+      const entry = streams.get(streamId);
+      return entry ? [...entry.stream.events] : [];
+    },
+    subscribe(streamId, onEvent, onComplete) {
+      const entry = getOrCreate(streamId);
+      const subscriber = { onEvent, onComplete };
+      entry.subscribers.add(subscriber);
+      return () => {
+        entry.subscribers.delete(subscriber);
+      };
+    },
+    publish(streamId, event) {
+      const entry = streams.get(streamId);
+      if (!entry) {
+        return;
+      }
+      const cursor = eventCursors.get(event) ?? entry.stream.events.length - 1;
+      for (const subscriber of entry.subscribers) {
+        scheduleCallback(() => {
+          subscriber.onEvent(event, cursor);
+        });
+      }
+    },
+    async remove(streamId) {
+      const entry = streams.get(streamId);
+      if (entry) {
+        for (const subscriber of entry.subscribers) {
+          scheduleCallback(subscriber.onComplete);
+        }
+        streams.delete(streamId);
+      }
+    }
+  };
+}
+
+// src/middleware/pubsub/index.ts
+var STATE_KEY_STREAM_ID = "pubsub:streamId";
+var STATE_KEY_ADAPTER = "pubsub:adapter";
+function getStreamId(state) {
+  return state.get(STATE_KEY_STREAM_ID);
+}
+function getAdapter(state) {
+  return state.get(STATE_KEY_ADAPTER);
+}
+function pubsubMiddleware(options = {}) {
+  const {
+    adapter = memoryAdapter(),
+    streamId
+  } = options;
+  const appendChains = /* @__PURE__ */ new Map();
+  const enqueueAppend = (id, event) => {
+    const state = appendChains.get(id) ?? { chain: Promise.resolve() };
+    const task = state.chain.catch(() => {
+    }).then(async () => {
+      await adapter.append(id, event);
+      adapter.publish(id, event);
+    });
+    state.chain = task.catch(() => {
+    });
+    appendChains.set(id, state);
+  };
+  const waitForAppends = async (id) => {
+    const state = appendChains.get(id);
+    if (!state) {
+      return;
+    }
+    await state.chain.catch(() => {
+    });
+  };
+  const clearAppendState = (id) => {
+    appendChains.delete(id);
+  };
+  const finalizeStreamByState = async (state) => {
+    const id = state.get(STATE_KEY_STREAM_ID);
+    if (!id) {
+      return;
+    }
+    await waitForAppends(id);
+    clearAppendState(id);
+    await adapter.remove(id).catch(() => {
+    });
+  };
+  return {
+    name: "pubsub",
+    onStart(ctx) {
+      ctx.state.set(STATE_KEY_ADAPTER, adapter);
+      if (streamId) {
+        ctx.state.set(STATE_KEY_STREAM_ID, streamId);
+        adapter.subscribe(streamId, () => {
+        }, () => {
+        })();
+      }
+    },
+    onStreamEvent(event, ctx) {
+      const id = ctx.state.get(STATE_KEY_STREAM_ID);
+      if (!id) {
+        return event;
+      }
+      enqueueAppend(id, event);
+      return event;
+    },
+    async onStreamEnd(ctx) {
+      await finalizeStreamByState(ctx.state);
+    },
+    async onError(_error, ctx) {
+      await finalizeStreamByState(ctx.state);
+    },
+    async onAbort(_error, ctx) {
+      await finalizeStreamByState(ctx.state);
+    }
+  };
+}
+export {
+  getAdapter,
+  getStreamId,
+  memoryAdapter,
+  pubsubMiddleware
+};
+//# sourceMappingURL=index.js.map

package/dist/middleware/pubsub/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middleware/pubsub/memory-adapter.ts","../../../src/middleware/pubsub/index.ts"],"sourcesContent":["/**\n * @fileoverview In-memory storage adapter for pub-sub middleware.\n *\n * Provides a simple Map-based implementation for temporary stream\n * storage during active generation.\n *\n * @module middleware/pubsub/memory-adapter\n */\n\nimport type { StreamEvent } from '../../types/stream.ts';\nimport type {\n  PubSubAdapter,\n  StoredStream,\n  SubscriptionCallback,\n  CompletionCallback,\n  Unsubscribe,\n  MemoryAdapterOptions,\n} from './types.ts';\n\ninterface MutableStoredStream {\n  streamId: string;\n  createdAt: number;\n  events: StreamEvent[];\n}\n\ninterface Subscriber {\n  onEvent: SubscriptionCallback;\n  onComplete: CompletionCallback;\n}\n\ninterface StreamEntry {\n  stream: MutableStoredStream;\n  subscribers: Set<Subscriber>;\n}\n\n/**\n * Creates an in-memory storage adapter for pub-sub middleware.\n *\n * Stores streams in a Map. Throws when maxStreams is exceeded.\n * Streams are created lazily on first append or subscribe.\n *\n * @param options - Adapter configuration\n * @returns A PubSubAdapter instance\n *\n * @example\n * ```typescript\n * import { pubsubMiddleware, memoryAdapter } from '@providerprotocol/ai/middleware/pubsub';\n *\n * const adapter = memoryAdapter({ maxStreams: 500 });\n * ```\n */\nexport function memoryAdapter(options: MemoryAdapterOptions = {}): PubSubAdapter {\n  const { maxStreams = 1000 } = options;\n\n  const streams = new Map<string, StreamEntry>();\n  const eventCursors = new WeakMap<StreamEvent, number>();\n\n  const scheduleCallback = (callback: () => void): void => {\n    queueMicrotask(() => {\n      try {\n        callback();\n      } catch {\n        // Subscriber errors should not affect other subscribers\n      }\n    });\n  };\n\n  const getOrCreate = (streamId: string): StreamEntry => {\n    let entry = streams.get(streamId);\n    if (!entry) {\n      if (streams.size >= maxStreams) {\n        throw new Error(`Maximum concurrent streams (${maxStreams}) exceeded`);\n      }\n      entry = {\n        stream: {\n          streamId,\n          createdAt: Date.now(),\n          events: [],\n        },\n        subscribers: new Set(),\n      };\n      streams.set(streamId, entry);\n    }\n    return entry;\n  };\n\n  return {\n    async exists(streamId): Promise<boolean> {\n      return streams.has(streamId);\n    },\n\n    async append(streamId, event): Promise<void> {\n      const entry = getOrCreate(streamId);\n      entry.stream.events.push(event);\n      eventCursors.set(event, entry.stream.events.length - 1);\n    },\n\n    async getEvents(streamId): Promise<StreamEvent[]> {\n      const entry = streams.get(streamId);\n      return entry ? [...entry.stream.events] : [];\n    },\n\n    subscribe(streamId, onEvent, onComplete): Unsubscribe {\n      const entry = getOrCreate(streamId);\n      const subscriber: Subscriber = { onEvent, onComplete };\n      entry.subscribers.add(subscriber);\n\n      return () => {\n        entry.subscribers.delete(subscriber);\n      };\n    },\n\n    publish(streamId, event): void {\n      const entry = streams.get(streamId);\n      if (!entry) {\n        return;\n      }\n\n      const cursor = eventCursors.get(event) ?? entry.stream.events.length - 1;\n      for (const subscriber of entry.subscribers) {\n        scheduleCallback(() => {\n          subscriber.onEvent(event, cursor);\n        });\n      }\n    },\n\n    async remove(streamId): Promise<void> {\n      const entry = streams.get(streamId);\n      if (entry) {\n        for (const subscriber of entry.subscribers) {\n          scheduleCallback(subscriber.onComplete);\n        }\n        streams.delete(streamId);\n      }\n    },\n  };\n}\n","/**\n * @fileoverview Pub-sub middleware for stream resumption.\n *\n * Enables reconnecting clients to catch up on missed events during\n * active generation. The middleware buffers events and publishes them\n * to subscribers. Server routes handle reconnection logic using the\n * exported `createSubscriberStream` utility.\n *\n * @module middleware/pubsub\n */\n\nimport type {\n  Middleware,\n  MiddlewareContext,\n  StreamContext,\n} from '../../types/middleware.ts';\nimport type { StreamEvent } from '../../types/stream.ts';\nimport type { PubSubAdapter, PubSubOptions } from './types.ts';\nimport { memoryAdapter } from './memory-adapter.ts';\n\nexport type {\n  PubSubAdapter,\n  PubSubOptions,\n  StoredStream,\n  SubscriptionCallback,\n  CompletionCallback,\n  Unsubscribe,\n  MemoryAdapterOptions,\n} from './types.ts';\nexport { memoryAdapter } from './memory-adapter.ts';\n\nconst STATE_KEY_STREAM_ID = 'pubsub:streamId';\nconst STATE_KEY_ADAPTER = 'pubsub:adapter';\n\ninterface AppendChainState {\n  chain: Promise<void>;\n}\n\n/**\n * Gets the stream ID from middleware state.\n *\n * @param state - Middleware state map\n * @returns Stream ID or undefined if not set\n */\nexport function getStreamId(state: Map<string, unknown>): string | undefined {\n  return state.get(STATE_KEY_STREAM_ID) as string | undefined;\n}\n\n/**\n * Gets the adapter from middleware state.\n *\n * @param state - Middleware state map\n * @returns Adapter or undefined if not set\n */\nexport function getAdapter(state: Map<string, unknown>): PubSubAdapter | undefined {\n  return state.get(STATE_KEY_ADAPTER) as PubSubAdapter | undefined;\n}\n\n/**\n * Creates pub-sub middleware for stream buffering and publishing.\n *\n * The middleware:\n * - Creates stream entries for new requests\n * - Buffers all stream events\n * - Publishes events to subscribers\n * - On stream end: notifies subscribers, then removes from adapter\n *\n * Server routes handle reconnection logic using `streamSubscriber`.\n *\n * @param options - Middleware configuration\n * @returns Middleware instance\n *\n * @example\n * ```typescript\n * import { llm } from '@providerprotocol/ai';\n * import { anthropic } from '@providerprotocol/ai/anthropic';\n * import { pubsubMiddleware, memoryAdapter } from '@providerprotocol/ai/middleware/pubsub';\n * import { h3 } from '@providerprotocol/ai/middleware/pubsub/server';\n *\n * const adapter = memoryAdapter();\n *\n * export default defineEventHandler(async (event) => {\n *   const { input, conversationId } = await readBody(event);\n *\n *   // Fire and forget - subscriber connects immediately, events flow when ready\n *   const model = llm({\n *     model: anthropic('claude-sonnet-4-20250514'),\n *     middleware: [pubsubMiddleware({ adapter, streamId: conversationId })],\n *   });\n *   model.stream(input).then(turn => saveToDatabase(turn));\n *\n *   return h3.streamSubscriber(conversationId, adapter, event);\n * });\n * ```\n */\nexport function pubsubMiddleware(options: PubSubOptions = {}): Middleware {\n  const {\n    adapter = memoryAdapter(),\n    streamId,\n  } = options;\n\n  const appendChains = new Map<string, AppendChainState>();\n\n  const enqueueAppend = (id: string, event: StreamEvent): void => {\n    const state = appendChains.get(id) ?? { chain: Promise.resolve() };\n\n    const task = state.chain\n      .catch(() => {})\n      .then(async () => {\n        await adapter.append(id, event);\n        adapter.publish(id, event);\n      });\n\n    state.chain = task.catch(() => {});\n    appendChains.set(id, state);\n  };\n\n  const waitForAppends = async (id: string): Promise<void> => {\n    const state = appendChains.get(id);\n    if (!state) {\n      return;\n    }\n\n    await state.chain.catch(() => {});\n  };\n\n  const clearAppendState = (id: string): void => {\n    appendChains.delete(id);\n  };\n\n  /**\n   * Finalizes a stream by marking completion and removing from adapter.\n   *\n   * Called on any terminal state (complete, error, abort). After finalization,\n   * the stream is removed from the adapter. Apps should use `.then()` to persist\n   * completed conversations and serve them from their own storage on reconnect.\n   */\n  const finalizeStreamByState = async (state: Map<string, unknown>): Promise<void> => {\n    const id = state.get(STATE_KEY_STREAM_ID) as string | undefined;\n    if (!id) {\n      return;\n    }\n\n    await waitForAppends(id);\n    clearAppendState(id);\n\n    // Remove from adapter (notifies subscribers) - apps persist via .then()\n    await adapter.remove(id).catch(() => {});\n  };\n\n  return {\n    name: 'pubsub',\n\n    onStart(ctx: MiddlewareContext): void {\n      ctx.state.set(STATE_KEY_ADAPTER, adapter);\n\n      if (streamId) {\n        ctx.state.set(STATE_KEY_STREAM_ID, streamId);\n        // Ensure stream exists immediately so exists() returns true\n        // before first token arrives (prevents duplicate generations)\n        adapter.subscribe(streamId, () => {}, () => {})();\n      }\n    },\n\n    onStreamEvent(event: StreamEvent, ctx: StreamContext): StreamEvent {\n      const id = ctx.state.get(STATE_KEY_STREAM_ID) as string | undefined;\n      if (!id) {\n        return event;\n      }\n\n      enqueueAppend(id, event);\n\n      return event;\n    },\n\n    async onStreamEnd(ctx: StreamContext): Promise<void> {\n      await finalizeStreamByState(ctx.state);\n    },\n\n    async onError(_error: Error, ctx: MiddlewareContext): Promise<void> {\n      await finalizeStreamByState(ctx.state);\n    },\n\n    async onAbort(_error: Error, ctx: MiddlewareContext): Promise<void> {\n      await finalizeStreamByState(ctx.state);\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/middleware/pubsub/server/express/index.d.ts

@@ -0,0 +1,66 @@
+import { P as PubSubAdapter } from '../../../../types-CE4B7pno.js';
+import '../../../../stream-S7nwQRqM.js';
+
+/**
+ * @fileoverview Express/Connect adapter for pub-sub stream resumption.
+ *
+ * Provides utilities for Express.js or Connect-based servers
+ * to handle stream reconnections.
+ *
+ * @module middleware/pubsub/server/express
+ */
+
+/**
+ * Express Response interface (minimal type to avoid dependency).
+ */
+interface ExpressResponse {
+    setHeader(name: string, value: string): void;
+    write(chunk: string): boolean;
+    end(): void;
+    on(event: 'close', listener: () => void): void;
+}
+/**
+ * Stream buffered and live events to an Express response.
+ *
+ * Handles reconnection for Express routes:
+ * 1. Replays buffered events from the adapter
+ * 2. Subscribes to live events until completion signal
+ * 3. Ends when stream completes or client disconnects
+ *
+ * @param streamId - The stream ID to subscribe to
+ * @param adapter - The pub-sub adapter instance
+ * @param res - Express response object
+ *
+ * @example
+ * ```typescript
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { pubsubMiddleware, memoryAdapter } from '@providerprotocol/ai/middleware/pubsub';
+ * import { express } from '@providerprotocol/ai/middleware/pubsub/server';
+ *
+ * const adapter = memoryAdapter();
+ *
+ * app.post('/api/chat', async (req, res) => {
+ *   const { input, conversationId } = req.body;
+ *
+ *   if (!await adapter.exists(conversationId)) {
+ *     const model = llm({
+ *       model: anthropic('claude-sonnet-4-20250514'),
+ *       middleware: [pubsubMiddleware({ adapter, streamId: conversationId })],
+ *     });
+ *     model.stream(input).then(turn => saveToDatabase(conversationId, turn));
+ *   }
+ *
+ *   return express.streamSubscriber(conversationId, adapter, res);
+ * });
+ * ```
+ */
+declare function streamSubscriber(streamId: string, adapter: PubSubAdapter, res: ExpressResponse): Promise<void>;
+/**
+ * Express adapter namespace for pub-sub server utilities.
+ */
+declare const express: {
+    streamSubscriber: typeof streamSubscriber;
+};
+
+export { express, streamSubscriber };

package/dist/middleware/pubsub/server/express/index.js

@@ -0,0 +1,11 @@
+import {
+  express,
+  streamSubscriber
+} from "../../../../chunk-5IWHCXKN.js";
+import "../../../../chunk-EPB3GQNL.js";
+import "../../../../chunk-ETBFOLQN.js";
+export {
+  express,
+  streamSubscriber
+};
+//# sourceMappingURL=index.js.map

package/dist/middleware/pubsub/server/express/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}