agentfootprint 1.0.0

package/dist/types/adapters/index.d.ts

@@ -0,0 +1,30 @@
+export type { ConversationStore, MemoryConfig } from './memory/types';
+export { InMemoryStore } from './memory/inMemory';
+export { redisStore, dynamoStore, postgresStore } from './memory/stores';
+export type { RedisLike, RedisStoreOptions, DynamoLike, DynamoStoreOptions, PostgresLike, PostgresStoreOptions } from './memory/stores';
+export { MockAdapter, mock } from './mock/MockAdapter';
+export type { MockResponse } from './mock/MockAdapter';
+export { MockRetriever, mockRetriever } from './mock/MockRetriever';
+export type { MockRetrievalResponse } from './mock/MockRetriever';
+export { createAdapterSubflow } from './createAdapterSubflow';
+export type { AdapterSubflowConfig } from './createAdapterSubflow';
+export { mcpToolProvider } from './mcp/mcpToolProvider';
+export type { MCPClient, MCPToolInfo, MCPToolResult, MCPToolProviderOptions, } from './mcp/mcpToolProvider';
+export { a2aRunner } from './a2a/a2aRunner';
+export type { A2AClient, A2AResponse, A2ARunnerOptions } from './a2a/a2aRunner';
+export { AnthropicAdapter } from './anthropic/AnthropicAdapter';
+export type { AnthropicAdapterOptions } from './anthropic/AnthropicAdapter';
+export { OpenAIAdapter } from './openai/OpenAIAdapter';
+export type { OpenAIAdapterOptions } from './openai/OpenAIAdapter';
+export { BedrockAdapter } from './bedrock/BedrockAdapter';
+export type { BedrockAdapterOptions } from './bedrock/BedrockAdapter';
+export { BrowserAnthropicAdapter } from './browser/BrowserAnthropicAdapter';
+export type { BrowserAnthropicAdapterOptions } from './browser/BrowserAnthropicAdapter';
+export { BrowserOpenAIAdapter } from './browser/BrowserOpenAIAdapter';
+export type { BrowserOpenAIAdapterOptions } from './browser/BrowserOpenAIAdapter';
+export { fallbackProvider } from './fallbackProvider';
+export type { FallbackProviderOptions } from './fallbackProvider';
+export { resilientProvider } from './resilientProvider';
+export type { ResilientProviderOptions } from './resilientProvider';
+export { createProvider, resolveProvider, isLLMProvider } from './createProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACzE,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAE,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAGxI,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACpE,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EACV,SAAS,EACT,WAAW,EACX,aAAa,EACb,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,YAAY,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,YAAY,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAGtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,YAAY,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,YAAY,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAGlF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAGpE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/types/adapters/mcp/mcpToolProvider.d.ts

@@ -0,0 +1,41 @@
+/**
+ * mcpToolProvider — wraps an MCP server as a ToolProvider.
+ *
+ * MCP (Model Context Protocol) exposes tools from external servers.
+ * This adapter bridges MCP's tool interface to agentfootprint's ToolProvider,
+ * enabling agents to use MCP tools without knowing the protocol.
+ *
+ * The adapter accepts an MCPClient interface (transport-agnostic).
+ * Users provide their own MCP client implementation — this adapter
+ * only handles the ToolProvider mapping.
+ *
+ * Usage:
+ *   const tools = mcpToolProvider({ client: myMcpClient });
+ *   const agent = Agent.create({ provider }).build();
+ *   // Agent can now call MCP tools
+ */
+import type { ToolProvider } from '../../core';
+/** Minimal MCP client interface. Users bring their own implementation. */
+export interface MCPClient {
+    /** List available tools from the MCP server. */
+    listTools(): Promise<MCPToolInfo[]>;
+    /** Call a tool on the MCP server. */
+    callTool(name: string, args: Record<string, unknown>): Promise<MCPToolResult>;
+}
+export interface MCPToolInfo {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema?: Record<string, unknown>;
+}
+export interface MCPToolResult {
+    readonly content: string;
+    readonly isError?: boolean;
+}
+export interface MCPToolProviderOptions {
+    /** MCP client instance. */
+    readonly client: MCPClient;
+    /** Optional prefix for tool names to avoid collisions. */
+    readonly prefix?: string;
+}
+export declare function mcpToolProvider(options: MCPToolProviderOptions): ToolProvider;
+//# sourceMappingURL=mcpToolProvider.d.ts.map

package/dist/types/adapters/mcp/mcpToolProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpToolProvider.d.ts","sourceRoot":"","sources":["../../../../src/adapters/mcp/mcpToolProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,YAAY,CAAC;AAIpE,0EAA0E;AAC1E,MAAM,WAAW,SAAS;IACxB,gDAAgD;IAChD,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACpC,qCAAqC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC/E;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAID,MAAM,WAAW,sBAAsB;IACrC,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,YAAY,CAwB7E"}

package/dist/types/adapters/memory/inMemory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * InMemoryStore — ConversationStore implementation backed by a plain Map.
+ *
+ * For testing and development only. Data does not survive process restarts.
+ * Use a real backend (Redis, Postgres, DynamoDB) in production.
+ */
+import type { Message } from '../../types/messages';
+import type { ConversationStore } from './types';
+export declare class InMemoryStore implements ConversationStore {
+    private readonly conversations;
+    load(conversationId: string): Message[];
+    save(conversationId: string, messages: Message[]): void;
+    /** Return all conversation IDs currently in store. */
+    ids(): string[];
+    /** Return number of messages stored for a conversation. */
+    size(conversationId: string): number;
+    /** Clear a specific conversation. */
+    delete(conversationId: string): void;
+    /** Clear all stored conversations. */
+    clear(): void;
+}
+//# sourceMappingURL=inMemory.d.ts.map

package/dist/types/adapters/memory/inMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemory.d.ts","sourceRoot":"","sources":["../../../../src/adapters/memory/inMemory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,qBAAa,aAAc,YAAW,iBAAiB;IACrD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgC;IAE9D,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,EAAE;IAKvC,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI;IAKvD,sDAAsD;IACtD,GAAG,IAAI,MAAM,EAAE;IAIf,2DAA2D;IAC3D,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM;IAIpC,qCAAqC;IACrC,MAAM,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAIpC,sCAAsC;IACtC,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/adapters/memory/index.d.ts

@@ -0,0 +1,3 @@
+export type { ConversationStore, MemoryConfig } from './types';
+export { InMemoryStore } from './inMemory';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/adapters/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapters/memory/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/types/adapters/memory/stores.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Memory store adapter factories — consumer brings their own client.
+ *
+ * Zero new dependencies. Each factory wraps the consumer's client instance
+ * into a ConversationStore that implements load() + save().
+ *
+ * @example Redis
+ * ```typescript
+ * import Redis from 'ioredis';
+ * import { redisStore } from 'agentfootprint';
+ *
+ * const store = redisStore(new Redis(), { ttlSeconds: 3600 });
+ * agent.memory({ store, conversationId: 'session-123' });
+ * ```
+ *
+ * @example DynamoDB
+ * ```typescript
+ * import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+ * import { dynamoStore } from 'agentfootprint';
+ *
+ * const store = dynamoStore(new DynamoDBClient({}), { tableName: 'conversations' });
+ * agent.memory({ store, conversationId: 'session-123' });
+ * ```
+ */
+import type { ConversationStore } from './types';
+/**
+ * Duck-typed Redis client — works with ioredis and node-redis v4+.
+ * Uses variadic `set()` for ioredis compat and options object for node-redis v4.
+ */
+export interface RedisLike {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
+}
+export interface RedisStoreOptions {
+    /** Key prefix. Default: 'agentfp:conv:' */
+    prefix?: string;
+    /** TTL in seconds. Default: no expiry. */
+    ttlSeconds?: number;
+}
+/**
+ * Create a ConversationStore backed by Redis.
+ * Consumer provides their own Redis client (ioredis, redis, etc.).
+ */
+export declare function redisStore(client: RedisLike, options?: RedisStoreOptions): ConversationStore;
+/**
+ * Duck-typed DynamoDB adapter — consumer provides get/put functions.
+ *
+ * This avoids depending on specific AWS SDK versions or Command class imports.
+ * The consumer wraps their own client:
+ *
+ * ```typescript
+ * import { DynamoDBDocumentClient, GetCommand, PutCommand } from '@aws-sdk/lib-dynamodb';
+ *
+ * const docClient = DynamoDBDocumentClient.from(new DynamoDBClient({}));
+ * const store = dynamoStore({
+ *   get: async (table, key) => {
+ *     const result = await docClient.send(new GetCommand({ TableName: table, Key: key }));
+ *     return result.Item ?? null;
+ *   },
+ *   put: async (table, item) => {
+ *     await docClient.send(new PutCommand({ TableName: table, Item: item }));
+ *   },
+ * }, { tableName: 'conversations' });
+ * ```
+ */
+export interface DynamoLike {
+    get(tableName: string, key: Record<string, unknown>): Promise<Record<string, unknown> | null>;
+    put(tableName: string, item: Record<string, unknown>): Promise<void>;
+}
+export interface DynamoStoreOptions {
+    /** DynamoDB table name. Required. */
+    tableName: string;
+    /** Partition key name. Default: 'id'. */
+    partitionKey?: string;
+}
+/**
+ * Create a ConversationStore backed by DynamoDB.
+ * Consumer provides a thin wrapper around their DynamoDB client.
+ */
+export declare function dynamoStore(client: DynamoLike, options: DynamoStoreOptions): ConversationStore;
+/** Duck-typed Postgres client — works with pg (node-postgres) or any client with query(text, values). */
+export interface PostgresLike {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: unknown[];
+    }>;
+}
+export interface PostgresStoreOptions {
+    /** Table name. Default: 'conversations'. */
+    tableName?: string;
+}
+export declare function postgresStore(client: PostgresLike, options?: PostgresStoreOptions): ConversationStore;
+//# sourceMappingURL=stores.d.ts.map

package/dist/types/adapters/memory/stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../../../src/adapters/memory/stores.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAKjD;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAkC5F;AAID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IAC9F,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,CA2B9F;AAID,yGAAyG;AACzG,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAUD,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,iBAAiB,CA2BrG"}

package/dist/types/adapters/memory/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Memory adapter types — ConversationStore interface for persistent conversation history.
+ *
+ * ConversationStore is the persistence adapter: it defines WHERE messages are stored.
+ * Implement this interface to plug in Redis, Postgres, DynamoDB, localStorage,
+ * or any other backend. The library ships with InMemoryStore for testing.
+ *
+ * This is the memory equivalent of LLMProvider — same adapter-swap story:
+ *   - Swap mock ↔ real adapter without changing agent logic
+ *   - Swap InMemoryStore ↔ RedisStore without touching flowchart stages
+ */
+import type { Message } from '../../types/messages';
+import type { MessageStrategy } from '../../core/providers';
+/**
+ * Persistence adapter for conversation message history.
+ *
+ * Implement this to plug in any storage backend:
+ *   - `InMemoryStore` (built-in, for testing)
+ *   - Redis: `store.save(id, msgs)` → SETEX key ttl JSON.stringify(msgs)
+ *   - Postgres: INSERT OR REPLACE INTO conversations ...
+ *   - DynamoDB: PutItem with conversationId as partition key
+ *   - localStorage: localStorage.setItem(id, JSON.stringify(msgs))
+ *
+ * Both methods can be sync or async. The PrepareMemory stage awaits load().
+ * The CommitMemory stage fires save() without awaiting (non-blocking).
+ */
+export interface ConversationStore {
+    /**
+     * Load stored messages for a conversation.
+     * Returns empty array (or null) if no history exists for this conversationId.
+     * PrepareMemory treats null the same as an empty array — safe to return either.
+     */
+    load(conversationId: string): Message[] | null | Promise<Message[] | null>;
+    /**
+     * Save messages for a conversation (replaces existing).
+     * Called fire-and-forget by CommitMemory — errors should be caught internally.
+     */
+    save(conversationId: string, messages: Message[]): void | Promise<void>;
+}
+/**
+ * Configuration passed to Agent.memory().
+ *
+ * ```typescript
+ * const store = new InMemoryStore();
+ *
+ * const agent = Agent.create({ provider: llm })
+ *   .system('You are helpful.')
+ *   .memory({
+ *     store,
+ *     conversationId: 'conv-123',
+ *     strategy: slidingWindow({ maxMessages: 20 }),
+ *   })
+ *   .build();
+ * ```
+ */
+export interface MemoryConfig {
+    /** Persistence adapter — where messages are stored. */
+    readonly store: ConversationStore;
+    /**
+     * Unique identifier for this conversation.
+     * Use a stable ID (user ID, session ID, thread ID) so history persists
+     * across multiple Agent.run() calls or server restarts.
+     */
+    readonly conversationId: string;
+    /**
+     * Optional message strategy — how history is trimmed before each LLM call.
+     * If omitted, full untruncated history is used.
+     *
+     * Recommended: pair with slidingWindow() or charBudget() to avoid
+     * exceeding the LLM's context window on long conversations.
+     */
+    readonly strategy?: MessageStrategy;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/adapters/memory/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/adapters/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI5D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IAE3E;;;OAGG;IACH,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzE;AAID;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAElC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAEhC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAC;CACrC"}

package/dist/types/adapters/mock/MockAdapter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MockAdapter — scripted LLM responses for $0 testing.
+ *
+ * Same flowchart, swap the adapter, zero code changes.
+ * Tests exercise the exact same control flow as production.
+ *
+ * Usage:
+ *   import { mock } from 'agentfootprint';
+ *   const model = mock([
+ *     { content: 'Let me search.', toolCalls: [{ id: '1', name: 'search', arguments: { q: 'test' } }] },
+ *     { content: 'The answer is 42.' },
+ *   ]);
+ */
+import type { LLMProvider, LLMResponse, LLMCallOptions, Message, ToolCall } from '../../types';
+export interface MockResponse {
+    readonly content: string;
+    readonly toolCalls?: ToolCall[];
+    readonly usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    readonly model?: string;
+}
+export declare class MockAdapter implements LLMProvider {
+    private responses;
+    private callIndex;
+    private readonly calls;
+    constructor(responses: MockResponse[]);
+    chat(messages: Message[], options?: LLMCallOptions): Promise<LLMResponse>;
+    /** How many times chat() was called. */
+    getCallCount(): number;
+    /** Get the messages sent in a specific call (0-indexed). */
+    getCall(index: number): {
+        messages: Message[];
+        options?: LLMCallOptions;
+    } | undefined;
+    /** Get all calls for assertion. */
+    getAllCalls(): ReadonlyArray<{
+        messages: Message[];
+        options?: LLMCallOptions;
+    }>;
+    /** Reset call history (keep responses). */
+    reset(): void;
+}
+/**
+ * Factory function for creating a mock model.
+ *
+ *   const model = mock([{ content: 'Hello!' }]);
+ */
+export declare function mock(responses: MockResponse[]): MockAdapter;
+//# sourceMappingURL=MockAdapter.d.ts.map

package/dist/types/adapters/mock/MockAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockAdapter.d.ts","sourceRoot":"","sources":["../../../../src/adapters/mock/MockAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE/F,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,WAAY,YAAW,WAAW;IAC7C,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgE;gBAE1E,SAAS,EAAE,YAAY,EAAE;IAI/B,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC;IAsB/E,wCAAwC;IACxC,YAAY,IAAI,MAAM;IAItB,4DAA4D;IAC5D,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,cAAc,CAAA;KAAE,GAAG,SAAS;IAIrF,mCAAmC;IACnC,WAAW,IAAI,aAAa,CAAC;QAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,cAAc,CAAA;KAAE,CAAC;IAI/E,2CAA2C;IAC3C,KAAK,IAAI,IAAI;CAId;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,WAAW,CAE3D"}

package/dist/types/adapters/mock/MockRetriever.d.ts

@@ -0,0 +1,43 @@
+/**
+ * MockRetriever — scripted retrieval responses for $0 testing.
+ *
+ * Same flowchart, swap the retriever, zero code changes.
+ *
+ * Usage:
+ *   import { mockRetriever } from 'agentfootprint';
+ *   const retriever = mockRetriever([
+ *     { chunks: [{ content: 'Relevant doc', score: 0.95 }] },
+ *   ]);
+ */
+import type { RetrieverProvider, RetrievalResult, RetrieveOptions, RetrievalChunk } from '../../types';
+export interface MockRetrievalResponse {
+    readonly chunks: RetrievalChunk[];
+}
+export declare class MockRetriever implements RetrieverProvider {
+    private responses;
+    private callIndex;
+    private readonly calls;
+    constructor(responses: MockRetrievalResponse[]);
+    retrieve(query: string, options?: RetrieveOptions): Promise<RetrievalResult>;
+    /** How many times retrieve() was called. */
+    getCallCount(): number;
+    /** Get a specific call (0-indexed). */
+    getCall(index: number): {
+        query: string;
+        options?: RetrieveOptions;
+    } | undefined;
+    /** Get all calls for assertion. */
+    getAllCalls(): ReadonlyArray<{
+        query: string;
+        options?: RetrieveOptions;
+    }>;
+    /** Reset call history (keep responses). */
+    reset(): void;
+}
+/**
+ * Factory function for creating a mock retriever.
+ *
+ *   const retriever = mockRetriever([{ chunks: [{ content: 'doc', score: 0.9 }] }]);
+ */
+export declare function mockRetriever(responses: MockRetrievalResponse[]): MockRetriever;
+//# sourceMappingURL=MockRetriever.d.ts.map

package/dist/types/adapters/mock/MockRetriever.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockRetriever.d.ts","sourceRoot":"","sources":["../../../../src/adapters/mock/MockRetriever.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,cAAc,EACf,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;CACnC;AAED,qBAAa,aAAc,YAAW,iBAAiB;IACrD,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2D;gBAErE,SAAS,EAAE,qBAAqB,EAAE;IAIxC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAmBlF,4CAA4C;IAC5C,YAAY,IAAI,MAAM;IAItB,uCAAuC;IACvC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,eAAe,CAAA;KAAE,GAAG,SAAS;IAIhF,mCAAmC;IACnC,WAAW,IAAI,aAAa,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,eAAe,CAAA;KAAE,CAAC;IAI1E,2CAA2C;IAC3C,KAAK,IAAI,IAAI;CAId;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,qBAAqB,EAAE,GAAG,aAAa,CAE/E"}

package/dist/types/adapters/openai/OpenAIAdapter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * OpenAIAdapter — wraps the openai SDK as an LLMProvider.
+ *
+ * Requires: npm install openai
+ *
+ * Also works with OpenAI-compatible APIs (Ollama, Together, Groq, etc.)
+ * by setting the baseURL option.
+ *
+ * Features:
+ *   - Full chat() + chatStream() support
+ *   - Multi-modal content (text, images via URL)
+ *   - AbortSignal passthrough for cancellation
+ *   - Normalized LLMError for uniform error handling
+ *
+ * Usage:
+ *   import { OpenAIAdapter } from 'agentfootprint';
+ *   const provider = new OpenAIAdapter({ model: 'gpt-4o' });
+ *
+ *   // Ollama (OpenAI-compatible):
+ *   const ollama = new OpenAIAdapter({
+ *     model: 'llama3',
+ *     baseURL: 'http://localhost:11434/v1',
+ *   });
+ */
+import type { LLMProvider, LLMResponse, LLMCallOptions, LLMStreamChunk, Message } from '../../types';
+export interface OpenAIAdapterOptions {
+    /** Model ID (e.g., 'gpt-4o', 'gpt-4o-mini'). */
+    readonly model: string;
+    /** API key. Defaults to OPENAI_API_KEY env var. */
+    readonly apiKey?: string;
+    /** Base URL for OpenAI-compatible APIs (Ollama, Together, Groq). */
+    readonly baseURL?: string;
+    /** Max tokens in response. */
+    readonly maxTokens?: number;
+    /** @internal Pre-built client for testing. Skips SDK import. */
+    readonly _client?: unknown;
+}
+export declare class OpenAIAdapter implements LLMProvider {
+    private readonly client;
+    private readonly model;
+    private readonly defaultMaxTokens?;
+    constructor(options: OpenAIAdapterOptions);
+    chat(messages: Message[], options?: LLMCallOptions): Promise<LLMResponse>;
+    chatStream(messages: Message[], options?: LLMCallOptions): AsyncIterable<LLMStreamChunk>;
+    private buildParams;
+}
+//# sourceMappingURL=OpenAIAdapter.d.ts.map

package/dist/types/adapters/openai/OpenAIAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAIAdapter.d.ts","sourceRoot":"","sources":["../../../../src/adapters/openai/OpenAIAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,cAAc,EACd,cAAc,EACd,OAAO,EAKR,MAAM,aAAa,CAAC;AAyGrB,MAAM,WAAW,oBAAoB;IACnC,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,qBAAa,aAAc,YAAW,WAAW;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAS;gBAE/B,OAAO,EAAE,oBAAoB;IAuBnC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC;IAaxE,UAAU,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,aAAa,CAAC,cAAc,CAAC;IA0E/F,OAAO,CAAC,WAAW;CA0BpB"}

package/dist/types/adapters/resilientProvider.d.ts

@@ -0,0 +1,33 @@
+/**
+ * resilientProvider — fallback + circuit breaker in one call.
+ *
+ * Combines fallbackProvider() with per-provider CircuitBreaker instances.
+ * Each provider gets its own breaker. When a provider trips its breaker,
+ * it's skipped instantly (no wasted latency on known-down providers).
+ *
+ * This addresses the "sequential" con of fallbackProvider — with circuit
+ * breakers, a tripped provider is skipped in O(1) instead of waiting
+ * for it to timeout.
+ *
+ * Usage:
+ *   const provider = resilientProvider([
+ *     new AnthropicAdapter({ model: 'claude-sonnet-4-20250514' }),
+ *     new OpenAIAdapter({ model: 'gpt-4o' }),
+ *     new OpenAIAdapter({ model: 'llama3', baseURL: 'http://localhost:11434/v1' }),
+ *   ], {
+ *     circuitBreaker: { threshold: 3, resetAfterMs: 30_000 },
+ *     onFallback: (from, to, err) => console.warn('Switching provider', from, '→', to),
+ *   });
+ */
+import type { LLMProvider } from '../types/llm';
+import { CircuitBreaker } from '../compositions/withCircuitBreaker';
+import type { CircuitBreakerOptions } from '../compositions/withCircuitBreaker';
+import type { FallbackProviderOptions } from './fallbackProvider';
+export interface ResilientProviderOptions extends FallbackProviderOptions {
+    /** Circuit breaker config — applied per provider. Default: threshold=3, resetAfterMs=30000. */
+    circuitBreaker?: CircuitBreakerOptions;
+}
+export declare function resilientProvider(providers: readonly LLMProvider[], options?: ResilientProviderOptions): LLMProvider & {
+    breakers: CircuitBreaker[];
+};
+//# sourceMappingURL=resilientProvider.d.ts.map

package/dist/types/adapters/resilientProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resilientProvider.d.ts","sourceRoot":"","sources":["../../../src/adapters/resilientProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAA+C,MAAM,cAAc,CAAC;AAE7F,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,MAAM,WAAW,wBAAyB,SAAQ,uBAAuB;IACvE,+FAA+F;IAC/F,cAAc,CAAC,EAAE,qBAAqB,CAAC;CACxC;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,WAAW,EAAE,EACjC,OAAO,CAAC,EAAE,wBAAwB,GACjC,WAAW,GAAG;IAAE,QAAQ,EAAE,cAAc,EAAE,CAAA;CAAE,CAwE9C"}

package/dist/types/agent.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Agent configuration and result types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=agent.js.map

package/dist/types/agent.js.map

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

package/dist/types/compositions/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * compositions/ — Orchestration wrappers composed from existing primitives.
+ *
+ * These are NOT new concepts — they wrap RunnerLike with cross-cutting
+ * concerns (retry, fallback, circuit breaker) without changing core.
+ */
+export { withRetry } from './withRetry';
+export type { RetryOptions } from './withRetry';
+export { withFallback } from './withFallback';
+export type { FallbackOptions } from './withFallback';
+export { withCircuitBreaker, CircuitBreaker } from './withCircuitBreaker';
+export type { CircuitBreakerOptions, CircuitState } from './withCircuitBreaker';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/compositions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/compositions/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC1E,YAAY,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/types/compositions/withCircuitBreaker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * withCircuitBreaker — wraps a RunnerLike with circuit breaker protection.
+ *
+ * Tracks consecutive failures. After `threshold` failures, the circuit
+ * opens and all subsequent calls fail immediately (fast-fail) until
+ * `resetAfterMs` has elapsed, at which point a single probe call is
+ * allowed through (half-open state).
+ *
+ * States:
+ *   CLOSED  → normal operation, counting failures
+ *   OPEN    → fast-fail, no calls to runner
+ *   HALF_OPEN → one probe call allowed; success → CLOSED, failure → OPEN
+ *
+ * Usage:
+ *   const protected = withCircuitBreaker(fragileAgent, {
+ *     threshold: 5,
+ *     resetAfterMs: 30_000,
+ *   });
+ */
+import type { RunnerLike } from '../types/multiAgent';
+export type CircuitState = 'closed' | 'open' | 'half_open';
+export interface CircuitBreakerOptions {
+    /** Number of consecutive failures before opening. Default: 5. */
+    readonly threshold?: number;
+    /** How long to wait (ms) before trying a probe call. Default: 30000. */
+    readonly resetAfterMs?: number;
+}
+export declare class CircuitBreaker {
+    private state;
+    private failures;
+    private lastFailureTime;
+    private readonly threshold;
+    private readonly resetAfterMs;
+    constructor(options?: CircuitBreakerOptions);
+    getState(): CircuitState;
+    recordSuccess(): void;
+    recordFailure(): void;
+    reset(): void;
+}
+export declare function withCircuitBreaker(runner: RunnerLike, options?: CircuitBreakerOptions): RunnerLike & {
+    breaker: CircuitBreaker;
+};
+//# sourceMappingURL=withCircuitBreaker.d.ts.map

package/dist/types/compositions/withCircuitBreaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withCircuitBreaker.d.ts","sourceRoot":"","sources":["../../../src/compositions/withCircuitBreaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAE1B,OAAO,GAAE,qBAA0B;IAK/C,QAAQ,IAAI,YAAY;IASxB,aAAa,IAAI,IAAI;IAKrB,aAAa,IAAI,IAAI;IAQrB,KAAK,IAAI,IAAI;CAKd;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,qBAA0B,GAClC,UAAU,GAAG;IAAE,OAAO,EAAE,cAAc,CAAA;CAAE,CA0B1C"}

package/dist/types/compositions/withFallback.d.ts

@@ -0,0 +1,17 @@
+/**
+ * withFallback — wraps a primary RunnerLike with a fallback.
+ *
+ * If the primary runner throws, the fallback runner is called instead.
+ * Useful for degraded-mode patterns (e.g., expensive LLM → cheap LLM).
+ *
+ * Usage:
+ *   const safe = withFallback(gpt4Agent, gpt35Agent);
+ *   const result = await safe.run('Hello');
+ */
+import type { RunnerLike } from '../types/multiAgent';
+export interface FallbackOptions {
+    /** Optional predicate — use fallback only if this returns true for the error. */
+    readonly shouldFallback?: (error: unknown) => boolean;
+}
+export declare function withFallback(primary: RunnerLike, fallback: RunnerLike, options?: FallbackOptions): RunnerLike;
+//# sourceMappingURL=withFallback.d.ts.map

package/dist/types/compositions/withFallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFallback.d.ts","sourceRoot":"","sources":["../../../src/compositions/withFallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,WAAW,eAAe;IAC9B,iFAAiF;IACjF,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACvD;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,UAAU,EACnB,QAAQ,EAAE,UAAU,EACpB,OAAO,GAAE,eAAoB,GAC5B,UAAU,CAgBZ"}

package/dist/types/compositions/withRetry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * withRetry — wraps a RunnerLike with retry logic.
+ *
+ * On failure, retries up to maxRetries times with configurable backoff.
+ * Respects AbortSignal for cancellation during wait periods.
+ *
+ * Usage:
+ *   const reliable = withRetry(unreliableAgent, {
+ *     maxRetries: 3,
+ *     backoffMs: 1000,
+ *     backoffMultiplier: 2,
+ *   });
+ *   const result = await reliable.run('Hello');
+ */
+import type { RunnerLike } from '../types/multiAgent';
+export interface RetryOptions {
+    /** Maximum number of retries after the initial attempt. Default: 3. */
+    readonly maxRetries?: number;
+    /** Initial backoff delay in milliseconds. Default: 0 (no delay). */
+    readonly backoffMs?: number;
+    /** Multiply backoff by this factor after each retry. Default: 1 (constant). */
+    readonly backoffMultiplier?: number;
+    /** Optional predicate — retry only if this returns true for the error. */
+    readonly shouldRetry?: (error: unknown) => boolean;
+}
+export declare function withRetry(runner: RunnerLike, options?: RetryOptions): RunnerLike;
+//# sourceMappingURL=withRetry.d.ts.map

package/dist/types/compositions/withRetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRetry.d.ts","sourceRoot":"","sources":["../../../src/compositions/withRetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,0EAA0E;IAC1E,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACpD;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,YAAiB,GAAG,UAAU,CAmCpF"}