agentfootprint 1.22.0 → 2.0.1

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

@@ -0,0 +1,65 @@
+/**
+ * agentfootprint/resilience — provider decorators for production reliability.
+ *
+ * Three composable wrappers around `LLMProvider`. Each preserves the
+ * `LLMProvider` interface (drop-in replacement) and stacks freely:
+ *
+ *   const provider = withRetry(
+ *     fallbackProvider(
+ *       anthropic({ apiKey }),
+ *       openai({ apiKey }),
+ *     ),
+ *     { maxAttempts: 5 },
+ *   );
+ *
+ * Reads as: try anthropic; on failure fall back to openai; the whole
+ * chain is wrapped in retry with 5 attempts.
+ *
+ * ─── 7-panel design review (2026-04-28) ────────────────────────────
+ *
+ *   LLM-AI system design   ✓ Decorator pattern around the existing
+ *                            `LLMProvider` port — no new contract.
+ *                            Stacks naturally; observation hooks
+ *                            (`onRetry`, `onFallback`) keep the
+ *                            recorder ecosystem informed.
+ *   Performance            ✓ Zero overhead on success path (one
+ *                            `try/await` per call). Backoff delays
+ *                            use AbortSignal-aware sleep — no busy
+ *                            wait, no leaked timers.
+ *   Scalability            ✓ Per-call state only. Composition is
+ *                            constant-time per attempt; chain depth
+ *                            doesn't grow runtime cost.
+ *   Research alignment     ✓ Right-fold of `withFallback` matches
+ *                            the standard chain-of-responsibility
+ *                            shape. No exotic resumption — once a
+ *                            stream yields, it commits.
+ *   Flexibility            ✓ Predicates (`shouldRetry`,
+ *                            `shouldFallback`) and hooks
+ *                            (`onRetry`, `onFallback`) make every
+ *                            policy decision overridable. Default
+ *                            policies match common real-world signals
+ *                            (4xx skip, 429 retry, AbortError pass).
+ *   Abstraction-modular    ✓ Three primitives, one purpose each.
+ *                            `fallbackProvider` is sugar over chained
+ *                            `withFallback`. No surprises.
+ *   Software engineering   ✓ Pure decorators — no shared state.
+ *                            Every option has a documented default.
+ *                            Tests cover unit + scenario + integration
+ *                            + property + security + performance + ROI.
+ *
+ * ─── 7-pattern test coverage ───────────────────────────────────────
+ *
+ *   Unit         test/resilience/unit/withRetry.test.ts
+ *                test/resilience/unit/withFallback.test.ts
+ *                test/resilience/unit/fallbackProvider.test.ts
+ *   Scenario     resilience-patterns.test.ts → "production recipes"
+ *   Integration  resilience-patterns.test.ts → "Agent + resilient provider"
+ *   Property     resilience-patterns.test.ts → "invariants"
+ *   Security     resilience-patterns.test.ts → "hostile inputs"
+ *   Performance  resilience-patterns.test.ts → "performance"
+ *   ROI          resilience-patterns.test.ts → "realistic SLO budgets"
+ */
+export { withRetry, type WithRetryOptions } from './withRetry.js';
+export { withFallback, type WithFallbackOptions } from './withFallback.js';
+export { fallbackProvider, type FallbackProviderOptions } from './fallbackProvider.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/resilience/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC"}

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

@@ -0,0 +1,46 @@
+/**
+ * withFallback — provider decorator that falls back to a secondary
+ * on error.
+ *
+ * Pattern: Decorator (GoF) — composes two `LLMProvider`s into one.
+ * Role:    Outer ring (Hexagonal). Stacks with `withRetry`:
+ *          `withRetry(withFallback(primary, fallback))` first retries
+ *          the primary, then on exhaustion falls back to the secondary.
+ *
+ * Common pairings:
+ *   • Anthropic primary, OpenAI fallback (vendor outage tolerance)
+ *   • Real provider primary, Mock fallback (degrade gracefully in dev)
+ *   • Premium model primary, cheaper model fallback (cost ceiling)
+ *
+ * `stream()` falls back too — if the primary's stream errors before
+ * yielding any chunks, we restart on the fallback. Once the primary
+ * has yielded chunks the stream is committed — fallback would
+ * duplicate the partial output.
+ */
+import type { LLMProvider } from '../adapters/types.js';
+export interface WithFallbackOptions {
+    /**
+     * Predicate to decide whether an error from the primary should
+     * trigger fallback. Default: every error except AbortError.
+     * Override to gate on specific status codes or error types.
+     */
+    readonly shouldFallback?: (error: unknown) => boolean;
+    /**
+     * Hook invoked when the primary fails and we're about to call the
+     * fallback. Useful for emitting `agentfootprint.resilience.fallback`.
+     */
+    readonly onFallback?: (error: unknown) => void;
+}
+/**
+ * Wrap a primary provider with a fallback. Tries primary first; on
+ * error matching the policy, calls the fallback.
+ *
+ * @example
+ *   const provider = withFallback(
+ *     anthropic({ apiKey: A }),
+ *     openai({ apiKey: O }),
+ *     { onFallback: (err) => console.warn('primary failed, falling back:', err) },
+ *   );
+ */
+export declare function withFallback(primary: LLMProvider, fallback: LLMProvider, options?: WithFallbackOptions): LLMProvider;
+//# sourceMappingURL=withFallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withFallback.d.ts","sourceRoot":"","sources":["../../../src/resilience/withFallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAY,WAAW,EAA2B,MAAM,sBAAsB,CAAC;AAE3F,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IACtD;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAChD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,WAAW,EACrB,OAAO,GAAE,mBAAwB,GAChC,WAAW,CA6Cb"}

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

@@ -0,0 +1,54 @@
+/**
+ * withRetry — provider decorator that retries failed calls.
+ *
+ * Pattern: Decorator (GoF) — wraps an `LLMProvider` and adds retry
+ *          policy without changing its interface.
+ * Role:    Outer ring (Hexagonal). Composable: `withRetry(withFallback(...))`.
+ *
+ * Retries `complete()` on transient failures with exponential backoff.
+ * `stream()` is delegated as-is — once tokens start flowing the
+ * pipeline is stateful and cannot safely be restarted. If you need
+ * retry semantics for streaming, fall back to `complete()` or
+ * implement custom resumability at the consumer.
+ *
+ * Default policy:
+ *   • maxAttempts: 3 (initial + 2 retries)
+ *   • backoff:     exponential — 200ms, 400ms, 800ms
+ *   • shouldRetry: rejects 4xx-class errors (client mistakes don't
+ *                  benefit from retry) and AbortError; retries 5xx,
+ *                  network errors, and unknown shapes.
+ */
+import type { LLMProvider } from '../adapters/types.js';
+export interface WithRetryOptions {
+    /** Total attempts including the first. Default 3. Must be >= 1. */
+    readonly maxAttempts?: number;
+    /** Initial delay in ms before the first retry. Default 200. */
+    readonly initialDelayMs?: number;
+    /** Multiplier between attempts. Default 2 (200ms → 400ms → 800ms). */
+    readonly backoffFactor?: number;
+    /** Maximum delay cap in ms. Default 10_000. */
+    readonly maxDelayMs?: number;
+    /**
+     * Predicate to decide whether an error is worth retrying. Default
+     * skips AbortError + HTTP 4xx; retries everything else. Override
+     * to add provider-specific signals (e.g., 429 with Retry-After).
+     */
+    readonly shouldRetry?: (error: unknown, attempt: number) => boolean;
+    /**
+     * Hook invoked before each retry. Useful for logging or
+     * `agentfootprint.resilience.retry` emit. Receives the attempt
+     * number that's about to start (so attempt 2 = first retry).
+     */
+    readonly onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
+}
+/**
+ * Wrap a provider so its `complete()` retries transient failures.
+ *
+ * @example
+ *   const robust = withRetry(anthropic({ apiKey }), {
+ *     maxAttempts: 5,
+ *     onRetry: (err, attempt, ms) => console.warn(`retry ${attempt} in ${ms}ms`, err),
+ *   });
+ */
+export declare function withRetry(provider: LLMProvider, options?: WithRetryOptions): LLMProvider;
+//# sourceMappingURL=withRetry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withRetry.d.ts","sourceRoot":"","sources":["../../../src/resilience/withRetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAY,WAAW,EAA2B,MAAM,sBAAsB,CAAC;AAE3F,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,sEAAsE;IACtE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,+CAA+C;IAC/C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IACpE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CAqC5F"}

package/dist/types/stream.d.ts

@@ -0,0 +1,112 @@
+/**
+ * agentfootprint/stream — agent events → Server-Sent Events helpers.
+ *
+ * Pattern: Adapter (event stream → SSE wire format).
+ * Role:    Outer ring. Subscribes to a `Runner`'s `EventDispatcher`
+ *          and yields SSE-formatted strings. Drop into any HTTP
+ *          framework that accepts an async iterable response body
+ *          (Fetch Response, Express res.write, Hono streaming, etc.).
+ * Emits:   N/A — observes only.
+ *
+ * ─── 7-panel design review (2026-04-28) ─────────────────────────────
+ *
+ *   LLM-AI system design   ✓ One-line-per-event SSE format. Each
+ *                            event = one observation; each chunk
+ *                            includes the `runtimeStageId` for
+ *                            cross-view binding.
+ *   Performance            ✓ AsyncIterable<string> — no buffering;
+ *                            yields each event as it arrives. Stops
+ *                            naturally when the run completes.
+ *   Scalability            ✓ Per-run instance. No shared state;
+ *                            many concurrent SSE streams safe.
+ *   Research alignment     ✓ Standard SSE wire format
+ *                            (text/event-stream). Browsers'
+ *                            native EventSource API consumes directly.
+ *   Flexibility            ✓ `format` option for full event payload
+ *                            vs slim text-only mode (chat UIs that
+ *                            only want token deltas). `filter`
+ *                            predicate gates events.
+ *   Abstraction-modular    ✓ One function (`toSSE`) + one class
+ *                            (`SSEFormatter`); class is sugar for
+ *                            consumers who prefer .pipeTo() shape.
+ *   Software engineering   ✓ Pure observer. No global state. Tests
+ *                            cover unit + scenario + property +
+ *                            security + performance.
+ *
+ * ─── 7-pattern test coverage ────────────────────────────────────────
+ *
+ *   See `test/stream/unit/SSEFormatter.test.ts`.
+ */
+import type { AgentfootprintEvent } from './events/registry.js';
+import type { RunnerBase } from './core/RunnerBase.js';
+/**
+ * Hand the runner this iterable's caller before calling `runner.run()`.
+ * Yields SSE-formatted strings until the run finishes (success, error,
+ * or pause). Each event becomes:
+ *
+ *   event: <event name>
+ *   data: <JSON payload>
+ *   <blank line>
+ *
+ * @example
+ *   // Express
+ *   app.post('/agent', async (req, res) => {
+ *     res.setHeader('content-type', 'text/event-stream');
+ *     for await (const chunk of toSSE(agent)) {
+ *       res.write(chunk);
+ *     }
+ *     res.end();
+ *     // (in parallel: await agent.run(req.body))
+ *   });
+ */
+export interface ToSSEOptions {
+    /**
+     * Filter predicate — return false to skip an event. Default: all events.
+     * Common: `event => event.type.startsWith('agentfootprint.stream.')`
+     * for a token-only feed.
+     */
+    readonly filter?: (event: AgentfootprintEvent) => boolean;
+    /**
+     * Output shape:
+     *   - 'full' (default) — each event is JSON-serialized verbatim.
+     *   - 'text' — only `agentfootprint.stream.token.content` is yielded,
+     *     in plain text form (no event/data prefix). Useful for piping
+     *     directly into a chat UI.
+     */
+    readonly format?: 'full' | 'text';
+    /**
+     * Custom event name extractor. By default `event.type` is used.
+     * Useful for SSE consumers that want their own naming.
+     */
+    readonly eventName?: (event: AgentfootprintEvent) => string;
+    /**
+     * Heartbeat interval in ms. SSE connections through proxies/load
+     * balancers often die after ~30s of silence; emit `: ping` comments
+     * at this interval. Default 0 (disabled).
+     */
+    readonly heartbeatMs?: number;
+}
+/**
+ * Subscribe to a runner's `EventDispatcher` and yield SSE-formatted
+ * strings until the run completes.
+ */
+export declare function toSSE<TIn, TOut>(runner: RunnerBase<TIn, TOut>, options?: ToSSEOptions): AsyncIterable<string>;
+/**
+ * Class form for consumers who prefer `new SSEFormatter(runner).stream()`.
+ * Identical behavior to `toSSE(runner)` — pick by preference.
+ */
+export declare class SSEFormatter<TIn = unknown, TOut = unknown> {
+    private readonly runner;
+    private readonly options;
+    constructor(runner: RunnerBase<TIn, TOut>, options?: ToSSEOptions);
+    /** Async iterable of SSE chunks. Consume with `for await`. */
+    stream(): AsyncIterable<string>;
+}
+/**
+ * Format any JSON-able payload as a single SSE event chunk.
+ *
+ * Useful for app-level events outside the runner's typed registry
+ * (auth/error frames, app-state echoes). Most consumers won't need this.
+ */
+export declare function encodeSSE(eventName: string, payload: unknown): string;
+//# sourceMappingURL=stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC;IAC1D;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,MAAM,CAAC;IAC5D;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAuB,KAAK,CAAC,GAAG,EAAE,IAAI,EACpC,MAAM,EAAE,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,EAC7B,OAAO,GAAE,YAAiB,GACzB,aAAa,CAAC,MAAM,CAAC,CA0EvB;AAED;;;GAGG;AACH,qBAAa,YAAY,CAAC,GAAG,GAAG,OAAO,EAAE,IAAI,GAAG,OAAO;IAEnD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,MAAM,EAAE,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,EAC7B,OAAO,GAAE,YAAiB;IAG7C,8DAA8D;IAC9D,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC;CAGhC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAMrE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "1.22.0",
+  "version": "2.0.1",
   "description": "The explainable agent framework — build AI agents you can explain, audit, and trust. Built on footprintjs.",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -52,7 +52,9 @@
     "build": "tsc && tsc -p tsconfig.esm.json",
     "watch": "tsc -w",
     "test": "vitest run",
-    "test:examples": "tsc -p examples/tsconfig.json",
+    "test:examples": "tsc -p examples/tsconfig.json && bash scripts/run-all-examples.sh",
+    "test:examples:typecheck": "tsc -p examples/tsconfig.json",
+    "example": "TSX_TSCONFIG_PATH=examples/runtime.tsconfig.json npx --yes tsx",
     "test:watch": "vitest --watch",
     "lint": "eslint 'src/**/*.ts' 'test/**/*.ts' --ext .ts",
     "lint:fix": "eslint 'src/**/*.ts' 'test/**/*.ts' --ext .ts --fix",
@@ -83,105 +85,40 @@
       "import": "./dist/esm/index.js",
       "require": "./dist/index.js"
     },
-    "./providers": {
-      "types": "./dist/types/providers.barrel.d.ts",
-      "import": "./dist/esm/providers.barrel.js",
-      "require": "./dist/providers.barrel.js"
-    },
-    "./instructions": {
-      "types": "./dist/types/instructions.barrel.d.ts",
-      "import": "./dist/esm/instructions.barrel.js",
-      "require": "./dist/instructions.barrel.js"
+    "./memory": {
+      "types": "./dist/types/memory/index.d.ts",
+      "import": "./dist/esm/memory/index.js",
+      "require": "./dist/memory/index.js"
     },
-    "./skills": {
-      "types": "./dist/types/skills.barrel.d.ts",
-      "import": "./dist/esm/skills.barrel.js",
-      "require": "./dist/skills.barrel.js"
+    "./providers": {
+      "types": "./dist/types/providers.d.ts",
+      "import": "./dist/esm/providers.js",
+      "require": "./dist/providers.js"
     },
     "./observe": {
-      "types": "./dist/types/observe.barrel.d.ts",
-      "import": "./dist/esm/observe.barrel.js",
-      "require": "./dist/observe.barrel.js"
+      "types": "./dist/types/observe.d.ts",
+      "import": "./dist/esm/observe.js",
+      "require": "./dist/observe.js"
     },
     "./resilience": {
-      "types": "./dist/types/resilience.barrel.d.ts",
-      "import": "./dist/esm/resilience.barrel.js",
-      "require": "./dist/resilience.barrel.js"
-    },
-    "./security": {
-      "types": "./dist/types/security.barrel.d.ts",
-      "import": "./dist/esm/security.barrel.js",
-      "require": "./dist/security.barrel.js"
-    },
-    "./explain": {
-      "types": "./dist/types/explain.barrel.d.ts",
-      "import": "./dist/esm/explain.barrel.js",
-      "require": "./dist/explain.barrel.js"
+      "types": "./dist/types/resilience/index.d.ts",
+      "import": "./dist/esm/resilience/index.js",
+      "require": "./dist/resilience/index.js"
     },
     "./stream": {
-      "types": "./dist/types/stream.barrel.d.ts",
-      "import": "./dist/esm/stream.barrel.js",
-      "require": "./dist/stream.barrel.js"
-    },
-    "./patterns": {
-      "types": "./dist/types/patterns.barrel.d.ts",
-      "import": "./dist/esm/patterns.barrel.js",
-      "require": "./dist/patterns.barrel.js"
+      "types": "./dist/types/stream.d.ts",
+      "import": "./dist/esm/stream.js",
+      "require": "./dist/stream.js"
     },
-    "./memory": {
-      "types": "./dist/types/memory.barrel.d.ts",
-      "import": "./dist/esm/memory.barrel.js",
-      "require": "./dist/memory.barrel.js"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "providers": [
-        "dist/types/providers.barrel.d.ts"
-      ],
-      "instructions": [
-        "dist/types/instructions.barrel.d.ts"
-      ],
-      "observe": [
-        "dist/types/observe.barrel.d.ts"
-      ],
-      "resilience": [
-        "dist/types/resilience.barrel.d.ts"
-      ],
-      "security": [
-        "dist/types/security.barrel.d.ts"
-      ],
-      "explain": [
-        "dist/types/explain.barrel.d.ts"
-      ],
-      "stream": [
-        "dist/types/stream.barrel.d.ts"
-      ],
-      "patterns": [
-        "dist/types/patterns.barrel.d.ts"
-      ],
-      "memory": [
-        "dist/types/memory.barrel.d.ts"
-      ]
+    "./injection-engine": {
+      "types": "./dist/types/injection-engine.d.ts",
+      "import": "./dist/esm/injection-engine.js",
+      "require": "./dist/injection-engine.js"
     }
   },
   "sideEffects": false,
   "peerDependencies": {
-    "@anthropic-ai/sdk": ">=0.30.0",
-    "@aws-sdk/client-bedrock-runtime": ">=3.0.0",
-    "footprintjs": ">=4.14.0",
-    "openai": ">=4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@anthropic-ai/sdk": {
-      "optional": true
-    },
-    "openai": {
-      "optional": true
-    },
-    "@aws-sdk/client-bedrock-runtime": {
-      "optional": true
-    }
+    "footprintjs": ">=4.14.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.2",

package/dist/adapters/a2a/a2aRunner.js

@@ -1,36 +0,0 @@
-"use strict";
-/**
- * a2aRunner — wraps an A2A (Agent-to-Agent) endpoint as a RunnerLike.
- *
- * A2A protocol enables agents to communicate across services.
- * This adapter bridges the A2A interface to agentfootprint's RunnerLike,
- * enabling composition in FlowChart, Swarm, or agentAsTool.
- *
- * The adapter accepts an A2AClient interface (transport-agnostic).
- * Users provide their own A2A client implementation.
- *
- * Usage:
- *   const remoteAgent = a2aRunner({
- *     client: myA2AClient,
- *     agentId: 'research-agent',
- *   });
- *   const pipeline = FlowChart.create()
- *     .agent('remote-research', 'Research', remoteAgent)
- *     .build();
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.a2aRunner = void 0;
-function a2aRunner(options) {
-    const { client, agentId } = options;
-    return {
-        run: async (message, runOptions) => {
-            const response = await client.sendMessage(agentId, message, {
-                signal: runOptions?.signal,
-                timeoutMs: runOptions?.timeoutMs,
-            });
-            return { content: response.content };
-        },
-    };
-}
-exports.a2aRunner = a2aRunner;
-//# sourceMappingURL=a2aRunner.js.map

package/dist/adapters/a2a/a2aRunner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"a2aRunner.js","sourceRoot":"","sources":["../../../src/adapters/a2a/a2aRunner.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AA8BH,SAAgB,SAAS,CAAC,OAAyB;IACjD,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAEpC,OAAO;QACL,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE;YACjC,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE;gBAC1D,MAAM,EAAE,UAAU,EAAE,MAAM;gBAC1B,SAAS,EAAE,UAAU,EAAE,SAAS;aACjC,CAAC,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC;QACvC,CAAC;KACF,CAAC;AACJ,CAAC;AAZD,8BAYC"}