@mcp-abap-adt/llm-agent 20.7.1 → 20.9.0

package/dist/interfaces/tool-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-catalog.d.ts","sourceRoot":"","sources":["../../src/interfaces/tool-catalog.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,2EAA2E;IAC3E,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,+EAA+E;IAC/E,oBAAoB,IAAI,iBAAiB,GAAG,SAAS,CAAC;CACvD;AAED,uDAAuD;AACvD,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,oBAAoB,CAM3E"}

package/dist/interfaces/tool-catalog.js

@@ -0,0 +1,7 @@
+/** Type guard: does `x` report tool-catalog status? */
+export function isToolCatalogReporter(x) {
+    return (typeof x === 'object' &&
+        x !== null &&
+        typeof x.getToolCatalogStatus === 'function');
+}
+//# sourceMappingURL=tool-catalog.js.map

package/dist/interfaces/tool-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-catalog.js","sourceRoot":"","sources":["../../src/interfaces/tool-catalog.ts"],"names":[],"mappings":"AAkCA,uDAAuD;AACvD,MAAM,UAAU,qBAAqB,CAAC,CAAU;IAC9C,OAAO,CACL,OAAO,CAAC,KAAK,QAAQ;QACrB,CAAC,KAAK,IAAI;QACV,OAAQ,CAA0B,CAAC,oBAAoB,KAAK,UAAU,CACvE,CAAC;AACJ,CAAC"}

package/dist/interfaces/tool-namespace.d.ts

@@ -0,0 +1,24 @@
+import type { IMcpClient } from './mcp-client.js';
+export interface ToolNamespaceContext {
+    /** Original tool name the server exposes. */
+    toolName: string;
+    /** Prefix source resolved by the builder: the server's config `name`, else `s${slotIndex}`. */
+    prefix: string;
+    /** True when this tool name is exposed by more than one currently-active client. */
+    colliding: boolean;
+}
+export interface IToolNamespace {
+    /** Name the LLM sees / RAG stores. Must be non-empty, `^[a-zA-Z0-9_-]+$`, <= 64 chars.
+     *  The builder validates this output — an invalid name fails fast. */
+    expose(ctx: ToolNamespaceContext): string;
+}
+/** Bare when unique; `${prefix}__${toolName}` on a collision. */
+export declare const defaultToolNamespace: IToolNamespace;
+/**
+ * Wrap an MCP client so `callTool` always targets `originalName`, whatever
+ * (exposed) name the caller passes. All other IMcpClient methods proxy straight
+ * through. This encapsulates the namespace strip in the tool→client map value,
+ * so no executor call site needs to know about namespacing.
+ */
+export declare function bindToolCallName(client: IMcpClient, originalName: string): IMcpClient;
+//# sourceMappingURL=tool-namespace.d.ts.map

package/dist/interfaces/tool-namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-namespace.d.ts","sourceRoot":"","sources":["../../src/interfaces/tool-namespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,MAAM,EAAE,MAAM,CAAC;IACf,oFAAoF;IACpF,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B;0EACsE;IACtE,MAAM,CAAC,GAAG,EAAE,oBAAoB,GAAG,MAAM,CAAC;CAC3C;AAED,iEAAiE;AACjE,eAAO,MAAM,oBAAoB,EAAE,cAGlC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,GACnB,UAAU,CASZ"}

package/dist/interfaces/tool-namespace.js

@@ -0,0 +1,20 @@
+/** Bare when unique; `${prefix}__${toolName}` on a collision. */
+export const defaultToolNamespace = {
+    expose: ({ toolName, prefix, colliding }) => colliding ? `${prefix}__${toolName}` : toolName,
+};
+/**
+ * Wrap an MCP client so `callTool` always targets `originalName`, whatever
+ * (exposed) name the caller passes. All other IMcpClient methods proxy straight
+ * through. This encapsulates the namespace strip in the tool→client map value,
+ * so no executor call site needs to know about namespacing.
+ */
+export function bindToolCallName(client, originalName) {
+    return {
+        listTools: (options) => client.listTools(options),
+        callTool: (_exposedName, args, options) => client.callTool(originalName, args, options),
+        ...(client.healthCheck
+            ? { healthCheck: (options) => client.healthCheck?.(options) }
+            : {}),
+    };
+}
+//# sourceMappingURL=tool-namespace.js.map

package/dist/interfaces/tool-namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-namespace.js","sourceRoot":"","sources":["../../src/interfaces/tool-namespace.ts"],"names":[],"mappings":"AAiBA,iEAAiE;AACjE,MAAM,CAAC,MAAM,oBAAoB,GAAmB;IAClD,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,EAAU,EAAE,CAClD,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,KAAK,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ;CAClD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAAkB,EAClB,YAAoB;IAEpB,OAAO;QACL,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC;QACjD,QAAQ,EAAE,CAAC,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CACxC,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC;QAC9C,GAAG,CAAC,MAAM,CAAC,WAAW;YACpB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE;YAC7D,CAAC,CAAC,EAAE,CAAC;KACM,CAAC;AAClB,CAAC"}

package/dist/interfaces/tool-record-key.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Strategy for the RAG record id under which an MCP tool is stored.
+ *
+ * A variation point the consumer owns: the default gives a working,
+ * collision-free *storage* key, and a consumer who knows its servers (real
+ * names, a per-server collection layout, or a faster-but-conflicting scheme)
+ * swaps in its own — provided the id keeps the `tool:` prefix (see `key`). The
+ * engine stays MCP-agnostic — it never assumes a fixed server set.
+ *
+ * Scope: this disambiguates records in the tools RAG store (so same-named tools
+ * from different servers both survive, improving recall). It does NOT route a
+ * call to a specific server — tool selection deduplicates by name because LLM
+ * tool-calling needs unique names, so a colliding name resolves to the first
+ * client. Per-server call routing needs tool-name namespacing, tracked apart.
+ */
+export interface ToolKeyContext {
+    /** The tool's own name, as exposed by its MCP server. */
+    toolName: string;
+    /**
+     * Zero-based index of the client this tool came from. One MCP server maps to
+     * exactly one client, so within a boot this identifies the server. Stable for
+     * the run; not durable across restarts if the configured order changes.
+     */
+    clientIndex: number;
+    /** Total number of connected MCP clients this run. */
+    clientCount: number;
+}
+export interface IToolRecordKey {
+    /**
+     * The record id for a tool. Must be stable for a given (name, server), and
+     * must start with `tool:` — retrieval uses that prefix to tell tool records
+     * apart from skill records (`skill:`) in the same store. The tool name is
+     * stored in metadata separately, so anything after `tool:` is free.
+     */
+    key(ctx: ToolKeyContext): string;
+}
+/**
+ * Default: a single MCP server keeps the historical `tool:${name}` key, so
+ * existing single-server collections are unchanged. With two or more servers
+ * the client index disambiguates, so identically named tools from different
+ * servers no longer overwrite each other.
+ */
+export declare const defaultToolRecordKey: IToolRecordKey;
+/**
+ * Recover a tool's name from a stored record, independent of the key scheme.
+ *
+ * The name is written into record metadata at vectorization time, so this
+ * works for ANY {@link IToolRecordKey} — including a consumer's custom scheme —
+ * without parsing the id. The id parse is a fallback for records written before
+ * the name was stored, and it understands both default forms (`tool:name` and
+ * `tool:<index>:name`).
+ *
+ * Returns `undefined` for a record that is not a tool (no `tool:` id).
+ */
+export declare function toolNameFromRecord(meta: {
+    id?: unknown;
+    name?: unknown;
+}): string | undefined;
+//# sourceMappingURL=tool-record-key.d.ts.map

package/dist/interfaces/tool-record-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-record-key.d.ts","sourceRoot":"","sources":["../../src/interfaces/tool-record-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CAAC;CAClC;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAMlC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,GAAG,MAAM,GAAG,SAAS,CAWrB"}

package/dist/interfaces/tool-record-key.js

@@ -0,0 +1,40 @@
+/**
+ * Default: a single MCP server keeps the historical `tool:${name}` key, so
+ * existing single-server collections are unchanged. With two or more servers
+ * the client index disambiguates, so identically named tools from different
+ * servers no longer overwrite each other.
+ */
+export const defaultToolRecordKey = {
+    key({ toolName, clientIndex, clientCount }) {
+        return clientCount <= 1
+            ? `tool:${toolName}`
+            : `tool:${clientIndex}:${toolName}`;
+    },
+};
+/**
+ * Recover a tool's name from a stored record, independent of the key scheme.
+ *
+ * The name is written into record metadata at vectorization time, so this
+ * works for ANY {@link IToolRecordKey} — including a consumer's custom scheme —
+ * without parsing the id. The id parse is a fallback for records written before
+ * the name was stored, and it understands both default forms (`tool:name` and
+ * `tool:<index>:name`).
+ *
+ * Returns `undefined` for a record that is not a tool (no `tool:` id).
+ */
+export function toolNameFromRecord(meta) {
+    const id = meta?.id;
+    if (typeof id !== 'string' || !id.startsWith('tool:'))
+        return undefined;
+    if (typeof meta.name === 'string' && meta.name.length > 0)
+        return meta.name;
+    const rest = id.slice(5);
+    // Default multi-server form `tool:<index>:<name>` — a numeric first segment is
+    // the client index, so the name follows it.
+    const indexed = /^\d+:(.*)$/.exec(rest);
+    if (indexed)
+        return indexed[1];
+    // Otherwise the historical `tool:<name>[:<suffix>]` form — name comes first.
+    return rest.replace(/:.*$/, '');
+}
+//# sourceMappingURL=tool-record-key.js.map

package/dist/interfaces/tool-record-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-record-key.js","sourceRoot":"","sources":["../../src/interfaces/tool-record-key.ts"],"names":[],"mappings":"AAsCA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAmB;IAClD,GAAG,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE;QACxC,OAAO,WAAW,IAAI,CAAC;YACrB,CAAC,CAAC,QAAQ,QAAQ,EAAE;YACpB,CAAC,CAAC,QAAQ,WAAW,IAAI,QAAQ,EAAE,CAAC;IACxC,CAAC;CACF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAGlC;IACC,MAAM,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC;IACpB,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC;QAAE,OAAO,SAAS,CAAC;IACxE,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC,IAAI,CAAC;IAC5E,MAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzB,+EAA+E;IAC/E,4CAA4C;IAC5C,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/B,6EAA6E;IAC7E,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAClC,CAAC"}

package/dist/resilience/batch-chunking-embedder.d.ts

@@ -0,0 +1,23 @@
+/**
+ * BatchChunkingEmbedder — splits embedBatch input into provider-safe chunks.
+ *
+ * Applied ONLY over a batch-capable inner (see composeResilientEmbedder): a
+ * decorator exposing embedBatch unconditionally would make a non-batch embedder
+ * look batch-capable to isBatchEmbedder.
+ */
+import type { IEmbedderBatch, IEmbedResult } from '../interfaces/rag.js';
+import type { CallOptions } from '../interfaces/types.js';
+/**
+ * Used when neither YAML nor the provider declares a cap. Comfortably below the
+ * only hard cap we have confirmed (Vertex 250), and large enough that a
+ * 356-tool catalog costs 4 requests.
+ */
+export declare const DEFAULT_MAX_BATCH_SIZE = 100;
+export declare class BatchChunkingEmbedder implements IEmbedderBatch {
+    private readonly inner;
+    private readonly maxBatchSize;
+    constructor(inner: IEmbedderBatch, maxBatchSize: number);
+    embed(text: string, options?: CallOptions): Promise<IEmbedResult>;
+    embedBatch(texts: string[], options?: CallOptions): Promise<IEmbedResult[]>;
+}
+//# sourceMappingURL=batch-chunking-embedder.d.ts.map

package/dist/resilience/batch-chunking-embedder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-chunking-embedder.d.ts","sourceRoot":"","sources":["../../src/resilience/batch-chunking-embedder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG1D;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,qBAAa,qBAAsB,YAAW,cAAc;IAExD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADZ,KAAK,EAAE,cAAc,EACrB,YAAY,EAAE,MAAM;IAUvC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAI3D,UAAU,CACd,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC;CAkB3B"}

package/dist/resilience/batch-chunking-embedder.js

@@ -0,0 +1,45 @@
+/**
+ * BatchChunkingEmbedder — splits embedBatch input into provider-safe chunks.
+ *
+ * Applied ONLY over a batch-capable inner (see composeResilientEmbedder): a
+ * decorator exposing embedBatch unconditionally would make a non-batch embedder
+ * look batch-capable to isBatchEmbedder.
+ */
+import { RagError } from '../interfaces/types.js';
+/**
+ * Used when neither YAML nor the provider declares a cap. Comfortably below the
+ * only hard cap we have confirmed (Vertex 250), and large enough that a
+ * 356-tool catalog costs 4 requests.
+ */
+export const DEFAULT_MAX_BATCH_SIZE = 100;
+export class BatchChunkingEmbedder {
+    inner;
+    maxBatchSize;
+    constructor(inner, maxBatchSize) {
+        this.inner = inner;
+        this.maxBatchSize = maxBatchSize;
+        if (!Number.isSafeInteger(maxBatchSize) || maxBatchSize < 1) {
+            throw new RagError(`maxBatchSize must be a positive safe integer, got ${String(maxBatchSize)}`, 'CONFIG_ERROR');
+        }
+    }
+    embed(text, options) {
+        return this.inner.embed(text, options);
+    }
+    async embedBatch(texts, options) {
+        if (texts.length === 0)
+            return [];
+        const out = [];
+        // Sequential on purpose: concurrent chunks would reintroduce the rate
+        // limiting that chunking exists to avoid.
+        for (let i = 0; i < texts.length; i += this.maxBatchSize) {
+            const chunk = texts.slice(i, i + this.maxBatchSize);
+            const res = await this.inner.embedBatch(chunk, options);
+            if (res.length !== chunk.length) {
+                throw new RagError(`Batch embedding returned ${res.length} embeddings, expected ${chunk.length}`, 'EMBED_ERROR');
+            }
+            out.push(...res);
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=batch-chunking-embedder.js.map

package/dist/resilience/batch-chunking-embedder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-chunking-embedder.js","sourceRoot":"","sources":["../../src/resilience/batch-chunking-embedder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAElD;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAE1C,MAAM,OAAO,qBAAqB;IAEb;IACA;IAFnB,YACmB,KAAqB,EACrB,YAAoB;QADpB,UAAK,GAAL,KAAK,CAAgB;QACrB,iBAAY,GAAZ,YAAY,CAAQ;QAErC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,YAAY,GAAG,CAAC,EAAE,CAAC;YAC5D,MAAM,IAAI,QAAQ,CAChB,qDAAqD,MAAM,CAAC,YAAY,CAAC,EAAE,EAC3E,cAAc,CACf,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,IAAY,EAAE,OAAqB;QACvC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,UAAU,CACd,KAAe,EACf,OAAqB;QAErB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAClC,MAAM,GAAG,GAAmB,EAAE,CAAC;QAC/B,sEAAsE;QACtE,0CAA0C;QAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACzD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;YACpD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACxD,IAAI,GAAG,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;gBAChC,MAAM,IAAI,QAAQ,CAChB,4BAA4B,GAAG,CAAC,MAAM,yBAAyB,KAAK,CAAC,MAAM,EAAE,EAC7E,aAAa,CACd,CAAC;YACJ,CAAC;YACD,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;CACF"}

package/dist/resilience/circuit-breaker-embedder.d.ts

@@ -3,14 +3,34 @@
  *
  * When the circuit is open, calls throw an error rather than hitting the
  * underlying embedding service.
+ *
+ * Prefer the {@link withCircuitBreaker} factory: it selects a non-batch or
+ * batch class by inspecting the inner embedder, so it preserves batch
+ * capability rather than fabricating it. The exported classes are kept for
+ * direct construction and backward compatibility.
  */
-import type { CallOptions, IEmbedder, IEmbedResult } from '@mcp-abap-adt/llm-agent';
+import type { CallOptions, IEmbedder, IEmbedderBatch, IEmbedResult } from '@mcp-abap-adt/llm-agent';
 import type { CircuitBreaker } from './circuit-breaker.js';
-export declare class CircuitBreakerEmbedder implements IEmbedder {
-    private readonly inner;
+/** Non-batch breaker decorator — exposes only `embed()`. */
+export declare class CircuitBreakerEmbedderBase implements IEmbedder {
+    protected readonly inner: IEmbedder;
     readonly breaker: CircuitBreaker;
     constructor(inner: IEmbedder, breaker: CircuitBreaker);
     embed(text: string, options?: CallOptions): Promise<IEmbedResult>;
+}
+/**
+ * Batch breaker decorator. Unchanged public shape: it always exposes
+ * `embedBatch`, so `new CircuitBreakerEmbedder(nonBatchInner, ...)` still
+ * reports batch capability it lacks (and throws at call time). Construct via
+ * {@link withCircuitBreaker} to avoid that.
+ */
+export declare class CircuitBreakerEmbedder extends CircuitBreakerEmbedderBase implements IEmbedderBatch {
     embedBatch(texts: string[], options?: CallOptions): Promise<IEmbedResult[]>;
 }
+/**
+ * Wrap an embedder with a circuit breaker, preserving batch capability: a
+ * batch-capable inner gets the batch class, a non-batch inner the base class.
+ * The same two-class-behind-a-factory shape as `wrapEmbedder` / `withRetry`.
+ */
+export declare function withCircuitBreaker(inner: IEmbedder, breaker: CircuitBreaker): IEmbedder;
 //# sourceMappingURL=circuit-breaker-embedder.d.ts.map

package/dist/resilience/circuit-breaker-embedder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circuit-breaker-embedder.d.ts","sourceRoot":"","sources":["../../src/resilience/circuit-breaker-embedder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,YAAY,EACb,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,qBAAa,sBAAuB,YAAW,SAAS;IAEpD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc;gBADf,KAAK,EAAE,SAAS,EACxB,OAAO,EAAE,cAAc;IAG5B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAcjE,UAAU,CACd,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC;CAmB3B"}
+{"version":3,"file":"circuit-breaker-embedder.d.ts","sourceRoot":"","sources":["../../src/resilience/circuit-breaker-embedder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,cAAc,EACd,YAAY,EACb,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,4DAA4D;AAC5D,qBAAa,0BAA2B,YAAW,SAAS;IAExD,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS;IACnC,QAAQ,CAAC,OAAO,EAAE,cAAc;gBADb,KAAK,EAAE,SAAS,EAC1B,OAAO,EAAE,cAAc;IAG5B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CAaxE;AAED;;;;;GAKG;AACH,qBAAa,sBACX,SAAQ,0BACR,YAAW,cAAc;IAEnB,UAAU,CACd,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC;CAmB3B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,cAAc,GACtB,SAAS,CAIX"}

package/dist/resilience/circuit-breaker-embedder.js

@@ -3,9 +3,15 @@
  *
  * When the circuit is open, calls throw an error rather than hitting the
  * underlying embedding service.
+ *
+ * Prefer the {@link withCircuitBreaker} factory: it selects a non-batch or
+ * batch class by inspecting the inner embedder, so it preserves batch
+ * capability rather than fabricating it. The exported classes are kept for
+ * direct construction and backward compatibility.
  */
 import { isBatchEmbedder, RagError } from '@mcp-abap-adt/llm-agent';
-export class CircuitBreakerEmbedder {
+/** Non-batch breaker decorator — exposes only `embed()`. */
+export class CircuitBreakerEmbedderBase {
     inner;
     breaker;
     constructor(inner, breaker) {
@@ -26,6 +32,14 @@ export class CircuitBreakerEmbedder {
             throw err;
         }
     }
+}
+/**
+ * Batch breaker decorator. Unchanged public shape: it always exposes
+ * `embedBatch`, so `new CircuitBreakerEmbedder(nonBatchInner, ...)` still
+ * reports batch capability it lacks (and throws at call time). Construct via
+ * {@link withCircuitBreaker} to avoid that.
+ */
+export class CircuitBreakerEmbedder extends CircuitBreakerEmbedderBase {
     async embedBatch(texts, options) {
         if (!this.breaker.isCallPermitted) {
             throw new RagError('Embedder circuit breaker is open', 'CIRCUIT_OPEN');
@@ -44,4 +58,14 @@ export class CircuitBreakerEmbedder {
         }
     }
 }
+/**
+ * Wrap an embedder with a circuit breaker, preserving batch capability: a
+ * batch-capable inner gets the batch class, a non-batch inner the base class.
+ * The same two-class-behind-a-factory shape as `wrapEmbedder` / `withRetry`.
+ */
+export function withCircuitBreaker(inner, breaker) {
+    return isBatchEmbedder(inner)
+        ? new CircuitBreakerEmbedder(inner, breaker)
+        : new CircuitBreakerEmbedderBase(inner, breaker);
+}
 //# sourceMappingURL=circuit-breaker-embedder.js.map

package/dist/resilience/circuit-breaker-embedder.js.map

@@ -1 +1 @@
-{"version":3,"file":"circuit-breaker-embedder.js","sourceRoot":"","sources":["../../src/resilience/circuit-breaker-embedder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGpE,MAAM,OAAO,sBAAsB;IAEd;IACR;IAFX,YACmB,KAAgB,EACxB,OAAuB;QADf,UAAK,GAAL,KAAK,CAAW;QACxB,YAAO,GAAP,OAAO,CAAgB;IAC/B,CAAC;IAEJ,KAAK,CAAC,KAAK,CAAC,IAAY,EAAE,OAAqB;QAC7C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,MAAM,IAAI,QAAQ,CAAC,kCAAkC,EAAE,cAAc,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACrD,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CACd,KAAe,EACf,OAAqB;QAErB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,MAAM,IAAI,QAAQ,CAAC,kCAAkC,EAAE,cAAc,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,QAAQ,CAChB,iDAAiD,EACjD,aAAa,CACd,CAAC;QACJ,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAC3D,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;CACF"}
+{"version":3,"file":"circuit-breaker-embedder.js","sourceRoot":"","sources":["../../src/resilience/circuit-breaker-embedder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGpE,4DAA4D;AAC5D,MAAM,OAAO,0BAA0B;IAEhB;IACV;IAFX,YACqB,KAAgB,EAC1B,OAAuB;QADb,UAAK,GAAL,KAAK,CAAW;QAC1B,YAAO,GAAP,OAAO,CAAgB;IAC/B,CAAC;IAEJ,KAAK,CAAC,KAAK,CAAC,IAAY,EAAE,OAAqB;QAC7C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,MAAM,IAAI,QAAQ,CAAC,kCAAkC,EAAE,cAAc,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACrD,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,OAAO,sBACX,SAAQ,0BAA0B;IAGlC,KAAK,CAAC,UAAU,CACd,KAAe,EACf,OAAqB;QAErB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,MAAM,IAAI,QAAQ,CAAC,kCAAkC,EAAE,cAAc,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,QAAQ,CAChB,iDAAiD,EACjD,aAAa,CACd,CAAC;QACJ,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAC3D,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAgB,EAChB,OAAuB;IAEvB,OAAO,eAAe,CAAC,KAAK,CAAC;QAC3B,CAAC,CAAC,IAAI,sBAAsB,CAAC,KAAK,EAAE,OAAO,CAAC;QAC5C,CAAC,CAAC,IAAI,0BAA0B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACrD,CAAC"}

package/dist/resilience/embedder-resilience.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Composition of the embedder resilience chain, and the metadata that travels
+ * with it.
+ *
+ *   wrapEmbedder( BatchChunkingEmbedder( RetryBatchEmbedder( provider ) ) )
+ *
+ * Retry sits INSIDE chunking so each chunk retries independently: a failure on
+ * chunk 20 must not re-issue chunks 1-19.
+ *
+ * The metadata is keyed by a registered symbol, not a string property: a string
+ * key could be matched structurally by an unrelated consumer embedder, and the
+ * guard would then read a foreign object as ours.
+ */
+import type { IEmbedder } from '../interfaces/rag.js';
+import type { ILogger } from '../logger/types.js';
+import type { EmbedderRetryOptions } from './retry-embedder.js';
+export declare const RESILIENCE_META: unique symbol;
+export interface EmbedderResilienceMetadata {
+    /** Absent for a non-batch embedder: retry applies, chunking does not. */
+    maxBatchSize?: number;
+}
+/** Undefined iff the embedder has no resilience layer. */
+export declare function getResilienceMetadata(e: IEmbedder): EmbedderResilienceMetadata | undefined;
+/**
+ * Attach metadata to an instance without making it enumerable.
+ *
+ * Also used by `wrapEmbedder` (llm-agent-libs) to propagate the metadata onto
+ * its own wrapper: that decorator's `inner` is `protected`, so a caller holding
+ * the wrapper could not otherwise see a brand sitting on a layer below, and
+ * re-resolution would compose the decorators a second time.
+ */
+export declare function brandResilient(e: IEmbedder, meta: EmbedderResilienceMetadata): void;
+export interface ComposeResilienceOptions {
+    /** A cap a human configured. ONLY this may trigger the conflict check. */
+    explicitMaxBatchSize?: number;
+    /** Provider-derived or default cap; never triggers the conflict check. */
+    fallbackMaxBatchSize?: number;
+    retry?: Partial<EmbedderRetryOptions>;
+    logger?: ILogger;
+}
+export declare function composeResilientEmbedder(inner: IEmbedder, options?: ComposeResilienceOptions): IEmbedder;
+//# sourceMappingURL=embedder-resilience.d.ts.map

package/dist/resilience/embedder-resilience.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedder-resilience.d.ts","sourceRoot":"","sources":["../../src/resilience/embedder-resilience.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAKlD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,eAAO,MAAM,eAAe,eAAkD,CAAC;AAE/E,MAAM,WAAW,0BAA0B;IACzC,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,0DAA0D;AAC1D,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,SAAS,GACX,0BAA0B,GAAG,SAAS,CAIxC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,SAAS,EACZ,IAAI,EAAE,0BAA0B,GAC/B,IAAI,CAON;AAED,MAAM,WAAW,wBAAwB;IACvC,0EAA0E;IAC1E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACtC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,wBAAwB,GACjC,SAAS,CAgCX"}

package/dist/resilience/embedder-resilience.js

@@ -0,0 +1,66 @@
+/**
+ * Composition of the embedder resilience chain, and the metadata that travels
+ * with it.
+ *
+ *   wrapEmbedder( BatchChunkingEmbedder( RetryBatchEmbedder( provider ) ) )
+ *
+ * Retry sits INSIDE chunking so each chunk retries independently: a failure on
+ * chunk 20 must not re-issue chunks 1-19.
+ *
+ * The metadata is keyed by a registered symbol, not a string property: a string
+ * key could be matched structurally by an unrelated consumer embedder, and the
+ * guard would then read a foreign object as ours.
+ */
+import { isBatchEmbedder, isBatchSizeLimited } from '../interfaces/rag.js';
+import { BatchChunkingEmbedder, DEFAULT_MAX_BATCH_SIZE, } from './batch-chunking-embedder.js';
+import { withRetry } from './retry-embedder.js';
+export const RESILIENCE_META = Symbol.for('@mcp-abap-adt/embedder-resilience');
+/** Undefined iff the embedder has no resilience layer. */
+export function getResilienceMetadata(e) {
+    return e[RESILIENCE_META];
+}
+/**
+ * Attach metadata to an instance without making it enumerable.
+ *
+ * Also used by `wrapEmbedder` (llm-agent-libs) to propagate the metadata onto
+ * its own wrapper: that decorator's `inner` is `protected`, so a caller holding
+ * the wrapper could not otherwise see a brand sitting on a layer below, and
+ * re-resolution would compose the decorators a second time.
+ */
+export function brandResilient(e, meta) {
+    Object.defineProperty(e, RESILIENCE_META, {
+        value: meta,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+}
+export function composeResilientEmbedder(inner, options) {
+    const existing = getResilienceMetadata(inner);
+    if (existing) {
+        const requested = options?.explicitMaxBatchSize;
+        // Re-deriving the cap here would fire on every normal boot: wrapEmbedder
+        // hides the provider, so a derived value falls to the default and would
+        // look like a conflict nobody configured. Only an explicit request counts.
+        if (requested !== undefined && requested !== existing.maxBatchSize) {
+            options?.logger?.log({
+                type: 'warning',
+                traceId: 'embedder-resolution',
+                message: `Embedder is already composed with maxBatchSize ${String(existing.maxBatchSize)}; ` +
+                    `ignoring the requested ${requested}. One shared embedder has one cap.`,
+            });
+        }
+        return inner;
+    }
+    const cap = options?.explicitMaxBatchSize ??
+        options?.fallbackMaxBatchSize ??
+        (isBatchSizeLimited(inner) ? inner.maxBatchSize : DEFAULT_MAX_BATCH_SIZE);
+    const retried = withRetry(inner, options?.retry);
+    const batchCapable = isBatchEmbedder(retried);
+    const composed = batchCapable
+        ? new BatchChunkingEmbedder(retried, cap)
+        : retried;
+    brandResilient(composed, batchCapable ? { maxBatchSize: cap } : {});
+    return composed;
+}
+//# sourceMappingURL=embedder-resilience.js.map

package/dist/resilience/embedder-resilience.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedder-resilience.js","sourceRoot":"","sources":["../../src/resilience/embedder-resilience.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;AAO/E,0DAA0D;AAC1D,MAAM,UAAU,qBAAqB,CACnC,CAAY;IAEZ,OAAQ,CAAwD,CAC9D,eAAe,CAChB,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,CAAY,EACZ,IAAgC;IAEhC,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,eAAe,EAAE;QACxC,KAAK,EAAE,IAAI;QACX,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE,KAAK;QACnB,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAC;AACL,CAAC;AAWD,MAAM,UAAU,wBAAwB,CACtC,KAAgB,EAChB,OAAkC;IAElC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAC9C,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,SAAS,GAAG,OAAO,EAAE,oBAAoB,CAAC;QAChD,yEAAyE;QACzE,wEAAwE;QACxE,2EAA2E;QAC3E,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,QAAQ,CAAC,YAAY,EAAE,CAAC;YACnE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC;gBACnB,IAAI,EAAE,SAAS;gBACf,OAAO,EAAE,qBAAqB;gBAC9B,OAAO,EACL,kDAAkD,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI;oBACnF,0BAA0B,SAAS,oCAAoC;aAC1E,CAAC,CAAC;QACL,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,GAAG,GACP,OAAO,EAAE,oBAAoB;QAC7B,OAAO,EAAE,oBAAoB;QAC7B,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC;IAE5E,MAAM,OAAO,GAAG,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IACjD,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IAC9C,MAAM,QAAQ,GAAG,YAAY;QAC3B,CAAC,CAAC,IAAI,qBAAqB,CAAC,OAAO,EAAE,GAAG,CAAC;QACzC,CAAC,CAAC,OAAO,CAAC;IAEZ,cAAc,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpE,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/resilience/index.d.ts

@@ -1,5 +1,8 @@
+export { BatchChunkingEmbedder, DEFAULT_MAX_BATCH_SIZE, } from './batch-chunking-embedder.js';
 export { CircuitBreaker, type CircuitBreakerConfig, type CircuitState, } from './circuit-breaker.js';
-export { CircuitBreakerEmbedder } from './circuit-breaker-embedder.js';
+export { CircuitBreakerEmbedder, CircuitBreakerEmbedderBase, withCircuitBreaker, } from './circuit-breaker-embedder.js';
 export { CircuitBreakerLlm } from './circuit-breaker-llm.js';
+export { brandResilient, type ComposeResilienceOptions, composeResilientEmbedder, type EmbedderResilienceMetadata, getResilienceMetadata, RESILIENCE_META, } from './embedder-resilience.js';
 export { FallbackRag } from './fallback-rag.js';
+export { type EmbedderRetryOptions, extractStatusCode, isRetryableStatus, RetryBatchEmbedder, RetryEmbedder, withRetry, } from './retry-embedder.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resilience/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,YAAY,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resilience/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,YAAY,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EACL,cAAc,EACd,KAAK,wBAAwB,EAC7B,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,qBAAqB,EACrB,eAAe,GAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EACL,KAAK,oBAAoB,EACzB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,SAAS,GACV,MAAM,qBAAqB,CAAC"}

package/dist/resilience/index.js

@@ -1,5 +1,8 @@
+export { BatchChunkingEmbedder, DEFAULT_MAX_BATCH_SIZE, } from './batch-chunking-embedder.js';
 export { CircuitBreaker, } from './circuit-breaker.js';
-export { CircuitBreakerEmbedder } from './circuit-breaker-embedder.js';
+export { CircuitBreakerEmbedder, CircuitBreakerEmbedderBase, withCircuitBreaker, } from './circuit-breaker-embedder.js';
 export { CircuitBreakerLlm } from './circuit-breaker-llm.js';
+export { brandResilient, composeResilientEmbedder, getResilienceMetadata, RESILIENCE_META, } from './embedder-resilience.js';
 export { FallbackRag } from './fallback-rag.js';
+export { extractStatusCode, isRetryableStatus, RetryBatchEmbedder, RetryEmbedder, withRetry, } from './retry-embedder.js';
 //# sourceMappingURL=index.js.map

package/dist/resilience/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resilience/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAGf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resilience/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,cAAc,GAGf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EACL,cAAc,EAEd,wBAAwB,EAExB,qBAAqB,EACrB,eAAe,GAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAEL,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,SAAS,GACV,MAAM,qBAAqB,CAAC"}

package/dist/resilience/retry-embedder.d.ts

@@ -0,0 +1,79 @@
+/**
+ * RetryEmbedder — IEmbedder decorators that retry transient failures with
+ * exponential backoff. Ported from RetryLlm (llm-agent-libs) onto IEmbedder,
+ * which throws instead of returning a Result.
+ *
+ * Two classes behind a factory, following wrapEmbedder: a single class exposing
+ * embedBatch unconditionally would make every non-batch embedder look
+ * batch-capable to isBatchEmbedder.
+ */
+import type { IEmbedder, IEmbedderBatch, IEmbedResult } from '../interfaces/rag.js';
+import type { CallOptions } from '../interfaces/types.js';
+import type { IWaitStrategy } from '../interfaces/wait-strategy.js';
+export interface EmbedderRetryOptions {
+    /** Maximum number of retries (total calls = maxAttempts + 1). Default: 3. */
+    maxAttempts: number;
+    /** Initial backoff delay in ms. Doubles each attempt. Default: 2000. */
+    backoffMs: number;
+    /** HTTP status codes that trigger a retry. Default: [429, 500, 502, 503]. */
+    retryOn: number[];
+    /**
+     * Mechanism for the backoff sleep. Default: `DefaultWaitStrategy`.
+     *
+     * The same seam the controller's `wait` step uses: a deployment can replace
+     * a blocking timer with jitter, its own scheduler, or suspend/resume.
+     *
+     * Optional, unlike the scalar knobs beside it: this is a collaborator, not a
+     * setting. A consumer assembling a full options literal should not have to
+     * name an internal mechanism, and the type stays expressible as plain data.
+     */
+    waitStrategy?: IWaitStrategy;
+}
+/** Internal shape after defaults are applied — every field is present. */
+type ResolvedRetryOptions = Omit<EmbedderRetryOptions, 'waitStrategy'> & {
+    waitStrategy: IWaitStrategy;
+};
+/**
+ * Resolve an HTTP status from an unknown thrown value: own status/statusCode,
+ * then the same walking `cause`, bounded by depth and a visited set so a cyclic
+ * chain cannot hang. Returns undefined when no numeric status is present.
+ */
+export declare function extractStatusCode(err: unknown): number | undefined;
+/**
+ * Whether a thrown value should be retried against a set of HTTP status codes.
+ *
+ * A structured status (own `status`/`statusCode`, or the same on `cause`) is
+ * authoritative. Only when none is present does it fall back to the message,
+ * and there it matches on **word boundaries** — a bare `includes('429')` also
+ * fires on `4290`, an id, or a byte count, turning a hard error into a
+ * multi-second backoff stall.
+ *
+ * Shared by both retry decorators (embedder and LLM) so the classification
+ * cannot drift between them.
+ */
+export declare function isRetryableStatus(err: unknown, retryOn: number[]): boolean;
+export declare class RetryEmbedder implements IEmbedder {
+    protected readonly inner: IEmbedder;
+    protected readonly opts: ResolvedRetryOptions;
+    constructor(inner: IEmbedder, options?: Partial<EmbedderRetryOptions>);
+    embed(text: string, options?: CallOptions): Promise<IEmbedResult>;
+    protected run<T>(call: () => Promise<T>, options?: CallOptions): Promise<T>;
+    protected isRetryable(err: unknown): boolean;
+    /**
+     * Delegated to IWaitStrategy rather than hand-rolled: honouring the signal is
+     * part of that contract — an already-aborted signal returns immediately
+     * (addEventListener never fires for an event that already dispatched), and
+     * the listener is removed when the timer wins so a request- or session-scoped
+     * signal does not accumulate one per retry.
+     */
+    protected backoff(attempt: number, signal?: AbortSignal): Promise<void>;
+}
+export declare class RetryBatchEmbedder extends RetryEmbedder implements IEmbedderBatch {
+    protected readonly inner: IEmbedderBatch;
+    constructor(inner: IEmbedderBatch, options?: Partial<EmbedderRetryOptions>);
+    embedBatch(texts: string[], options?: CallOptions): Promise<IEmbedResult[]>;
+}
+/** Preserves batch capability: never turns a non-batch embedder into one. */
+export declare function withRetry(inner: IEmbedder, options?: Partial<EmbedderRetryOptions>): IEmbedder;
+export {};
+//# sourceMappingURL=retry-embedder.d.ts.map

package/dist/resilience/retry-embedder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-embedder.d.ts","sourceRoot":"","sources":["../../src/resilience/retry-embedder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,YAAY,EACb,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAGpE,MAAM,WAAW,oBAAoB;IACnC,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC;CAC9B;AAED,0EAA0E;AAC1E,KAAK,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,EAAE,cAAc,CAAC,GAAG;IACvE,YAAY,EAAE,aAAa,CAAC;CAC7B,CAAC;AAYF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAgBlE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAK1E;AAED,qBAAa,aAAc,YAAW,SAAS;IAI3C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS;IAHrC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;gBAGzB,KAAK,EAAE,SAAS,EACnC,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAYnC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;cAIvD,GAAG,CAAC,CAAC,EACnB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,CAAC,CAAC;IAeb,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAI5C;;;;;;OAMG;cACa,OAAO,CACrB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC;CAIjB;AAED,qBAAa,kBACX,SAAQ,aACR,YAAW,cAAc;IAGvB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,cAAc;gBAArB,KAAK,EAAE,cAAc,EACxC,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAKnC,UAAU,CACd,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC;CAG3B;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,GACtC,SAAS,CAIX"}