@mcp-abap-adt/llm-agent 11.1.2 → 12.0.0

package/dist/interfaces/api-adapter.d.ts

@@ -0,0 +1,36 @@
+import type { AgentCallOptions, LlmStreamChunk, Message, OrchestratorError, Result, SmartAgentResponse } from '@mcp-abap-adt/llm-agent';
+export interface ApiSseEvent {
+    /**
+     * Optional SSE event name.
+     * - Anthropic: "message_start", "content_block_delta", ...
+     * - OpenAI: omitted (OpenAI SSE has no `event:` field)
+     */
+    event?: string;
+    /**
+     * Already-serialized SSE data payload.
+     * Consumer writes verbatim after `data: `.
+     */
+    data: string;
+}
+export interface ApiRequestContext {
+    readonly adapterName: string;
+    readonly protocol: Record<string, unknown>;
+}
+export interface NormalizedRequest {
+    messages: Message[];
+    stream: boolean;
+    options?: AgentCallOptions;
+    context: ApiRequestContext;
+}
+export interface ILlmApiAdapter {
+    readonly name: string;
+    normalizeRequest(request: unknown): NormalizedRequest;
+    transformStream(source: AsyncIterable<Result<LlmStreamChunk, OrchestratorError>>, context: ApiRequestContext): AsyncIterable<ApiSseEvent>;
+    formatResult(response: SmartAgentResponse, context: ApiRequestContext): unknown;
+    formatError?(error: OrchestratorError, context: ApiRequestContext): unknown;
+}
+export declare class AdapterValidationError extends Error {
+    readonly statusCode: number;
+    constructor(message: string, statusCode?: number);
+}
+//# sourceMappingURL=api-adapter.d.ts.map

package/dist/interfaces/api-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-adapter.d.ts","sourceRoot":"","sources":["../../src/interfaces/api-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,OAAO,EACP,iBAAiB,EACjB,MAAM,EACN,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAAC;IAEtD,eAAe,CACb,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC,EAChE,OAAO,EAAE,iBAAiB,GACzB,aAAa,CAAC,WAAW,CAAC,CAAC;IAE9B,YAAY,CACV,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC;IAEX,WAAW,CAAC,CAAC,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC;CAC7E;AAED,qBAAa,sBAAuB,SAAQ,KAAK;aAG7B,UAAU,EAAE,MAAM;gBADlC,OAAO,EAAE,MAAM,EACC,UAAU,GAAE,MAAY;CAK3C"}

package/dist/interfaces/api-adapter.js

@@ -0,0 +1,9 @@
+export class AdapterValidationError extends Error {
+    statusCode;
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'AdapterValidationError';
+    }
+}
+//# sourceMappingURL=api-adapter.js.map

package/dist/interfaces/api-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-adapter.js","sourceRoot":"","sources":["../../src/interfaces/api-adapter.ts"],"names":[],"mappings":"AAuDA,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAG7B;IAFlB,YACE,OAAe,EACC,aAAqB,GAAG;QAExC,KAAK,CAAC,OAAO,CAAC,CAAC;QAFC,eAAU,GAAV,UAAU,CAAc;QAGxC,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACvC,CAAC;CACF"}

package/dist/interfaces/client-adapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Contract for adapting agent responses to a specific client format.
+ *
+ * Some clients (e.g. Cline) are prompt-based agents that expect tool
+ * calls formatted as XML inside the assistant `content` field rather
+ * than as native OpenAI `tool_calls`.  A client adapter detects such
+ * clients and wraps the final response accordingly.
+ */
+export interface IClientAdapter {
+    /** Human-readable name used in logs. */
+    readonly name: string;
+    /**
+     * Return `true` if this adapter should handle the given request.
+     * Called once per request with the client's system prompt (if any).
+     */
+    detect(systemPrompt: string): boolean;
+    /**
+     * Wrap the final assistant content before it is sent to the client.
+     * Only called when {@link detect} returned `true` for this request.
+     */
+    wrapResponse(content: string): string;
+}
+//# sourceMappingURL=client-adapter.d.ts.map

package/dist/interfaces/client-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-adapter.d.ts","sourceRoot":"","sources":["../../src/interfaces/client-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;IAEtC;;;OAGG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CACvC"}

package/dist/interfaces/client-adapter.js

@@ -0,0 +1,10 @@
+/**
+ * Contract for adapting agent responses to a specific client format.
+ *
+ * Some clients (e.g. Cline) are prompt-based agents that expect tool
+ * calls formatted as XML inside the assistant `content` field rather
+ * than as native OpenAI `tool_calls`.  A client adapter detects such
+ * clients and wraps the final response accordingly.
+ */
+export {};
+//# sourceMappingURL=client-adapter.js.map

package/dist/interfaces/client-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-adapter.js","sourceRoot":"","sources":["../../src/interfaces/client-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/logger/types.d.ts

@@ -0,0 +1,63 @@
+export interface ILogger {
+    log(event: LogEvent): void;
+}
+export type LogEvent = {
+    type: 'classify';
+    traceId: string;
+    inputLength: number;
+    subpromptCount: number;
+    durationMs: number;
+} | {
+    type: 'rag_upsert';
+    traceId: string;
+    store: string;
+    durationMs: number;
+} | {
+    type: 'rag_query';
+    traceId: string;
+    store: string;
+    k: number;
+    resultCount: number;
+    durationMs: number;
+} | {
+    type: 'llm_call';
+    traceId: string;
+    iteration: number;
+    finishReason: string;
+    durationMs: number;
+} | {
+    type: 'tool_call';
+    traceId: string;
+    toolName: string;
+    isError: boolean;
+    durationMs: number;
+} | {
+    type: 'pipeline_done';
+    traceId: string;
+    stopReason: string;
+    iterations: number;
+    toolCallCount: number;
+    durationMs: number;
+} | {
+    type: 'pipeline_error';
+    traceId: string;
+    code: string;
+    message: string;
+    durationMs: number;
+} | {
+    type: 'tools_selected';
+    traceId: string;
+    total: number;
+    selected: number;
+    names: string[];
+} | {
+    type: 'rag_translate';
+    traceId: string;
+    original: string;
+    translated: string;
+} | {
+    type: 'warning';
+    traceId: string;
+    message: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/logger/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/logger/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,OAAO;IACtB,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,MAAM,QAAQ,GAChB;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,GACD;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1E;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,GACD;IACE,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB,GACD;IACE,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,GACD;IACE,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,GACD;IACE,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,GACD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/logger/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/logger/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/logger/types.ts"],"names":[],"mappings":""}

package/dist/policy/fallback-llm-call-strategy.d.ts

@@ -0,0 +1,16 @@
+import type { CallOptions, ILlm, ILlmCallStrategy, LlmError, LlmStreamChunk, LlmTool, Message, Result } from '@mcp-abap-adt/llm-agent';
+import type { ILogger } from '../logger/types.js';
+/**
+ * Starts with streaming. On error, logs the cause and retries the same call
+ * via non-streaming. All subsequent calls use non-streaming for this instance.
+ */
+export declare class FallbackLlmCallStrategy implements ILlmCallStrategy {
+    private readonly logger?;
+    private streamingDisabled;
+    private readonly streaming;
+    private readonly nonStreaming;
+    constructor(logger?: ILogger | undefined);
+    call(llm: ILlm, messages: Message[], tools: LlmTool[], options?: CallOptions): AsyncIterable<Result<LlmStreamChunk, LlmError>>;
+    private logFallback;
+}
+//# sourceMappingURL=fallback-llm-call-strategy.d.ts.map

package/dist/policy/fallback-llm-call-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-llm-call-strategy.d.ts","sourceRoot":"","sources":["../../src/policy/fallback-llm-call-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,IAAI,EACJ,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,OAAO,EACP,OAAO,EACP,MAAM,EACP,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAIlD;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAKlD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAJpC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkC;IAC5D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqC;gBAErC,MAAM,CAAC,EAAE,OAAO,YAAA;IAEtC,IAAI,CACT,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;IA4ClD,OAAO,CAAC,WAAW;CAcpB"}

package/dist/policy/fallback-llm-call-strategy.js

@@ -0,0 +1,66 @@
+import { NonStreamingLlmCallStrategy } from './non-streaming-llm-call-strategy.js';
+import { StreamingLlmCallStrategy } from './streaming-llm-call-strategy.js';
+/**
+ * Starts with streaming. On error, logs the cause and retries the same call
+ * via non-streaming. All subsequent calls use non-streaming for this instance.
+ */
+export class FallbackLlmCallStrategy {
+    logger;
+    streamingDisabled = false;
+    streaming = new StreamingLlmCallStrategy();
+    nonStreaming = new NonStreamingLlmCallStrategy();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async *call(llm, messages, tools, options) {
+        if (this.streamingDisabled) {
+            yield* this.nonStreaming.call(llm, messages, tools, options);
+            return;
+        }
+        try {
+            const chunks = [];
+            let hadError = false;
+            for await (const chunk of this.streaming.call(llm, messages, tools, options)) {
+                if (!chunk.ok) {
+                    // Streaming returned a Result error — treat as streaming failure
+                    hadError = true;
+                    this.logFallback(chunk.error.message, chunk.error);
+                    break;
+                }
+                chunks.push(chunk);
+                yield chunk;
+            }
+            if (hadError) {
+                this.streamingDisabled = true;
+                // Retry the same call non-streaming — chunks already yielded are
+                // partial content that the consumer may have streamed to the client.
+                // We yield a reset signal so the consumer can discard partial state.
+                yield { ok: true, value: { content: '', reset: true } };
+                yield* this.nonStreaming.call(llm, messages, tools, options);
+            }
+        }
+        catch (err) {
+            // Streaming threw an exception (e.g. SSE disconnect, network error)
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.logFallback(errMsg, err);
+            this.streamingDisabled = true;
+            yield { ok: true, value: { content: '', reset: true } };
+            yield* this.nonStreaming.call(llm, messages, tools, options);
+        }
+    }
+    logFallback(message, err) {
+        // biome-ignore lint/suspicious/noExplicitAny: ErrorWithCause shape
+        const cause = err?.cause;
+        const causeDetail = cause?.message || cause;
+        const causeCode = cause?.code;
+        const detail = causeDetail
+            ? ` (cause: ${causeDetail}${causeCode ? `, code: ${causeCode}` : ''})`
+            : '';
+        this.logger?.log({
+            type: 'warning',
+            traceId: 'tool-loop',
+            message: `Streaming failed, falling back to non-streaming: ${message}${detail}`,
+        });
+    }
+}
+//# sourceMappingURL=fallback-llm-call-strategy.js.map

package/dist/policy/fallback-llm-call-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-llm-call-strategy.js","sourceRoot":"","sources":["../../src/policy/fallback-llm-call-strategy.ts"],"names":[],"mappings":"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"}

package/dist/policy/index.d.ts

@@ -0,0 +1,4 @@
+export { FallbackLlmCallStrategy } from './fallback-llm-call-strategy.js';
+export { NonStreamingLlmCallStrategy } from './non-streaming-llm-call-strategy.js';
+export { StreamingLlmCallStrategy } from './streaming-llm-call-strategy.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/policy/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/policy/index.js

@@ -0,0 +1,4 @@
+export { FallbackLlmCallStrategy } from './fallback-llm-call-strategy.js';
+export { NonStreamingLlmCallStrategy } from './non-streaming-llm-call-strategy.js';
+export { StreamingLlmCallStrategy } from './streaming-llm-call-strategy.js';
+//# sourceMappingURL=index.js.map

package/dist/policy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/policy/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/policy/non-streaming-llm-call-strategy.d.ts

@@ -0,0 +1,6 @@
+import type { CallOptions, ILlm, ILlmCallStrategy, LlmError, LlmStreamChunk, LlmTool, Message, Result } from '@mcp-abap-adt/llm-agent';
+/** Always uses chat(). Result is yielded as a single chunk. Errors propagate as-is. */
+export declare class NonStreamingLlmCallStrategy implements ILlmCallStrategy {
+    call(llm: ILlm, messages: Message[], tools: LlmTool[], options?: CallOptions): AsyncIterable<Result<LlmStreamChunk, LlmError>>;
+}
+//# sourceMappingURL=non-streaming-llm-call-strategy.d.ts.map

package/dist/policy/non-streaming-llm-call-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-streaming-llm-call-strategy.d.ts","sourceRoot":"","sources":["../../src/policy/non-streaming-llm-call-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,IAAI,EACJ,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,OAAO,EACP,OAAO,EACP,MAAM,EACP,MAAM,yBAAyB,CAAC;AAEjC,uFAAuF;AACvF,qBAAa,2BAA4B,YAAW,gBAAgB;IAC3D,IAAI,CACT,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;CAmBnD"}

package/dist/policy/non-streaming-llm-call-strategy.js

@@ -0,0 +1,21 @@
+/** Always uses chat(). Result is yielded as a single chunk. Errors propagate as-is. */
+export class NonStreamingLlmCallStrategy {
+    async *call(llm, messages, tools, options) {
+        const result = await llm.chat(messages, tools, options);
+        if (!result.ok) {
+            yield result;
+            return;
+        }
+        const response = result.value;
+        yield {
+            ok: true,
+            value: {
+                content: response.content,
+                finishReason: response.finishReason,
+                toolCalls: response.toolCalls,
+                usage: response.usage,
+            },
+        };
+    }
+}
+//# sourceMappingURL=non-streaming-llm-call-strategy.js.map

package/dist/policy/non-streaming-llm-call-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-streaming-llm-call-strategy.js","sourceRoot":"","sources":["../../src/policy/non-streaming-llm-call-strategy.ts"],"names":[],"mappings":"AAWA,uFAAuF;AACvF,MAAM,OAAO,2BAA2B;IACtC,KAAK,CAAC,CAAC,IAAI,CACT,GAAS,EACT,QAAmB,EACnB,KAAgB,EAChB,OAAqB;QAErB,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAExD,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YACf,MAAM,MAAM,CAAC;YACb,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC;QAC9B,MAAM;YACJ,EAAE,EAAE,IAAI;YACR,KAAK,EAAE;gBACL,OAAO,EAAE,QAAQ,CAAC,OAAO;gBACzB,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,SAAS,EAAE,QAAQ,CAAC,SAAS;gBAC7B,KAAK,EAAE,QAAQ,CAAC,KAAK;aACtB;SACF,CAAC;IACJ,CAAC;CACF"}

package/dist/policy/streaming-llm-call-strategy.d.ts

@@ -0,0 +1,6 @@
+import type { CallOptions, ILlm, ILlmCallStrategy, LlmError, LlmStreamChunk, LlmTool, Message, Result } from '@mcp-abap-adt/llm-agent';
+/** Always uses streamChat(). Errors propagate as-is. */
+export declare class StreamingLlmCallStrategy implements ILlmCallStrategy {
+    call(llm: ILlm, messages: Message[], tools: LlmTool[], options?: CallOptions): AsyncIterable<Result<LlmStreamChunk, LlmError>>;
+}
+//# sourceMappingURL=streaming-llm-call-strategy.d.ts.map

package/dist/policy/streaming-llm-call-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-llm-call-strategy.d.ts","sourceRoot":"","sources":["../../src/policy/streaming-llm-call-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,IAAI,EACJ,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,OAAO,EACP,OAAO,EACP,MAAM,EACP,MAAM,yBAAyB,CAAC;AAEjC,wDAAwD;AACxD,qBAAa,wBAAyB,YAAW,gBAAgB;IACxD,IAAI,CACT,GAAG,EAAE,IAAI,EACT,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;CAGnD"}

package/dist/policy/streaming-llm-call-strategy.js

@@ -0,0 +1,7 @@
+/** Always uses streamChat(). Errors propagate as-is. */
+export class StreamingLlmCallStrategy {
+    async *call(llm, messages, tools, options) {
+        yield* llm.streamChat(messages, tools, options);
+    }
+}
+//# sourceMappingURL=streaming-llm-call-strategy.js.map

package/dist/policy/streaming-llm-call-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-llm-call-strategy.js","sourceRoot":"","sources":["../../src/policy/streaming-llm-call-strategy.ts"],"names":[],"mappings":"AAWA,wDAAwD;AACxD,MAAM,OAAO,wBAAwB;IACnC,KAAK,CAAC,CAAC,IAAI,CACT,GAAS,EACT,QAAmB,EACnB,KAAgB,EAChB,OAAqB;QAErB,KAAK,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;CACF"}

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

@@ -0,0 +1,16 @@
+/**
+ * CircuitBreakerEmbedder — IEmbedder decorator that wraps calls with a CircuitBreaker.
+ *
+ * When the circuit is open, calls throw an error rather than hitting the
+ * underlying embedding service.
+ */
+import type { CallOptions, IEmbedder, IEmbedResult } from '@mcp-abap-adt/llm-agent';
+import type { CircuitBreaker } from './circuit-breaker.js';
+export declare class CircuitBreakerEmbedder implements IEmbedder {
+    private readonly inner;
+    readonly breaker: CircuitBreaker;
+    constructor(inner: IEmbedder, breaker: CircuitBreaker);
+    embed(text: string, options?: CallOptions): Promise<IEmbedResult>;
+    embedBatch(texts: string[], options?: CallOptions): Promise<IEmbedResult[]>;
+}
+//# sourceMappingURL=circuit-breaker-embedder.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,47 @@
+/**
+ * CircuitBreakerEmbedder — IEmbedder decorator that wraps calls with a CircuitBreaker.
+ *
+ * When the circuit is open, calls throw an error rather than hitting the
+ * underlying embedding service.
+ */
+import { isBatchEmbedder, RagError } from '@mcp-abap-adt/llm-agent';
+export class CircuitBreakerEmbedder {
+    inner;
+    breaker;
+    constructor(inner, breaker) {
+        this.inner = inner;
+        this.breaker = breaker;
+    }
+    async embed(text, options) {
+        if (!this.breaker.isCallPermitted) {
+            throw new RagError('Embedder circuit breaker is open', 'CIRCUIT_OPEN');
+        }
+        try {
+            const result = await this.inner.embed(text, options);
+            this.breaker.recordSuccess();
+            return result;
+        }
+        catch (err) {
+            this.breaker.recordFailure();
+            throw err;
+        }
+    }
+    async embedBatch(texts, options) {
+        if (!this.breaker.isCallPermitted) {
+            throw new RagError('Embedder circuit breaker is open', 'CIRCUIT_OPEN');
+        }
+        if (!isBatchEmbedder(this.inner)) {
+            throw new RagError('Inner embedder does not support batch embedding', 'EMBED_ERROR');
+        }
+        try {
+            const result = await this.inner.embedBatch(texts, options);
+            this.breaker.recordSuccess();
+            return result;
+        }
+        catch (err) {
+            this.breaker.recordFailure();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=circuit-breaker-embedder.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,19 @@
+/**
+ * CircuitBreakerLlm — ILlm decorator that wraps calls with a CircuitBreaker.
+ *
+ * When the circuit is open, calls return `Result { ok: false, error: LlmError('CIRCUIT_OPEN') }`
+ * without hitting the underlying LLM.
+ */
+import type { ILlm, Message } from '@mcp-abap-adt/llm-agent';
+import { type CallOptions, LlmError, type LlmResponse, type LlmStreamChunk, type LlmTool, type Result } from '@mcp-abap-adt/llm-agent';
+import type { CircuitBreaker } from './circuit-breaker.js';
+export declare class CircuitBreakerLlm implements ILlm {
+    private readonly inner;
+    readonly breaker: CircuitBreaker;
+    healthCheck?: ILlm['healthCheck'];
+    constructor(inner: ILlm, breaker: CircuitBreaker);
+    get model(): string | undefined;
+    chat(messages: Message[], tools?: LlmTool[], options?: CallOptions): Promise<Result<LlmResponse, LlmError>>;
+    streamChat(messages: Message[], tools?: LlmTool[], options?: CallOptions): AsyncIterable<Result<LlmStreamChunk, LlmError>>;
+}
+//# sourceMappingURL=circuit-breaker-llm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker-llm.d.ts","sourceRoot":"","sources":["../../src/resilience/circuit-breaker-llm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EACL,KAAK,WAAW,EAChB,QAAQ,EACR,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,MAAM,EACZ,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,qBAAa,iBAAkB,YAAW,IAAI;IAI1C,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc;IAJlC,WAAW,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;gBAGf,KAAK,EAAE,IAAI,EACnB,OAAO,EAAE,cAAc;IAOlC,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAEK,IAAI,CACR,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,CAAC,EAAE,OAAO,EAAE,EACjB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IAgBlC,UAAU,CACf,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,CAAC,EAAE,OAAO,EAAE,EACjB,OAAO,CAAC,EAAE,WAAW,GACpB,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;CAoCnD"}

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

@@ -0,0 +1,72 @@
+/**
+ * CircuitBreakerLlm — ILlm decorator that wraps calls with a CircuitBreaker.
+ *
+ * When the circuit is open, calls return `Result { ok: false, error: LlmError('CIRCUIT_OPEN') }`
+ * without hitting the underlying LLM.
+ */
+import { LlmError, } from '@mcp-abap-adt/llm-agent';
+export class CircuitBreakerLlm {
+    inner;
+    breaker;
+    healthCheck;
+    constructor(inner, breaker) {
+        this.inner = inner;
+        this.breaker = breaker;
+        if (inner.healthCheck) {
+            this.healthCheck = inner.healthCheck.bind(inner);
+        }
+    }
+    get model() {
+        return this.inner.model;
+    }
+    async chat(messages, tools, options) {
+        if (!this.breaker.isCallPermitted) {
+            return {
+                ok: false,
+                error: new LlmError('Circuit breaker is open', 'CIRCUIT_OPEN'),
+            };
+        }
+        const result = await this.inner.chat(messages, tools, options);
+        if (result.ok) {
+            this.breaker.recordSuccess();
+        }
+        else {
+            this.breaker.recordFailure();
+        }
+        return result;
+    }
+    async *streamChat(messages, tools, options) {
+        if (!this.breaker.isCallPermitted) {
+            yield {
+                ok: false,
+                error: new LlmError('Circuit breaker is open', 'CIRCUIT_OPEN'),
+            };
+            return;
+        }
+        let hadError = false;
+        try {
+            for await (const chunk of this.inner.streamChat(messages, tools, options)) {
+                if (!chunk.ok) {
+                    hadError = true;
+                    this.breaker.recordFailure();
+                    yield chunk;
+                    return;
+                }
+                yield chunk;
+            }
+        }
+        catch (err) {
+            hadError = true;
+            this.breaker.recordFailure();
+            yield {
+                ok: false,
+                error: new LlmError(String(err), 'LLM_ERROR'),
+            };
+            return;
+        }
+        if (!hadError) {
+            this.breaker.recordSuccess();
+        }
+    }
+}
+//# sourceMappingURL=circuit-breaker-llm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker-llm.js","sourceRoot":"","sources":["../../src/resilience/circuit-breaker-llm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAEL,QAAQ,GAKT,MAAM,yBAAyB,CAAC;AAGjC,MAAM,OAAO,iBAAiB;IAIT;IACR;IAJX,WAAW,CAAuB;IAElC,YACmB,KAAW,EACnB,OAAuB;QADf,UAAK,GAAL,KAAK,CAAM;QACnB,YAAO,GAAP,OAAO,CAAgB;QAEhC,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,IAAI,CACR,QAAmB,EACnB,KAAiB,EACjB,OAAqB;QAErB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,OAAO;gBACL,EAAE,EAAE,KAAK;gBACT,KAAK,EAAE,IAAI,QAAQ,CAAC,yBAAyB,EAAE,cAAc,CAAC;aAC/D,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAC/D,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;YACd,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QAC/B,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,CAAC,UAAU,CACf,QAAmB,EACnB,KAAiB,EACjB,OAAqB;QAErB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,MAAM;gBACJ,EAAE,EAAE,KAAK;gBACT,KAAK,EAAE,IAAI,QAAQ,CAAC,yBAAyB,EAAE,cAAc,CAAC;aAC/D,CAAC;YACF,OAAO;QACT,CAAC;QACD,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC;YACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,CAC7C,QAAQ,EACR,KAAK,EACL,OAAO,CACR,EAAE,CAAC;gBACF,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;oBACd,QAAQ,GAAG,IAAI,CAAC;oBAChB,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;oBAC7B,MAAM,KAAK,CAAC;oBACZ,OAAO;gBACT,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,QAAQ,GAAG,IAAI,CAAC;YAChB,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC7B,MAAM;gBACJ,EAAE,EAAE,KAAK;gBACT,KAAK,EAAE,IAAI,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC;aAC9C,CAAC;YACF,OAAO;QACT,CAAC;QACD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QAC/B,CAAC;IACH,CAAC;CACF"}

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

@@ -0,0 +1,36 @@
+/**
+ * Generic Circuit Breaker — three-state pattern (closed → open → half-open).
+ *
+ * - **Closed**: requests pass through; failures are counted.
+ * - **Open**: requests are rejected immediately; after `recoveryWindowMs` the
+ *   breaker transitions to half-open.
+ * - **Half-Open**: a single probe request is allowed. If it succeeds the
+ *   breaker closes; if it fails it re-opens.
+ */
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export interface CircuitBreakerConfig {
+    /** Number of consecutive failures before opening. Default: 5 */
+    failureThreshold?: number;
+    /** Time (ms) to wait before probing again. Default: 30 000 */
+    recoveryWindowMs?: number;
+    /** Optional callback on state changes. */
+    onStateChange?: (from: CircuitState, to: CircuitState) => void;
+}
+export declare class CircuitBreaker {
+    private _state;
+    private failureCount;
+    private openedAt;
+    readonly failureThreshold: number;
+    readonly recoveryWindowMs: number;
+    private readonly onStateChange?;
+    constructor(config?: CircuitBreakerConfig);
+    get state(): CircuitState;
+    /** Record a successful call — resets the breaker to closed. */
+    recordSuccess(): void;
+    /** Record a failed call — may trip the breaker open. */
+    recordFailure(): void;
+    /** Whether the circuit allows requests through. */
+    get isCallPermitted(): boolean;
+    private _transition;
+}
+//# sourceMappingURL=circuit-breaker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/resilience/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0CAA0C;IAC1C,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,KAAK,IAAI,CAAC;CAChE;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,QAAQ,CAAK;IAErB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAGrB;gBAEE,MAAM,GAAE,oBAAyB;IAM7C,IAAI,KAAK,IAAI,YAAY,CAQxB;IAED,+DAA+D;IAC/D,aAAa,IAAI,IAAI;IAOrB,wDAAwD;IACxD,aAAa,IAAI,IAAI;IAWrB,mDAAmD;IACnD,IAAI,eAAe,IAAI,OAAO,CAG7B;IAED,OAAO,CAAC,WAAW;CAOpB"}

package/dist/resilience/circuit-breaker.js

@@ -0,0 +1,60 @@
+/**
+ * Generic Circuit Breaker — three-state pattern (closed → open → half-open).
+ *
+ * - **Closed**: requests pass through; failures are counted.
+ * - **Open**: requests are rejected immediately; after `recoveryWindowMs` the
+ *   breaker transitions to half-open.
+ * - **Half-Open**: a single probe request is allowed. If it succeeds the
+ *   breaker closes; if it fails it re-opens.
+ */
+export class CircuitBreaker {
+    _state = 'closed';
+    failureCount = 0;
+    openedAt = 0;
+    failureThreshold;
+    recoveryWindowMs;
+    onStateChange;
+    constructor(config = {}) {
+        this.failureThreshold = config.failureThreshold ?? 5;
+        this.recoveryWindowMs = config.recoveryWindowMs ?? 30_000;
+        this.onStateChange = config.onStateChange;
+    }
+    get state() {
+        if (this._state === 'open' &&
+            Date.now() - this.openedAt >= this.recoveryWindowMs) {
+            this._transition('half-open');
+        }
+        return this._state;
+    }
+    /** Record a successful call — resets the breaker to closed. */
+    recordSuccess() {
+        if (this._state !== 'closed') {
+            this._transition('closed');
+        }
+        this.failureCount = 0;
+    }
+    /** Record a failed call — may trip the breaker open. */
+    recordFailure() {
+        this.failureCount++;
+        if (this._state === 'half-open' ||
+            this.failureCount >= this.failureThreshold) {
+            this._transition('open');
+            this.openedAt = Date.now();
+        }
+    }
+    /** Whether the circuit allows requests through. */
+    get isCallPermitted() {
+        const s = this.state; // triggers half-open check
+        return s === 'closed' || s === 'half-open';
+    }
+    _transition(to) {
+        if (this._state === to)
+            return;
+        const from = this._state;
+        this._state = to;
+        if (to === 'closed')
+            this.failureCount = 0;
+        this.onStateChange?.(from, to);
+    }
+}
+//# sourceMappingURL=circuit-breaker.js.map