@tangle-network/agent-core 0.13.2 → 0.14.0

package/dist/interactions/mcp-server.js

@@ -1,4 +1,4 @@
-import { n as closeHttpServer, r as waitForSettled, t as SerializedTransportLifecycle } from "../lifecycle-BljLcnY5.js";
+import { n as closeHttpServer, r as waitForSettled, t as SerializedTransportLifecycle } from "../lifecycle-wjO8lqUZ.js";
 import { z } from "zod";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { createServer } from "node:http";
@@ -6,7 +6,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isJSONRPCErrorResponse, isJSONRPCRequest, isJSONRPCResultResponse } from "@modelcontextprotocol/sdk/types.js";
-//#region src/interactions/mcp-server.ts
+// src/interactions/mcp-server.ts
 const DEFAULT_INTERACTION_MCP_SERVER_NAME = "tangle-interaction";
 const MAX_MCP_BODY_BYTES = 4194304;
 const MAX_MCP_REPLAY_EVENTS = 1024;
@@ -363,7 +363,6 @@ var InteractionMcpServer = class {
 		return generationId;
 	}
 };
-//#endregion
 export { DEFAULT_INTERACTION_MCP_SERVER_NAME, InteractionMcpServer, interactionMcpToolName };
 
 //# sourceMappingURL=mcp-server.js.map

package/dist/{lifecycle-BljLcnY5.js → lifecycle-wjO8lqUZ.js}

@@ -1,4 +1,4 @@
-//#region src/interactions/lifecycle.ts
+// src/interactions/lifecycle.ts
 /** Serialize one transport's single-use start and stop operations. */
 var SerializedTransportLifecycle = class {
 	state = "idle";
@@ -62,7 +62,6 @@ async function waitForSettled(promises, graceMs = 1e3) {
 		if (timer) clearTimeout(timer);
 	}
 }
-//#endregion
 export { closeHttpServer as n, waitForSettled as r, SerializedTransportLifecycle as t };
 
-//# sourceMappingURL=lifecycle-BljLcnY5.js.map
+//# sourceMappingURL=lifecycle-wjO8lqUZ.js.map

package/dist/{lifecycle-BljLcnY5.js.map → lifecycle-wjO8lqUZ.js.map}

@@ -1 +1 @@
-{"version":3,"file":"lifecycle-BljLcnY5.js","names":[],"sources":["../src/interactions/lifecycle.ts"],"sourcesContent":["type LifecycleState = \"idle\" | \"starting\" | \"running\" | \"stopping\" | \"stopped\";\n\n/** Serialize one transport's single-use start and stop operations. */\nexport class SerializedTransportLifecycle {\n  private state: LifecycleState = \"idle\";\n  private tail: Promise<void> = Promise.resolve();\n\n  start(open: () => Promise<void>): Promise<void> {\n    return this.enqueue(async () => {\n      if (this.state !== \"idle\") {\n        throw new Error(`Interaction transport cannot start while ${this.state}`);\n      }\n      this.state = \"starting\";\n      try {\n        await open();\n        this.state = \"running\";\n      } catch (error) {\n        this.state = \"stopped\";\n        throw error;\n      }\n    });\n  }\n\n  stop(close: () => Promise<void>): Promise<void> {\n    return this.enqueue(async () => {\n      if (this.state === \"idle\" || this.state === \"stopped\") return;\n      this.state = \"stopping\";\n      try {\n        await close();\n      } finally {\n        this.state = \"stopped\";\n      }\n    });\n  }\n\n  private enqueue(operation: () => Promise<void>): Promise<void> {\n    const result = this.tail.then(operation);\n    this.tail = result.catch(() => undefined);\n    return result;\n  }\n}\n\n/** Close active requests gracefully, then force-close a stuck local socket. */\nexport async function closeHttpServer(\n  server: import(\"node:http\").Server,\n  graceMs = 1_000,\n): Promise<void> {\n  await new Promise<void>((resolve) => {\n    let finished = false;\n    const finish = () => {\n      if (finished) return;\n      finished = true;\n      clearTimeout(forceClose);\n      resolve();\n    };\n    const forceClose = setTimeout(() => {\n      server.closeAllConnections?.();\n      finish();\n    }, graceMs);\n    server.close(finish);\n    server.closeIdleConnections?.();\n  });\n}\n\n/** Give active work a bounded grace period before transport shutdown. */\nexport async function waitForSettled(\n  promises: Iterable<Promise<unknown>>,\n  graceMs = 1_000,\n): Promise<void> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  try {\n    await Promise.race([\n      Promise.allSettled([...promises]),\n      new Promise<void>((resolve) => {\n        timer = setTimeout(resolve, graceMs);\n      }),\n    ]);\n  } finally {\n    if (timer) clearTimeout(timer);\n  }\n}\n"],"mappings":";;AAGA,IAAa,+BAAb,MAA0C;CACxC,QAAgC;CAChC,OAA8B,QAAQ,QAAQ;CAE9C,MAAM,MAA0C;EAC9C,OAAO,KAAK,QAAQ,YAAY;GAC9B,IAAI,KAAK,UAAU,QACjB,MAAM,IAAI,MAAM,4CAA4C,KAAK,OAAO;GAE1E,KAAK,QAAQ;GACb,IAAI;IACF,MAAM,KAAK;IACX,KAAK,QAAQ;GACf,SAAS,OAAO;IACd,KAAK,QAAQ;IACb,MAAM;GACR;EACF,CAAC;CACH;CAEA,KAAK,OAA2C;EAC9C,OAAO,KAAK,QAAQ,YAAY;GAC9B,IAAI,KAAK,UAAU,UAAU,KAAK,UAAU,WAAW;GACvD,KAAK,QAAQ;GACb,IAAI;IACF,MAAM,MAAM;GACd,UAAU;IACR,KAAK,QAAQ;GACf;EACF,CAAC;CACH;CAEA,QAAgB,WAA+C;EAC7D,MAAM,SAAS,KAAK,KAAK,KAAK,SAAS;EACvC,KAAK,OAAO,OAAO,YAAY,KAAA,CAAS;EACxC,OAAO;CACT;AACF;;AAGA,eAAsB,gBACpB,QACA,UAAU,KACK;CACf,MAAM,IAAI,SAAe,YAAY;EACnC,IAAI,WAAW;EACf,MAAM,eAAe;GACnB,IAAI,UAAU;GACd,WAAW;GACX,aAAa,UAAU;GACvB,QAAQ;EACV;EACA,MAAM,aAAa,iBAAiB;GAClC,OAAO,sBAAsB;GAC7B,OAAO;EACT,GAAG,OAAO;EACV,OAAO,MAAM,MAAM;EACnB,OAAO,uBAAuB;CAChC,CAAC;AACH;;AAGA,eAAsB,eACpB,UACA,UAAU,KACK;CACf,IAAI;CACJ,IAAI;EACF,MAAM,QAAQ,KAAK,CACjB,QAAQ,WAAW,CAAC,GAAG,QAAQ,CAAC,GAChC,IAAI,SAAe,YAAY;GAC7B,QAAQ,WAAW,SAAS,OAAO;EACrC,CAAC,CACH,CAAC;CACH,UAAU;EACR,IAAI,OAAO,aAAa,KAAK;CAC/B;AACF"}
+{"version":3,"file":"lifecycle-wjO8lqUZ.js","names":[],"sources":["../src/interactions/lifecycle.ts"],"sourcesContent":["type LifecycleState = \"idle\" | \"starting\" | \"running\" | \"stopping\" | \"stopped\";\n\n/** Serialize one transport's single-use start and stop operations. */\nexport class SerializedTransportLifecycle {\n  private state: LifecycleState = \"idle\";\n  private tail: Promise<void> = Promise.resolve();\n\n  start(open: () => Promise<void>): Promise<void> {\n    return this.enqueue(async () => {\n      if (this.state !== \"idle\") {\n        throw new Error(`Interaction transport cannot start while ${this.state}`);\n      }\n      this.state = \"starting\";\n      try {\n        await open();\n        this.state = \"running\";\n      } catch (error) {\n        this.state = \"stopped\";\n        throw error;\n      }\n    });\n  }\n\n  stop(close: () => Promise<void>): Promise<void> {\n    return this.enqueue(async () => {\n      if (this.state === \"idle\" || this.state === \"stopped\") return;\n      this.state = \"stopping\";\n      try {\n        await close();\n      } finally {\n        this.state = \"stopped\";\n      }\n    });\n  }\n\n  private enqueue(operation: () => Promise<void>): Promise<void> {\n    const result = this.tail.then(operation);\n    this.tail = result.catch(() => undefined);\n    return result;\n  }\n}\n\n/** Close active requests gracefully, then force-close a stuck local socket. */\nexport async function closeHttpServer(\n  server: import(\"node:http\").Server,\n  graceMs = 1_000,\n): Promise<void> {\n  await new Promise<void>((resolve) => {\n    let finished = false;\n    const finish = () => {\n      if (finished) return;\n      finished = true;\n      clearTimeout(forceClose);\n      resolve();\n    };\n    const forceClose = setTimeout(() => {\n      server.closeAllConnections?.();\n      finish();\n    }, graceMs);\n    server.close(finish);\n    server.closeIdleConnections?.();\n  });\n}\n\n/** Give active work a bounded grace period before transport shutdown. */\nexport async function waitForSettled(\n  promises: Iterable<Promise<unknown>>,\n  graceMs = 1_000,\n): Promise<void> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  try {\n    await Promise.race([\n      Promise.allSettled([...promises]),\n      new Promise<void>((resolve) => {\n        timer = setTimeout(resolve, graceMs);\n      }),\n    ]);\n  } finally {\n    if (timer) clearTimeout(timer);\n  }\n}\n"],"mappings":";;AAGA,IAAa,+BAAb,MAA0C;CACxC,QAAgC;CAChC,OAA8B,QAAQ,QAAQ;CAE9C,MAAM,MAA0C;EAC9C,OAAO,KAAK,QAAQ,YAAY;GAC9B,IAAI,KAAK,UAAU,QACjB,MAAM,IAAI,MAAM,4CAA4C,KAAK,OAAO;GAE1E,KAAK,QAAQ;GACb,IAAI;IACF,MAAM,KAAK;IACX,KAAK,QAAQ;GACf,SAAS,OAAO;IACd,KAAK,QAAQ;IACb,MAAM;GACR;EACF,CAAC;CACH;CAEA,KAAK,OAA2C;EAC9C,OAAO,KAAK,QAAQ,YAAY;GAC9B,IAAI,KAAK,UAAU,UAAU,KAAK,UAAU,WAAW;GACvD,KAAK,QAAQ;GACb,IAAI;IACF,MAAM,MAAM;GACd,UAAU;IACR,KAAK,QAAQ;GACf;EACF,CAAC;CACH;CAEA,QAAgB,WAA+C;EAC7D,MAAM,SAAS,KAAK,KAAK,KAAK,SAAS;EACvC,KAAK,OAAO,OAAO,YAAY,KAAA,CAAS;EACxC,OAAO;CACT;AACF;;AAGA,eAAsB,gBACpB,QACA,UAAU,KACK;CACf,MAAM,IAAI,SAAe,YAAY;EACnC,IAAI,WAAW;EACf,MAAM,eAAe;GACnB,IAAI,UAAU;GACd,WAAW;GACX,aAAa,UAAU;GACvB,QAAQ;EACV;EACA,MAAM,aAAa,iBAAiB;GAClC,OAAO,sBAAsB;GAC7B,OAAO;EACT,GAAG,OAAO;EACV,OAAO,MAAM,MAAM;EACnB,OAAO,uBAAuB;CAChC,CAAC;AACH;;AAGA,eAAsB,eACpB,UACA,UAAU,KACK;CACf,IAAI;CACJ,IAAI;EACF,MAAM,QAAQ,KAAK,CACjB,QAAQ,WAAW,CAAC,GAAG,QAAQ,CAAC,GAChC,IAAI,SAAe,YAAY;GAC7B,QAAQ,WAAW,SAAS,OAAO;EACrC,CAAC,CACH,CAAC;CACH,UAAU;EACR,IAAI,OAAO,aAAa,KAAK;CAC/B;AACF"}

package/dist/node/index.d.ts

@@ -1,7 +1,5 @@
-//#region src/node/index.d.ts
 /** Lowercase hex SHA-256 of a string or bytes. */
 export declare function sha256Hex(value: string | Uint8Array): string;
 /** Quote one argument for a POSIX shell: single quotes, embedded `'` as `'\''`. */
 export declare function shellQuote(value: string): string;
-//#endregion
 //# sourceMappingURL=index.d.ts.map

package/dist/node/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/node/index.ts"],"mappings":";;wBAOgB,UAAU,gBAAgB;;wBAK1B,WAAW"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/node/index.ts"],"mappings":";wBAOgB,UAAU,gBAAgB;;wBAK1B,WAAW"}

package/dist/node/index.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-//#region src/node/index.ts
+// src/node/index.ts
 /**
 * Node-only primitives. Kept off the root entry so browser bundles of
 * `@tangle-network/agent-core` never pull in `node:crypto`.
@@ -12,7 +12,6 @@ function sha256Hex(value) {
 function shellQuote(value) {
 	return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-//#endregion
 export { sha256Hex, shellQuote };
 
 //# sourceMappingURL=index.js.map

package/dist/resilience/index.d.ts

@@ -1,2 +1,2 @@
-import { a as ProtectionOptions, c as CircuitBreaker, d as CircuitOpenError, f as CircuitState, i as withTimeout, l as CircuitBreakerConfig, n as createTimeoutController, o as createProtectedFn, r as sleep, s as withProtection, t as TimeoutError, u as CircuitBreakerStats } from "../index-CKDeaS7l.js";
+import { a as ProtectionOptions, c as CircuitBreaker, d as CircuitOpenError, f as CircuitState, i as withTimeout, l as CircuitBreakerConfig, n as createTimeoutController, o as createProtectedFn, r as sleep, s as withProtection, t as TimeoutError, u as CircuitBreakerStats } from "../index-DWPciD1S.js";
 export { CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerStats, CircuitOpenError, type CircuitState, type ProtectionOptions, TimeoutError, createProtectedFn, createTimeoutController, sleep, withProtection, withTimeout };

package/dist/resilience/index.js

@@ -1,2 +1 @@
-import { a as sleep, c as CircuitOpenError, i as createTimeoutController, n as withProtection, o as withTimeout, r as TimeoutError, s as CircuitBreaker, t as createProtectedFn } from "../resilience-Cv5tqIDU.js";
-export { CircuitBreaker, CircuitOpenError, TimeoutError, createProtectedFn, createTimeoutController, sleep, withProtection, withTimeout };
+export { s as CircuitBreaker, c as CircuitOpenError, r as TimeoutError, t as createProtectedFn, i as createTimeoutController, a as sleep, n as withProtection, o as withTimeout } from "../resilience-Bb1XDoKt.js";

package/dist/{resilience-Cv5tqIDU.js → resilience-Bb1XDoKt.js}

@@ -1,5 +1,5 @@
-import { t as SDKError } from "./errors-GuWACHTg.js";
-//#region src/resilience/circuit-breaker.ts
+import { t as SDKError } from "./errors-B5KiSXnw.js";
+// src/resilience/circuit-breaker.ts
 /**
 * Circuit Breaker
 *
@@ -122,8 +122,7 @@ var CircuitBreaker = class {
 		this.lastFailureTime = Date.now();
 	}
 };
-//#endregion
-//#region src/resilience/timeout.ts
+// src/resilience/timeout.ts
 /**
 * Timeout Utilities
 *
@@ -216,8 +215,7 @@ function armTimeout(ms, callback) {
 		if (timer !== void 0) clearTimeout(timer);
 	};
 }
-//#endregion
-//#region src/resilience/protection.ts
+// src/resilience/protection.ts
 /**
 * Execute a function with timeout and circuit breaker protection.
 *
@@ -242,7 +240,6 @@ async function withProtection(fn, options = {}) {
 function createProtectedFn(fn, options) {
 	return (...args) => withProtection(() => fn(...args), options);
 }
-//#endregion
 export { sleep as a, CircuitOpenError as c, createTimeoutController as i, withProtection as n, withTimeout as o, TimeoutError as r, CircuitBreaker as s, createProtectedFn as t };
 
-//# sourceMappingURL=resilience-Cv5tqIDU.js.map
+//# sourceMappingURL=resilience-Bb1XDoKt.js.map

package/dist/{resilience-Cv5tqIDU.js.map → resilience-Bb1XDoKt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"resilience-Cv5tqIDU.js","names":[],"sources":["../src/resilience/circuit-breaker.ts","../src/resilience/timeout.ts","../src/resilience/protection.ts"],"sourcesContent":["/**\n * Circuit Breaker\n *\n * Implements the circuit breaker pattern for fail-fast behavior when\n * downstream services are unhealthy. Prevents cascade failures by\n * stopping requests to failing services.\n *\n * States:\n * - CLOSED: Normal operation, requests pass through\n * - OPEN: Service unhealthy, requests fail immediately\n * - HALF_OPEN: Testing if service recovered\n */\n\nimport { SDKError } from \"../errors/index.js\";\n\nexport type CircuitState = \"closed\" | \"open\" | \"half-open\";\n\nexport interface CircuitBreakerConfig {\n  /** Number of failures before opening circuit */\n  failureThreshold: number;\n  /** Time in ms to wait before testing recovery (half-open) */\n  resetTimeoutMs: number;\n  /** Number of successes in half-open state to close circuit */\n  successThreshold: number;\n  /** Optional: Only count these error types as failures */\n  failureFilter?: (error: unknown) => boolean;\n}\n\nexport interface CircuitBreakerStats {\n  state: CircuitState;\n  failures: number;\n  successes: number;\n  lastFailureTime: number | null;\n  totalFailures: number;\n  totalSuccesses: number;\n  totalRejected: number;\n}\n\nexport class CircuitOpenError extends SDKError {\n  readonly circuitName: string;\n  readonly resetAfterMs: number;\n\n  constructor(name: string, resetAfterMs: number) {\n    super(`Circuit breaker '${name}' is open`, {\n      code: \"SERVER\",\n      retryable: true,\n      retryAfterMs: resetAfterMs,\n      context: { circuitName: name },\n    });\n    this.name = \"CircuitOpenError\";\n    this.circuitName = name;\n    this.resetAfterMs = resetAfterMs;\n  }\n}\n\nexport class CircuitBreaker {\n  private state: CircuitState = \"closed\";\n  private failures = 0;\n  private successes = 0;\n  private lastFailureTime: number | null = null;\n\n  // Lifetime stats\n  private totalFailures = 0;\n  private totalSuccesses = 0;\n  private totalRejected = 0;\n\n  constructor(\n    private readonly name: string,\n    private readonly config: CircuitBreakerConfig,\n  ) {\n    if (config.failureThreshold < 1) {\n      throw new Error(\"failureThreshold must be >= 1\");\n    }\n    if (config.resetTimeoutMs < 0) {\n      throw new Error(\"resetTimeoutMs must be >= 0\");\n    }\n    if (config.successThreshold < 1) {\n      throw new Error(\"successThreshold must be >= 1\");\n    }\n  }\n\n  /**\n   * Execute a function through the circuit breaker.\n   * Throws CircuitOpenError if circuit is open.\n   */\n  async execute<T>(fn: () => Promise<T>): Promise<T> {\n    // Check if we should transition from open to half-open\n    if (this.state === \"open\") {\n      const timeSinceFailure = this.lastFailureTime\n        ? Date.now() - this.lastFailureTime\n        : Number.POSITIVE_INFINITY;\n\n      if (timeSinceFailure >= this.config.resetTimeoutMs) {\n        this.state = \"half-open\";\n        this.successes = 0;\n      } else {\n        this.totalRejected++;\n        throw new CircuitOpenError(\n          this.name,\n          this.config.resetTimeoutMs - timeSinceFailure,\n        );\n      }\n    }\n\n    try {\n      const result = await fn();\n      this.onSuccess();\n      return result;\n    } catch (error) {\n      this.onFailure(error);\n      throw error;\n    }\n  }\n\n  private onSuccess(): void {\n    this.totalSuccesses++;\n\n    if (this.state === \"half-open\") {\n      this.successes++;\n      if (this.successes >= this.config.successThreshold) {\n        // Service recovered, close circuit\n        this.state = \"closed\";\n        this.failures = 0;\n        this.successes = 0;\n      }\n    } else if (this.state === \"closed\") {\n      // Reset failure count on success\n      this.failures = 0;\n    }\n  }\n\n  private onFailure(error: unknown): void {\n    // Check if this error should count as a failure\n    if (this.config.failureFilter && !this.config.failureFilter(error)) {\n      return;\n    }\n\n    this.totalFailures++;\n    this.failures++;\n    this.lastFailureTime = Date.now();\n    this.successes = 0;\n\n    if (this.state === \"half-open\") {\n      // Any failure in half-open returns to open\n      this.state = \"open\";\n    } else if (\n      this.state === \"closed\" &&\n      this.failures >= this.config.failureThreshold\n    ) {\n      // Threshold exceeded, open circuit\n      this.state = \"open\";\n    }\n  }\n\n  /** Get current circuit state */\n  getState(): CircuitState {\n    return this.state;\n  }\n\n  /** Get circuit statistics */\n  getStats(): CircuitBreakerStats {\n    return {\n      state: this.state,\n      failures: this.failures,\n      successes: this.successes,\n      lastFailureTime: this.lastFailureTime,\n      totalFailures: this.totalFailures,\n      totalSuccesses: this.totalSuccesses,\n      totalRejected: this.totalRejected,\n    };\n  }\n\n  /** Check if circuit is allowing requests */\n  isAllowingRequests(): boolean {\n    if (this.state === \"closed\" || this.state === \"half-open\") {\n      return true;\n    }\n\n    // Check if reset timeout has passed\n    const timeSinceFailure = this.lastFailureTime\n      ? Date.now() - this.lastFailureTime\n      : Number.POSITIVE_INFINITY;\n\n    return timeSinceFailure >= this.config.resetTimeoutMs;\n  }\n\n  /** Manually reset the circuit to closed state */\n  reset(): void {\n    this.state = \"closed\";\n    this.failures = 0;\n    this.successes = 0;\n    this.lastFailureTime = null;\n  }\n\n  /** Manually open the circuit */\n  open(): void {\n    this.state = \"open\";\n    this.lastFailureTime = Date.now();\n  }\n}\n","/**\n * Timeout Utilities\n *\n * Promise-based timeout handling with proper cleanup.\n */\n\nimport { SDKError } from \"../errors/index.js\";\n\nexport class TimeoutError extends SDKError {\n  readonly timeoutMs: number;\n\n  constructor(message: string, timeoutMs: number) {\n    super(message, {\n      code: \"TIMEOUT\",\n      retryable: true,\n      context: { timeoutMs },\n    });\n    this.name = \"TimeoutError\";\n    this.timeoutMs = timeoutMs;\n  }\n}\n\n/**\n * Wrap a promise with a timeout.\n * Rejects with TimeoutError if the promise doesn't resolve in time.\n */\nexport function withTimeout<T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  message?: string,\n): Promise<T> {\n  if (timeoutMs <= 0) {\n    return promise;\n  }\n\n  let clearTimer: (() => void) | undefined;\n\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    clearTimer = armTimeout(timeoutMs, () => {\n      reject(\n        new TimeoutError(\n          message || `Operation timed out after ${timeoutMs}ms`,\n          timeoutMs,\n        ),\n      );\n    });\n  });\n\n  return Promise.race([promise, timeoutPromise]).finally(() => {\n    clearTimer?.();\n  });\n}\n\n/**\n * Create an AbortController that auto-aborts after a timeout.\n * Returns the controller and a cleanup function.\n */\nexport function createTimeoutController(timeoutMs: number): {\n  controller: AbortController;\n  cleanup: () => void;\n} {\n  const controller = new AbortController();\n  let clearTimer: (() => void) | undefined;\n\n  if (timeoutMs > 0) {\n    clearTimer = armTimeout(timeoutMs, () => {\n      controller.abort(new TimeoutError(\"Request timeout\", timeoutMs));\n    });\n  }\n\n  return {\n    controller,\n    cleanup: () => {\n      clearTimer?.();\n    },\n  };\n}\n\n/**\n * Sleep for a specified duration.\n * Optionally accepts an AbortSignal for cancellation.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(signal.reason);\n      return;\n    }\n    const onAbort = () => {\n      clearTimer();\n      signal?.removeEventListener(\"abort\", onAbort);\n      reject(signal?.reason);\n    };\n    const clearTimer = armTimeout(ms, () => {\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve();\n    });\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n\n/** Keep one absolute deadline; native timers overflow to 1ms beyond this chunk size. */\nfunction armTimeout(ms: number, callback: () => void): () => void {\n  const deadline = Date.now() + Math.max(0, ms);\n  if (!Number.isFinite(ms) || !Number.isSafeInteger(Math.ceil(deadline))) {\n    throw new SDKError(\"Timeout must produce a finite safe deadline\", { code: \"VALIDATION\" });\n  }\n  let cleared = false;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const arm = () => {\n    if (cleared) return;\n    timer = setTimeout(() => {\n      if (cleared) return;\n      if (Date.now() >= deadline) callback();\n      else arm();\n    }, Math.min(2_147_483_647, Math.max(0, deadline - Date.now())));\n  };\n  arm();\n  return () => {\n    cleared = true;\n    if (timer !== undefined) clearTimeout(timer);\n  };\n}\n","/**\n * Combines timeout + circuit breaker into a single request guard.\n */\n\nimport type { CircuitBreaker } from \"./circuit-breaker.js\";\nimport { withTimeout } from \"./timeout.js\";\n\nexport interface ProtectionOptions {\n  /** Timeout in milliseconds (0 or undefined = no timeout) */\n  timeoutMs?: number;\n  /** Circuit breaker instance (optional) */\n  breaker?: CircuitBreaker;\n  /** Operation name for error messages */\n  operationName?: string;\n}\n\n/**\n * Execute a function with timeout and circuit breaker protection.\n *\n * Order of execution:\n * 1. Circuit breaker check (fail fast if open)\n * 2. Timeout wrapper\n * 3. Execute function\n * 4. Update circuit breaker state\n */\nexport async function withProtection<T>(\n  fn: () => Promise<T>,\n  options: ProtectionOptions = {},\n): Promise<T> {\n  const { timeoutMs, breaker, operationName = \"operation\" } = options;\n\n  const execute = async (): Promise<T> => {\n    if (timeoutMs && timeoutMs > 0) {\n      return withTimeout(fn(), timeoutMs, `${operationName} timed out`);\n    }\n    return fn();\n  };\n\n  if (breaker) {\n    return breaker.execute(execute);\n  }\n\n  return execute();\n}\n\n/**\n * Create a protected function that always applies the same protection options.\n */\nexport function createProtectedFn<TArgs extends unknown[], TResult>(\n  fn: (...args: TArgs) => Promise<TResult>,\n  options: ProtectionOptions,\n): (...args: TArgs) => Promise<TResult> {\n  return (...args: TArgs) => withProtection(() => fn(...args), options);\n}\n"],"mappings":"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"}
+{"version":3,"file":"resilience-Bb1XDoKt.js","names":[],"sources":["../src/resilience/circuit-breaker.ts","../src/resilience/timeout.ts","../src/resilience/protection.ts"],"sourcesContent":["/**\n * Circuit Breaker\n *\n * Implements the circuit breaker pattern for fail-fast behavior when\n * downstream services are unhealthy. Prevents cascade failures by\n * stopping requests to failing services.\n *\n * States:\n * - CLOSED: Normal operation, requests pass through\n * - OPEN: Service unhealthy, requests fail immediately\n * - HALF_OPEN: Testing if service recovered\n */\n\nimport { SDKError } from \"../errors/index.js\";\n\nexport type CircuitState = \"closed\" | \"open\" | \"half-open\";\n\nexport interface CircuitBreakerConfig {\n  /** Number of failures before opening circuit */\n  failureThreshold: number;\n  /** Time in ms to wait before testing recovery (half-open) */\n  resetTimeoutMs: number;\n  /** Number of successes in half-open state to close circuit */\n  successThreshold: number;\n  /** Optional: Only count these error types as failures */\n  failureFilter?: (error: unknown) => boolean;\n}\n\nexport interface CircuitBreakerStats {\n  state: CircuitState;\n  failures: number;\n  successes: number;\n  lastFailureTime: number | null;\n  totalFailures: number;\n  totalSuccesses: number;\n  totalRejected: number;\n}\n\nexport class CircuitOpenError extends SDKError {\n  readonly circuitName: string;\n  readonly resetAfterMs: number;\n\n  constructor(name: string, resetAfterMs: number) {\n    super(`Circuit breaker '${name}' is open`, {\n      code: \"SERVER\",\n      retryable: true,\n      retryAfterMs: resetAfterMs,\n      context: { circuitName: name },\n    });\n    this.name = \"CircuitOpenError\";\n    this.circuitName = name;\n    this.resetAfterMs = resetAfterMs;\n  }\n}\n\nexport class CircuitBreaker {\n  private state: CircuitState = \"closed\";\n  private failures = 0;\n  private successes = 0;\n  private lastFailureTime: number | null = null;\n\n  // Lifetime stats\n  private totalFailures = 0;\n  private totalSuccesses = 0;\n  private totalRejected = 0;\n\n  constructor(\n    private readonly name: string,\n    private readonly config: CircuitBreakerConfig,\n  ) {\n    if (config.failureThreshold < 1) {\n      throw new Error(\"failureThreshold must be >= 1\");\n    }\n    if (config.resetTimeoutMs < 0) {\n      throw new Error(\"resetTimeoutMs must be >= 0\");\n    }\n    if (config.successThreshold < 1) {\n      throw new Error(\"successThreshold must be >= 1\");\n    }\n  }\n\n  /**\n   * Execute a function through the circuit breaker.\n   * Throws CircuitOpenError if circuit is open.\n   */\n  async execute<T>(fn: () => Promise<T>): Promise<T> {\n    // Check if we should transition from open to half-open\n    if (this.state === \"open\") {\n      const timeSinceFailure = this.lastFailureTime\n        ? Date.now() - this.lastFailureTime\n        : Number.POSITIVE_INFINITY;\n\n      if (timeSinceFailure >= this.config.resetTimeoutMs) {\n        this.state = \"half-open\";\n        this.successes = 0;\n      } else {\n        this.totalRejected++;\n        throw new CircuitOpenError(\n          this.name,\n          this.config.resetTimeoutMs - timeSinceFailure,\n        );\n      }\n    }\n\n    try {\n      const result = await fn();\n      this.onSuccess();\n      return result;\n    } catch (error) {\n      this.onFailure(error);\n      throw error;\n    }\n  }\n\n  private onSuccess(): void {\n    this.totalSuccesses++;\n\n    if (this.state === \"half-open\") {\n      this.successes++;\n      if (this.successes >= this.config.successThreshold) {\n        // Service recovered, close circuit\n        this.state = \"closed\";\n        this.failures = 0;\n        this.successes = 0;\n      }\n    } else if (this.state === \"closed\") {\n      // Reset failure count on success\n      this.failures = 0;\n    }\n  }\n\n  private onFailure(error: unknown): void {\n    // Check if this error should count as a failure\n    if (this.config.failureFilter && !this.config.failureFilter(error)) {\n      return;\n    }\n\n    this.totalFailures++;\n    this.failures++;\n    this.lastFailureTime = Date.now();\n    this.successes = 0;\n\n    if (this.state === \"half-open\") {\n      // Any failure in half-open returns to open\n      this.state = \"open\";\n    } else if (\n      this.state === \"closed\" &&\n      this.failures >= this.config.failureThreshold\n    ) {\n      // Threshold exceeded, open circuit\n      this.state = \"open\";\n    }\n  }\n\n  /** Get current circuit state */\n  getState(): CircuitState {\n    return this.state;\n  }\n\n  /** Get circuit statistics */\n  getStats(): CircuitBreakerStats {\n    return {\n      state: this.state,\n      failures: this.failures,\n      successes: this.successes,\n      lastFailureTime: this.lastFailureTime,\n      totalFailures: this.totalFailures,\n      totalSuccesses: this.totalSuccesses,\n      totalRejected: this.totalRejected,\n    };\n  }\n\n  /** Check if circuit is allowing requests */\n  isAllowingRequests(): boolean {\n    if (this.state === \"closed\" || this.state === \"half-open\") {\n      return true;\n    }\n\n    // Check if reset timeout has passed\n    const timeSinceFailure = this.lastFailureTime\n      ? Date.now() - this.lastFailureTime\n      : Number.POSITIVE_INFINITY;\n\n    return timeSinceFailure >= this.config.resetTimeoutMs;\n  }\n\n  /** Manually reset the circuit to closed state */\n  reset(): void {\n    this.state = \"closed\";\n    this.failures = 0;\n    this.successes = 0;\n    this.lastFailureTime = null;\n  }\n\n  /** Manually open the circuit */\n  open(): void {\n    this.state = \"open\";\n    this.lastFailureTime = Date.now();\n  }\n}\n","/**\n * Timeout Utilities\n *\n * Promise-based timeout handling with proper cleanup.\n */\n\nimport { SDKError } from \"../errors/index.js\";\n\nexport class TimeoutError extends SDKError {\n  readonly timeoutMs: number;\n\n  constructor(message: string, timeoutMs: number) {\n    super(message, {\n      code: \"TIMEOUT\",\n      retryable: true,\n      context: { timeoutMs },\n    });\n    this.name = \"TimeoutError\";\n    this.timeoutMs = timeoutMs;\n  }\n}\n\n/**\n * Wrap a promise with a timeout.\n * Rejects with TimeoutError if the promise doesn't resolve in time.\n */\nexport function withTimeout<T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  message?: string,\n): Promise<T> {\n  if (timeoutMs <= 0) {\n    return promise;\n  }\n\n  let clearTimer: (() => void) | undefined;\n\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    clearTimer = armTimeout(timeoutMs, () => {\n      reject(\n        new TimeoutError(\n          message || `Operation timed out after ${timeoutMs}ms`,\n          timeoutMs,\n        ),\n      );\n    });\n  });\n\n  return Promise.race([promise, timeoutPromise]).finally(() => {\n    clearTimer?.();\n  });\n}\n\n/**\n * Create an AbortController that auto-aborts after a timeout.\n * Returns the controller and a cleanup function.\n */\nexport function createTimeoutController(timeoutMs: number): {\n  controller: AbortController;\n  cleanup: () => void;\n} {\n  const controller = new AbortController();\n  let clearTimer: (() => void) | undefined;\n\n  if (timeoutMs > 0) {\n    clearTimer = armTimeout(timeoutMs, () => {\n      controller.abort(new TimeoutError(\"Request timeout\", timeoutMs));\n    });\n  }\n\n  return {\n    controller,\n    cleanup: () => {\n      clearTimer?.();\n    },\n  };\n}\n\n/**\n * Sleep for a specified duration.\n * Optionally accepts an AbortSignal for cancellation.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(signal.reason);\n      return;\n    }\n    const onAbort = () => {\n      clearTimer();\n      signal?.removeEventListener(\"abort\", onAbort);\n      reject(signal?.reason);\n    };\n    const clearTimer = armTimeout(ms, () => {\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve();\n    });\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n\n/** Keep one absolute deadline; native timers overflow to 1ms beyond this chunk size. */\nfunction armTimeout(ms: number, callback: () => void): () => void {\n  const deadline = Date.now() + Math.max(0, ms);\n  if (!Number.isFinite(ms) || !Number.isSafeInteger(Math.ceil(deadline))) {\n    throw new SDKError(\"Timeout must produce a finite safe deadline\", { code: \"VALIDATION\" });\n  }\n  let cleared = false;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const arm = () => {\n    if (cleared) return;\n    timer = setTimeout(() => {\n      if (cleared) return;\n      if (Date.now() >= deadline) callback();\n      else arm();\n    }, Math.min(2_147_483_647, Math.max(0, deadline - Date.now())));\n  };\n  arm();\n  return () => {\n    cleared = true;\n    if (timer !== undefined) clearTimeout(timer);\n  };\n}\n","/**\n * Combines timeout + circuit breaker into a single request guard.\n */\n\nimport type { CircuitBreaker } from \"./circuit-breaker.js\";\nimport { withTimeout } from \"./timeout.js\";\n\nexport interface ProtectionOptions {\n  /** Timeout in milliseconds (0 or undefined = no timeout) */\n  timeoutMs?: number;\n  /** Circuit breaker instance (optional) */\n  breaker?: CircuitBreaker;\n  /** Operation name for error messages */\n  operationName?: string;\n}\n\n/**\n * Execute a function with timeout and circuit breaker protection.\n *\n * Order of execution:\n * 1. Circuit breaker check (fail fast if open)\n * 2. Timeout wrapper\n * 3. Execute function\n * 4. Update circuit breaker state\n */\nexport async function withProtection<T>(\n  fn: () => Promise<T>,\n  options: ProtectionOptions = {},\n): Promise<T> {\n  const { timeoutMs, breaker, operationName = \"operation\" } = options;\n\n  const execute = async (): Promise<T> => {\n    if (timeoutMs && timeoutMs > 0) {\n      return withTimeout(fn(), timeoutMs, `${operationName} timed out`);\n    }\n    return fn();\n  };\n\n  if (breaker) {\n    return breaker.execute(execute);\n  }\n\n  return execute();\n}\n\n/**\n * Create a protected function that always applies the same protection options.\n */\nexport function createProtectedFn<TArgs extends unknown[], TResult>(\n  fn: (...args: TArgs) => Promise<TResult>,\n  options: ProtectionOptions,\n): (...args: TArgs) => Promise<TResult> {\n  return (...args: TArgs) => withProtection(() => fn(...args), options);\n}\n"],"mappings":"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"}

package/dist/sse/index.d.ts

@@ -1,9 +1,29 @@
-//#region src/sse/index.d.ts
 /**
  * SSE Utilities
  *
- * Shared SSE parsing and stream usage extraction for the SDK.
- * Used by sdk-telemetry, sdk-memory, and other consumers.
+ * The one Server-Sent Events wire-format implementation: frame parsing and
+ * framing, plus the JSON event layer and stream usage extraction built on it.
+ * Everything here is pure ECMAScript over `ReadableStream`/`TextDecoder`
+ * globals and imports nothing, so Node, browser and Cloudflare Worker bundles
+ * can take this subpath without pulling a dependency.
+ *
+ * Frame parser guarantees (WHATWG Server-Sent Events, §9.2 "Interpreting an
+ * event stream"):
+ *   - Buffers frames that straddle chunk boundaries; `push()` emits only
+ *     complete frames and `flush()` dispatches a trailing frame whose
+ *     terminating blank line never arrived.
+ *   - Accepts LF and CRLF line terminators interchangeably. Bare CR is
+ *     intentionally not treated as a terminator: no known emitter uses
+ *     it, and supporting it would risk splitting payloads that
+ *     legitimately contain CR.
+ *   - Joins multi-line `data:` fields with "\n" (§9.2.6 step 3).
+ *   - Skips comment lines (a leading ":") — the heartbeat mechanism.
+ *   - Ignores `retry:` and unrecognized fields.
+ *   - Strips one leading U+FEFF (BOM) from the stream.
+ *   - Applies the `event:`/`id:` state of a frame only to that frame.
+ *
+ * The frame layer does no JSON parsing, reconnect/`Last-Event-ID` tracking or
+ * event-type filtering; `SSEChunkParser` adds JSON payload handling on top.
  */
 /** Raw SSE event data from stream */
 export interface SSEEventData {
@@ -46,6 +66,99 @@ export interface SSEEventData {
  * ```
  */
 export declare function parseSSEData(rawData: string): SSEEventData | null;
+/**
+ * One parsed SSE frame: the fields accumulated between blank lines.
+ *
+ * `event` and `id` share no memory with the chunk the frame arrived in, so a
+ * consumer can keep them as long as it keeps its events. `data` can share
+ * that memory: parse it, and keep what the parse returns.
+ */
+export interface SSEFrame {
+  /** Value of the `event:` field; "" when the frame carries none. */
+  event: string;
+  /** `data:` field lines joined with "\n". */
+  data: string;
+  /** Value of the `id:` field; undefined when the frame carries none. */
+  id?: string;
+}
+/** Options for {@link streamSSEFrames}. */
+export interface SSEStreamOptions {
+  /**
+   * Aborts the read loop. When the signal fires, the generator throws a
+   * `DOMException` named "AbortError" so consumers can distinguish a
+   * cancellation from a clean end-of-stream without inspecting signal
+   * state.
+   */
+  signal?: AbortSignal;
+  /**
+   * The longest silence the stream may keep, read before each chunk read.
+   * Any bytes reset it, comment heartbeats included, because a heartbeat is
+   * the producer saying the connection is still live. A read that outlasts it
+   * throws {@link SSEStreamSilentError}. `undefined` waits without bound, which
+   * suits a producer that promises no heartbeat.
+   */
+  idleMs?: () => number | undefined;
+}
+/**
+ * Thrown when a stream sends no bytes for longer than its `idleMs`. A
+ * producer that heartbeats would have written in that time, so the
+ * connection is dead even though it never closed: a half-open TCP connection
+ * or a stalled proxy hold the socket open while nothing arrives.
+ */
+export declare class SSEStreamSilentError extends Error {
+  readonly name = "SSEStreamSilentError";
+  readonly idleMs: number;
+  constructor(idleMs: number);
+}
+/**
+ * Incremental SSE frame parser. Feed decoded text via `push()`; call
+ * `flush()` when the stream ends.
+ */
+export declare class SSEFrameParser {
+  private buffer;
+  private frameEvent;
+  private frameId;
+  private frameDataLines;
+  private bomChecked;
+  /**
+   * Append a decoded text chunk and return every frame the chunk
+   * completes. Frame state survives across calls: one frame can
+   * straddle any number of chunks.
+   */
+  push(chunk: string): SSEFrame[];
+  /**
+   * End-of-stream: process the unterminated trailing line, then
+   * dispatch a dangling frame that never got its blank line.
+   * Well-behaved servers end frames with "\n\n", but some close early.
+   */
+  flush(): SSEFrame[];
+  private processLines;
+  /**
+   * Dispatch the accumulated frame. A frame with no `data:` field (an
+   * `event:`/`id:`-only frame, or a bare comment) produces nothing, and
+   * its field state is consumed and reset either way.
+   */
+  private dispatch;
+}
+/**
+ * Serialize one frame to its wire form. Multi-line `data` becomes one
+ * `data:` line per source line so the payload survives the trip without
+ * premature frame dispatch.
+ */
+export declare function encodeSSEFrame(frame: {
+  data: string;
+  event?: string;
+  id?: string;
+}): string;
+/**
+ * Read a streaming SSE response body into parsed frames.
+ *
+ * @throws `TypeError` when the body is missing.
+ * @throws `DOMException` with `name === "AbortError"` on cancellation —
+ *   including the WHATWG-fetch variant where an aborted body resolves
+ *   `done: true` instead of rejecting the read.
+ */
+export declare function streamSSEFrames(body: ReadableStream<Uint8Array> | null | undefined, options?: SSEStreamOptions): AsyncGenerator<SSEFrame>;
 export interface SSEParserOptions<T = unknown> {
   /** Log malformed data lines (default: false) */
   logMalformed?: boolean;
@@ -59,18 +172,18 @@ export interface ParsedSSEEvent<T = unknown> {
   eventType?: string;
 }
 /**
- * Incremental SSE parser for chunked streams.
- * Feed decoded string chunks via push(); call flush() on stream end.
+ * Incremental JSON event parser for chunked streams, framed by
+ * {@link SSEFrameParser}. Feed decoded string chunks via push(); call flush()
+ * on stream end. Frames whose trimmed data is empty produce no event.
  */
 export declare class SSEChunkParser<T = unknown> {
-  private buffer;
-  private currentEvent;
-  private options;
+  private readonly frames;
+  private readonly options;
   constructor(options?: SSEParserOptions<T>);
   push(chunk: string): ParsedSSEEvent<T>[];
   flush(): ParsedSSEEvent<T>[];
-  private processLines;
-  private parseCurrentEvent;
+  private toEvents;
+  private toEvent;
 }
 /**
  * Parse SSE stream into typed events via async iteration.
@@ -169,5 +282,4 @@ export declare function createUsageCallback<T extends Record<string, unknown>>(f
   getUsage: () => StreamUsageAccumulator;
   extractor: StreamUsageExtractor;
 };
-//#endregion
 //# sourceMappingURL=index.d.ts.map

package/dist/sse/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/sse/index.ts"],"mappings":";;;;;;;;iBAQiB;EACf;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EAEA;EAEA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EAEA;IACE;IACA;IACA;IACA;;GAGD;;;;;;;;;;;wBAYa,aAAa,kBAAkB;iBA+B9B,iBAAiB;;EAEhC;;EAEA,aAAa,gBAAgB;;iBAGd,eAAe;EAC9B,MAAM;EACN;EACA;EACA;;;;;;qBAOW,eAAe;UAClB;UACA;UACA;EAER,YAAY,UAAS,iBAAiB;EAItC,KAAK,gBAAgB,eAAe;EAOpC,SAAS,eAAe;UAYhB;UA4CA;;;;;wBA2Ca,eAAe,aACpC,QAAQ,eAAe,aACvB,UAAS,iBAAiB,KACzB,eAAe,eAAe;;;;wBA4CX,iBAAiB,aACrC,QAAQ,eAAe,aACvB,UAAU,OAAO,eAAe,aAChC,UAAU,OAAO,gBACjB,UAAS,iBAAiB,KACzB;;iBAuCc;EACf;EACA;EACA;EACA;;;iBAIe;;EAEf,OAAO;;EAEP;;EAEA;;EAEA;;EAEA,WAAW;;EAEX;;;;;;;;;;;;;;;;;;;qBA0BW;UACH;UACA;EAER;;;;EAeA,cAAc;;;;EAUd,aAAa,OAAO,eAAe;;;;;EAoDnC,YAAY;;;;EAeZ,WAAW,SAAS;;;;EAOpB;UAaQ;UAyCA;;;;;wBA4BM,8BAA8B;;;;;;;;;;;;;;wBAiB9B,oBAAoB,UAAU,yBAC5C,WAAW,OAAO;EAElB,WAAW,OAAO;EAClB,gBAAgB;EAChB,WAAW"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/sse/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BiB;EACf;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAEA;EACA;EACA;EAEA;EAEA;EACA;EAEA;EACA;EACA;EACA;EACA;EACA;EAEA;IACE;IACA;IACA;IACA;;GAGD;;;;;;;;;;;wBAYa,aAAa,kBAAkB;;;;;;;;iBAsC9B;;EAEf;;EAEA;;EAEA;;;iBAee;;;;;;;EAOf,SAAS;;;;;;;;EAQT;;;;;;;;qBASW,6BAA6B;WACtB;WACT;EACG,YAAA;;;;;;qBAUD;UACH;UACA;UACA;UACA;UACA;;;;;;EAOR,KAAK,gBAAgB;;;;;;EAqBrB,SAAS;UASD;;;;;;UAoCA;;;;;;;wBAqBM,eAAe;EAC7B;EACA;EACA;;;;;;;;;;wBAiBqB,gBACrB,MAAM,eAAe,gCACrB,UAAU,mBACT,eAAe;iBA4DD,iBAAiB;;EAEhC;;EAEA,aAAa,gBAAgB;;iBAGd,eAAe;EAC9B,MAAM;EACN;EACA;EACA;;;;;;;qBAQW,eAAe;mBACT;mBACA;EAEL,YAAA,UAAS,iBAAiB;EAItC,KAAK,gBAAgB,eAAe;EAIpC,SAAS,eAAe;UAIhB;UASA;;;;;wBAuCa,eAAe,aACpC,QAAQ,eAAe,aACvB,UAAS,iBAAiB,KACzB,eAAe,eAAe;;;;wBA4CX,iBAAiB,aACrC,QAAQ,eAAe,aACvB,UAAU,OAAO,eAAe,aAChC,UAAU,OAAO,gBACjB,UAAS,iBAAiB,KACzB;;iBAuCc;EACf;EACA;EACA;EACA;;;iBAIe;;EAEf,OAAO;;EAEP;;EAEA;;EAEA;;EAEA,WAAW;;EAEX;;;;;;;;;;;;;;;;;;;qBA0BW;UACH;UACA;;;;;EAiBR,cAAc;;;;EAUd,aAAa,OAAO,eAAe;;;;;EAoDnC,YAAY;;;;EAeZ,WAAW,SAAS;;;;EAOpB;UAaQ;UAyCA;;;;;wBA4BM,8BAA8B;;;;;;;;;;;;;;wBAiB9B,oBAAoB,UAAU,yBAC5C,WAAW,OAAO;EAElB,WAAW,OAAO;EAClB,gBAAgB;EAChB,WAAW"}

package/dist/sse/index.js

@@ -1,4 +1,4 @@
-//#region src/sse/index.ts
+// src/sse/index.ts
 /**
 * Parse raw SSE data string into structured event data.
 *
@@ -26,63 +26,191 @@ function parseSSEData(rawData) {
 	return null;
 }
 /**
-* Incremental SSE parser for chunked streams.
-* Feed decoded string chunks via push(); call flush() on stream end.
+* A copy of `value` that shares no memory with the string it was cut from.
+*
+* V8 can return a short substring of a long string as a view that keeps the
+* whole string alive. Consumers keep event names and ids as long as they keep
+* events, so a view would keep every chunk its frame arrived in alive.
 */
-var SSEChunkParser = class {
-	buffer = "";
-	currentEvent = {};
-	options;
-	constructor(options = {}) {
-		this.options = options;
+function detached(value) {
+	return value === "" ? value : JSON.parse(JSON.stringify(value));
+}
+/**
+* Thrown when a stream sends no bytes for longer than its `idleMs`. A
+* producer that heartbeats would have written in that time, so the
+* connection is dead even though it never closed: a half-open TCP connection
+* or a stalled proxy hold the socket open while nothing arrives.
+*/
+var SSEStreamSilentError = class extends Error {
+	name = "SSEStreamSilentError";
+	idleMs;
+	constructor(idleMs) {
+		super(`SSE stream sent no bytes for ${idleMs} ms`);
+		this.idleMs = idleMs;
 	}
+};
+/**
+* Incremental SSE frame parser. Feed decoded text via `push()`; call
+* `flush()` when the stream ends.
+*/
+var SSEFrameParser = class {
+	buffer = "";
+	frameEvent = "";
+	frameId;
+	frameDataLines = null;
+	bomChecked = false;
+	/**
+	* Append a decoded text chunk and return every frame the chunk
+	* completes. Frame state survives across calls: one frame can
+	* straddle any number of chunks.
+	*/
 	push(chunk) {
-		this.buffer += chunk;
+		let text = chunk;
+		if (!this.bomChecked && text.length > 0) {
+			this.bomChecked = true;
+			if (text.charCodeAt(0) === 65279) text = text.slice(1);
+		}
+		this.buffer += text;
 		const lines = this.buffer.split("\n");
 		this.buffer = lines.pop() ?? "";
 		return this.processLines(lines);
 	}
+	/**
+	* End-of-stream: process the unterminated trailing line, then
+	* dispatch a dangling frame that never got its blank line.
+	* Well-behaved servers end frames with "\n\n", but some close early.
+	*/
 	flush() {
-		const lines = this.buffer ? [this.buffer] : [];
+		const rest = this.buffer;
 		this.buffer = "";
-		const events = this.processLines(lines);
-		const finalEvent = this.parseCurrentEvent();
-		if (finalEvent) {
-			events.push(finalEvent);
-			this.currentEvent = {};
-		}
-		return events;
+		const frames = rest.length > 0 ? this.processLines([rest]) : [];
+		const dangling = this.dispatch();
+		if (dangling) frames.push(dangling);
+		return frames;
 	}
 	processLines(lines) {
-		const events = [];
+		const frames = [];
 		for (const rawLine of lines) {
 			const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-			if (line.startsWith(":")) continue;
 			if (line === "") {
-				const parsed = this.parseCurrentEvent();
-				if (parsed) events.push(parsed);
-				this.currentEvent = {};
+				const frame = this.dispatch();
+				if (frame) frames.push(frame);
 				continue;
 			}
-			if (line.startsWith("id:")) {
-				this.currentEvent.id = line.slice(3).trim();
+			if (line.startsWith(":")) continue;
+			if (line.startsWith("data:")) {
+				let value = line.slice(5);
+				if (value.startsWith(" ")) value = value.slice(1);
+				if (this.frameDataLines === null) this.frameDataLines = [];
+				this.frameDataLines.push(value);
 				continue;
 			}
 			if (line.startsWith("event:")) {
-				this.currentEvent.event = line.slice(6).trim();
+				this.frameEvent = line.slice(6).trim();
 				continue;
 			}
-			if (line.startsWith("data:")) {
-				let value = line.slice(5);
-				if (value.startsWith(" ")) value = value.slice(1);
-				this.currentEvent.data = this.currentEvent.data !== void 0 ? `${this.currentEvent.data}\n${value}` : value;
+			if (line.startsWith("id:")) this.frameId = line.slice(3).trim();
+		}
+		return frames;
+	}
+	/**
+	* Dispatch the accumulated frame. A frame with no `data:` field (an
+	* `event:`/`id:`-only frame, or a bare comment) produces nothing, and
+	* its field state is consumed and reset either way.
+	*/
+	dispatch() {
+		const dataLines = this.frameDataLines;
+		const frame = dataLines ? {
+			event: detached(this.frameEvent),
+			data: dataLines.join("\n"),
+			id: this.frameId ? detached(this.frameId) : void 0
+		} : null;
+		this.frameEvent = "";
+		this.frameId = void 0;
+		this.frameDataLines = null;
+		return frame;
+	}
+};
+/**
+* Serialize one frame to its wire form. Multi-line `data` becomes one
+* `data:` line per source line so the payload survives the trip without
+* premature frame dispatch.
+*/
+function encodeSSEFrame(frame) {
+	let out = "";
+	if (frame.event !== void 0) out += `event: ${frame.event}\n`;
+	if (frame.id !== void 0) out += `id: ${frame.id}\n`;
+	for (const line of frame.data.split("\n")) out += `data: ${line}\n`;
+	return `${out}\n`;
+}
+/**
+* Read a streaming SSE response body into parsed frames.
+*
+* @throws `TypeError` when the body is missing.
+* @throws `DOMException` with `name === "AbortError"` on cancellation —
+*   including the WHATWG-fetch variant where an aborted body resolves
+*   `done: true` instead of rejecting the read.
+*/
+async function* streamSSEFrames(body, options) {
+	if (!body) throw new TypeError("SSE stream has no response body");
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const parser = new SSEFrameParser();
+	const { signal, idleMs } = options ?? {};
+	const read = () => {
+		const limit = idleMs?.();
+		if (limit === void 0) return reader.read();
+		let timer;
+		return Promise.race([reader.read(), new Promise((_, reject) => {
+			timer = setTimeout(() => reject(new SSEStreamSilentError(limit)), limit);
+		})]).finally(() => clearTimeout(timer));
+	};
+	let completed = false;
+	try {
+		for (;;) {
+			if (signal?.aborted) throw new DOMException("SSE stream aborted", "AbortError");
+			const { done, value } = await read();
+			if (done) {
+				if (signal?.aborted) throw new DOMException("SSE stream aborted", "AbortError");
+				break;
 			}
+			for (const frame of parser.push(decoder.decode(value, { stream: true }))) yield frame;
+		}
+		for (const frame of parser.push(decoder.decode())) yield frame;
+		for (const frame of parser.flush()) yield frame;
+		completed = true;
+	} finally {
+		if (!completed) await reader.cancel().catch(() => void 0);
+		reader.releaseLock();
+	}
+}
+/**
+* Incremental JSON event parser for chunked streams, framed by
+* {@link SSEFrameParser}. Feed decoded string chunks via push(); call flush()
+* on stream end. Frames whose trimmed data is empty produce no event.
+*/
+var SSEChunkParser = class {
+	frames = new SSEFrameParser();
+	options;
+	constructor(options = {}) {
+		this.options = options;
+	}
+	push(chunk) {
+		return this.toEvents(this.frames.push(chunk));
+	}
+	flush() {
+		return this.toEvents(this.frames.flush());
+	}
+	toEvents(frames) {
+		const events = [];
+		for (const frame of frames) {
+			const event = this.toEvent(frame);
+			if (event) events.push(event);
 		}
 		return events;
 	}
-	parseCurrentEvent() {
-		if (this.currentEvent.data === void 0) return null;
-		const rawData = this.currentEvent.data.trim();
+	toEvent(frame) {
+		const rawData = frame.data.trim();
 		if (!rawData) return null;
 		let data;
 		if (this.options.transform) {
@@ -101,8 +229,8 @@ var SSEChunkParser = class {
 		return {
 			data,
 			rawData,
-			eventId: this.currentEvent.id,
-			eventType: this.currentEvent.event
+			eventId: frame.id,
+			eventType: frame.event || void 0
 		};
 	}
 };
@@ -297,7 +425,6 @@ function createUsageCallback(forward) {
 		extractor
 	};
 }
-//#endregion
-export { SSEChunkParser, StreamUsageExtractor, consumeSSEStream, createStreamUsageExtractor, createUsageCallback, parseSSEData, parseSSEStream };
+export { SSEChunkParser, SSEFrameParser, SSEStreamSilentError, StreamUsageExtractor, consumeSSEStream, createStreamUsageExtractor, createUsageCallback, encodeSSEFrame, parseSSEData, parseSSEStream, streamSSEFrames };
 
 //# sourceMappingURL=index.js.map