agentfootprint 1.22.0 → 2.0.1

package/dist/types/lib/call/types.d.ts

@@ -1,17 +0,0 @@
-/**
- * Call module types.
- *
- * The call module contains the three stages that happen AFTER the three API slots:
- *   CallLLM → ParseResponse → HandleResponse
- *
- * These stages consume what the slots wrote to scope and produce the LLM result.
- */
-import type { LLMProvider } from '../../types';
-/**
- * Config for CallLLM stage.
- */
-export interface CallLLMConfig {
-    /** The LLM provider to call (Anthropic, OpenAI, mock, etc.). */
-    readonly provider: LLMProvider;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/call/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/lib/call/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAChC"}

package/dist/types/lib/concepts/Agent.d.ts

@@ -1,9 +0,0 @@
-/**
- * Agent — re-exports builder and runner from split files.
- * Preserves backward compatibility for imports.
- */
-export { Agent } from './AgentBuilder';
-export type { AgentOptions, CustomRouteBranch, CustomRouteConfig } from './AgentBuilder';
-export { AgentRunner } from './AgentRunner';
-export type { AgentRunnerOptions } from './AgentRunner';
-//# sourceMappingURL=Agent.d.ts.map

package/dist/types/lib/concepts/Agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Agent.d.ts","sourceRoot":"","sources":["../../../../src/lib/concepts/Agent.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC"}

package/dist/types/lib/concepts/AgentBuilder.d.ts

@@ -1,297 +0,0 @@
-/**
- * Agent builder — fluent API for configuring an agent.
- *
- * Usage:
- *   const agent = Agent.create({ provider })
- *     .system('You are helpful.')
- *     .tool(searchTool)
- *     .build();
- */
-import type { ToolDefinition, LLMProvider } from '../../types';
-import type { ModelConfig } from '../../models';
-import type { MemoryPipeline } from '../../memory/pipeline';
-import type { AgentRecorder, PromptProvider, ToolProvider } from '../../core';
-import type { RunnerLike } from '../../types/multiAgent';
-import type { InstructionOverride, AgentInstruction } from '../instructions';
-import type { SkillRegistry } from '../skills';
-import { AgentPattern } from '../loop';
-import { AgentRunner } from './AgentRunner';
-/**
- * A single user-defined branch in `Agent.route({...})`.
- *
- * The `when` predicate runs BEFORE the default tool-calls/final routing. First match wins.
- * If no user branch matches, the Agent routes as normal (tool-calls if the LLM requested
- * tools, final otherwise).
- *
- * `runner` must be a RunnerLike — any concept (Agent, LLMCall, RAG, Swarm, etc.) or a
- * custom object with `.run(input)`. When the branch fires, the runner executes as a
- * subflow and the returned content replaces the agent's current response.
- */
-export interface CustomRouteBranch<TScope = any> {
-    /** Predicate evaluated on the agent scope after ParseResponse. First matching branch wins. */
-    readonly when: (scope: TScope) => boolean;
-    /** Runner to execute when the branch fires. */
-    readonly runner: RunnerLike;
-    /** Stable id for narrative + recorder dispatch. Auto-generated if omitted. */
-    readonly id?: string;
-}
-export interface CustomRouteConfig<TScope = any> {
-    /** User-defined branches, evaluated in order before default tool-calls/final. */
-    readonly branches: readonly CustomRouteBranch<TScope>[];
-}
-export interface AgentOptions {
-    /** LLMProvider instance or ModelConfig from anthropic()/openai()/bedrock()/ollama(). */
-    readonly provider: LLMProvider | ModelConfig;
-    readonly name?: string;
-}
-export declare class Agent {
-    private readonly provider;
-    private readonly agentName;
-    private systemPromptText?;
-    private customPromptProvider?;
-    private readonly registry;
-    private customToolProvider?;
-    private maxIter;
-    private readonly recorders;
-    private configuredMemoryPipeline?;
-    private agentPattern;
-    private readonly overrides;
-    private agentInstructions;
-    private skillsPromptAddition?;
-    private skillsTools?;
-    private initialDecisionScope?;
-    private enableStreaming;
-    private enableVerboseNarrative;
-    private outputResponseFormat?;
-    private parallelToolsEnabled;
-    private customRoute?;
-    private maxIdenticalFailuresValue?;
-    private constructor();
-    /**
-     * Create an agent builder.
-     *
-     * Accepts either an LLMProvider or a ModelConfig from factory functions:
-     * ```ts
-     * // With ModelConfig (auto-resolved)
-     * Agent.create({ provider: anthropic('claude-sonnet-4-20250514') })
-     *
-     * // With LLMProvider (direct)
-     * Agent.create({ provider: new AnthropicAdapter({ model: '...' }) })
-     * ```
-     */
-    static create(options: AgentOptions): Agent;
-    /** Set system prompt (static — same every iteration). */
-    system(prompt: string): this;
-    /**
-     * Set a custom prompt provider (dynamic — can change each iteration).
-     * Overrides `.system()`.
-     */
-    promptProvider(provider: PromptProvider): this;
-    /** Register a tool. */
-    tool(toolDef: ToolDefinition): this;
-    /** Register multiple tools. */
-    tools(toolDefs: ToolDefinition[]): this;
-    /**
-     * Set a custom tool provider (dynamic — can change each iteration).
-     * Overrides `.tool()` / `.tools()`.
-     */
-    toolProvider(provider: ToolProvider): this;
-    /** Set max ReAct loop iterations. */
-    maxIterations(n: number): this;
-    /** Enable streaming — tokens emitted incrementally via onToken callback. */
-    streaming(enabled?: boolean): this;
-    /**
-     * Run multiple tool calls within a single turn concurrently via Promise.all.
-     *
-     * Only beneficial when the LLM requests 2+ independent tool calls in one turn
-     * (e.g., "look up customer, orders, and product in parallel"). Results are
-     * appended to the conversation in the order the LLM requested them.
-     *
-     * **Caveat:** decide() functions on tool-level instructions mutate a shared
-     * Decision Scope — in parallel mode those mutations are not serialized.
-     * If your instructions rely on strict ordering, keep sequential (default).
-     *
-     * @example
-     * ```ts
-     * Agent.create({ provider })
-     *   .tools([getCustomer, getOrders, getProduct])
-     *   .parallelTools(true)
-     *   .build();
-     * ```
-     */
-    parallelTools(enabled?: boolean): this;
-    /**
-     * Register user-defined routing branches evaluated BEFORE the default
-     * `tool-calls | final` routing. First matching `when` predicate wins.
-     *
-     * Useful for injecting escalation paths, safety gates, or bespoke handlers
-     * without touching the Agent loop internals. The default tool-calls and
-     * final branches still apply when no user branch matches.
-     *
-     * @example
-     * ```ts
-     * Agent.create({ provider })
-     *   .tool(searchTool)
-     *   .route({
-     *     branches: [
-     *       { id: 'escalate', when: (s) => s.parsedResponse.content.includes('[ESCALATE]'), runner: humanReviewAgent },
-     *     ],
-     *   })
-     *   .build();
-     * ```
-     */
-    route(config: CustomRouteConfig): this;
-    /**
-     * Set the repeated-identical-failure escalation threshold. When a tool call
-     * with the exact same (name, args) has failed this many times in a row, a
-     * one-shot `escalation` field is injected into that tool result content
-     * urging the LLM to change arguments, switch tools, or finalize. Fires
-     * exactly once per (name, args) key per conversation — further identical
-     * failures are left bare to avoid token bloat.
-     *
-     * Defaults to `3`. Pass `0` to disable escalation entirely.
-     *
-     * @example
-     * ```ts
-     * Agent.create({ provider })
-     *   .tools([...])
-     *   .maxIdenticalFailures(2) // fire escalation after 2 identical failures
-     *   .build();
-     *
-     * // Disable entirely:
-     * Agent.create({ provider }).tools([...]).maxIdenticalFailures(0).build();
-     * ```
-     */
-    maxIdenticalFailures(n: number): this;
-    /**
-     * Enable verbose narrative — full values, no truncation.
-     * Shows complete system prompts, tool results, and LLM outputs in the narrative.
-     * Enables grounding analysis via ExplainRecorder.
-     */
-    verbose(enabled?: boolean): this;
-    /**
-     * Request structured JSON output matching a schema.
-     * Accepts JSON Schema or Zod schema (auto-converted).
-     *
-     * @param schema - JSON Schema object or Zod schema
-     * @param options - Optional: name for the schema, injection position for non-native providers
-     *
-     * @example
-     * ```ts
-     * // JSON Schema
-     * agent.outputSchema({ type: 'object', properties: { city: { type: 'string' } } })
-     *
-     * // Zod schema
-     * agent.outputSchema(z.object({ city: z.string() }))
-     *
-     * // Inject in user message (recency window) instead of system prompt
-     * agent.outputSchema(z.object({ city: z.string() }), { injection: 'user' })
-     * ```
-     */
-    outputSchema(schema: Record<string, unknown>, options?: {
-        name?: string;
-        injection?: 'system' | 'user';
-    }): this;
-    /**
-     * Set the agent loop pattern.
-     * - `AgentPattern.Regular` (default): slots resolve once
-     * - `AgentPattern.Dynamic`: all slots re-evaluate each iteration
-     */
-    pattern(p: AgentPattern): this;
-    /**
-     * Override instructions on a shared tool without modifying the tool definition.
-     */
-    instructionOverride(toolId: string, override: InstructionOverride): this;
-    /**
-     * Register an agent-level instruction.
-     * Instructions inject into system prompt, tools, and tool-result processing
-     * based on the Decision Scope state.
-     *
-     * @example
-     * ```typescript
-     * Agent.create({ provider })
-     *   .instruction(defineInstruction({
-     *     id: 'refund',
-     *     activeWhen: (d) => d.orderStatus === 'denied',
-     *     prompt: 'Be empathetic.',
-     *   }))
-     *   .build();
-     * ```
-     */
-    instruction(instr: AgentInstruction<any>): this;
-    /** Register multiple agent-level instructions. */
-    instructions(instrs: AgentInstruction<any>[]): this;
-    /**
-     * Attach a `SkillRegistry` — a typed, versioned bundle of procedures
-     * the model can discover via `list_skills` and activate via
-     * `read_skill(id)`. Registry's skills are wired through the existing
-     * AgentInstruction pipeline (each skill IS-A AgentInstruction) so
-     * per-skill `activeWhen` / `prompt` / `tools` / `onToolResult` rules
-     * fire exactly as with plain `.instruction(...)`.
-     *
-     * Idempotent: calling `.skills()` twice REPLACES the prior registry
-     * (panel #6). For additive composition, compose registries yourself
-     * before passing them in.
-     *
-     * @example
-     * ```ts
-     * const registry = new SkillRegistry<MyDecision>({ surfaceMode: 'auto' });
-     * registry.register(defineSkill({ id: 'port-triage', ... }));
-     *
-     * Agent.create({ provider: anthropic('claude-sonnet-4-5') })
-     *   .skills(registry)
-     *   .build();
-     * ```
-     */
-    skills<TDecision = any>(registry: SkillRegistry<TDecision>): this;
-    /**
-     * Set the initial Decision Scope values.
-     * Tool handlers update these values; InstructionsToLLM reads them
-     * to evaluate `activeWhen` predicates.
-     *
-     * @example
-     * ```typescript
-     * Agent.create({ provider })
-     *   .decision<MyDecision>({ orderStatus: null, riskLevel: 'unknown' })
-     *   .instruction(refundInstruction)
-     *   .build();
-     * ```
-     */
-    decision<T extends Record<string, unknown> = Record<string, unknown>>(scope: T): this;
-    /**
-     * Attach a memory pipeline built from `defaultPipeline`, `ephemeralPipeline`,
-     * or custom composition. Subflows handle load / pick / format before
-     * CallLLM and persist / summarize after Finalize.
-     *
-     * Identity is supplied at `run()` time via `{ identity: {...} }` so the
-     * same agent instance can serve many users / tenants safely.
-     *
-     * @example
-     * ```ts
-     * import { Agent, mock } from 'agentfootprint';
-     * import { defaultPipeline, InMemoryStore } from 'agentfootprint/memory';
-     *
-     * const pipeline = defaultPipeline({ store: new InMemoryStore() });
-     *
-     * const agent = Agent.create({ provider: mock([...]) })
-     *   .system('You remember the user across turns.')
-     *   .memoryPipeline(pipeline)
-     *   .build();
-     *
-     * await agent.run('My name is Alice', {
-     *   identity: { conversationId: 'alice-session-1' },
-     * });
-     * ```
-     */
-    memoryPipeline(pipeline: MemoryPipeline): this;
-    /** Attach a recorder. Accepts AgentRecorder OR EmitRecorder shape;
-     *  shape auto-detected at run-time. `contextEngineering()` works
-     *  here too — see RAG.recorder for the full rationale. */
-    recorder(rec: AgentRecorder | {
-        id: string;
-        onEmit?: (event: any) => void;
-    }): this;
-    /** Build the agent and return a runner. */
-    build(): AgentRunner;
-}
-//# sourceMappingURL=AgentBuilder.d.ts.map

package/dist/types/lib/concepts/AgentBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AgentBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/concepts/AgentBuilder.ts"],"names":[],"mappings":"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"}

package/dist/types/lib/concepts/AgentRunner.d.ts

@@ -1,241 +0,0 @@
-/**
- * AgentRunner — executes the agent loop, manages conversation state.
- *
- * Created by Agent.build(). Not instantiated directly.
- */
-import type { FlowChart as FlowChartType } from 'footprintjs';
-import { AgentPattern } from '../loop';
-import type { InstructionOverride, AgentInstruction } from '../instructions';
-import type { AgentStreamEventHandler } from '../../streaming';
-import type { CustomRouteConfig } from './AgentBuilder';
-import { ToolRegistry } from '../../tools';
-import type { LLMProvider, AgentResult, Message, ResponseFormat } from '../../types';
-import type { MemoryPipeline } from '../../memory/pipeline';
-import type { AgentRecorder, PromptProvider, ToolProvider } from '../../core';
-/** Options for constructing an AgentRunner. Created by Agent.build(). */
-export interface AgentRunnerOptions {
-    readonly provider: LLMProvider;
-    readonly name: string;
-    readonly systemPromptText?: string;
-    readonly registry: ToolRegistry;
-    readonly maxIterations?: number;
-    readonly recorders?: AgentRecorder[];
-    readonly memoryPipeline?: MemoryPipeline;
-    readonly pattern?: AgentPattern;
-    readonly promptProvider?: PromptProvider;
-    readonly toolProvider?: ToolProvider;
-    readonly instructionOverrides?: ReadonlyMap<string, InstructionOverride>;
-    readonly agentInstructions?: readonly AgentInstruction[];
-    readonly initialDecision?: Readonly<Record<string, unknown>>;
-    readonly streaming?: boolean;
-    /** When true, narrative shows full values (no truncation). */
-    readonly verboseNarrative?: boolean;
-    /** Structured output format — passed through to LLM provider. */
-    readonly responseFormat?: ResponseFormat;
-    /** Run tool calls within a single turn concurrently. Default: false. */
-    readonly parallelTools?: boolean;
-    /** User-defined routing branches evaluated before default tool-calls/final. */
-    readonly customRoute?: CustomRouteConfig;
-    /**
-     * Consecutive-identical-failure threshold for escalation. `0` disables.
-     * Defaults to `REPEATED_FAILURE_ESCALATION_THRESHOLD` (3) when omitted.
-     */
-    readonly maxIdenticalFailures?: number;
-}
-export declare class AgentRunner {
-    private static _autoExecCounter;
-    private readonly provider;
-    readonly name: string;
-    private readonly systemPromptText?;
-    private readonly registry;
-    private readonly maxIter;
-    private readonly recorders;
-    private readonly memoryPipeline?;
-    private readonly agentPattern;
-    private readonly customPromptProvider?;
-    private readonly customToolProvider?;
-    private readonly instructionOverrides?;
-    private readonly agentInstructions?;
-    private readonly initialDecision?;
-    private readonly streamingEnabled;
-    private readonly responseFormat?;
-    private readonly parallelToolsEnabled;
-    private readonly customRoute?;
-    private readonly maxIdenticalFailures?;
-    private readonly cachedDecideFunctions?;
-    private conversationHistory;
-    /**
-     * Decision scope carried forward between `.run()` calls. Tool handlers
-     * write into `scope.decision` via `decisionUpdate`; without this carry-
-     * over, every new turn would see an empty decision and skill-gated
-     * tools (autoActivate) would disappear on follow-up messages.
-     * `resetConversation()` clears this alongside `conversationHistory` so
-     * a fresh conversation really starts fresh. Undefined before the first
-     * run — falls back to `initialDecision` from build config.
-     */
-    private lastDecision?;
-    private lastExecutor?;
-    private lastSpec?;
-    private readonly verboseNarrative;
-    private narrativeRenderer;
-    /**
-     * Persistent observer list for `runner.observe(handler)`. One dispatcher
-     * per runner instance — every `.run()` call funnels events through here
-     * in addition to any per-run `options.onEvent` callback. Used by Lens,
-     * telemetry, and anyone else who wants to watch what the agent does.
-     */
-    private readonly dispatcher;
-    private readonly pendingFollowUps;
-    /**
-     * Cached charts — built lazily on first use, reused across every
-     * `.run()` / `.toFlowChart()` call. Stream events flow through the
-     * emit channel (via a per-run `StreamEventRecorder` attached to the
-     * executor), so no per-run closure ever lands in chart stages. This
-     * lets both standalone and subflow-mode charts be pure static
-     * structures.
-     */
-    private cachedStandaloneChart?;
-    private cachedSubflowChart?;
-    /**
-     * Per-run strict follow-up that fired during tool execution. Reset at
-     * the start of each `.run()` call so state doesn't leak between turns.
-     * Populated by the `onInstructionsFired` callback wired through
-     * `buildConfig()`.
-     */
-    private runStrictFollowUp?;
-    constructor(options: AgentRunnerOptions);
-    /**
-     * Expose the agent's internal flowChart for subflow composition.
-     * Cached — built once, reused across all mount sites.
-     */
-    toFlowChart(): FlowChartType;
-    /**
-     * Lazy-build the standalone chart on first `.run()`. Stream handler
-     * flows via a per-run emit recorder attached in `run()` — the chart
-     * itself is a pure static structure and is reused forever.
-     */
-    private getStandaloneChart;
-    /** Run the agent with a user message. */
-    run(message: string, options?: {
-        signal?: AbortSignal;
-        timeoutMs?: number;
-        /** Full event stream — tool lifecycle, LLM lifecycle, tokens. */
-        onEvent?: AgentStreamEventHandler;
-        /** @deprecated Use onEvent instead. Ignored if onEvent is also provided. */
-        onToken?: (token: string) => void;
-        /**
-         * Memory identity for this turn. Forwarded to the memory pipeline
-         * (if configured via `.memoryPipeline()`). Same agent instance can
-         * serve many users by passing different identities per-run.
-         * Ignored when the agent has no memory pipeline attached.
-         */
-        identity?: {
-            tenant?: string;
-            principal?: string;
-            conversationId: string;
-        };
-        /**
-         * Run-local turn counter. Written into `MemoryEntry.source.turn` by
-         * the write subflow for cross-turn provenance. Defaults to 1.
-         */
-        turnNumber?: number;
-        /**
-         * Context-window token budget hint. Picker stage uses this to bound
-         * how much memory it injects. Defaults to 4000.
-         */
-        contextTokensRemaining?: number;
-    }): Promise<AgentResult>;
-    /**
-     * Resume a paused agent (after ask_human tool).
-     *
-     * Provides the human's response, which becomes the tool result for ask_human.
-     * The agent loop continues from where it paused.
-     *
-     * @example
-     * ```typescript
-     * const result = await agent.run('Process my refund');
-     * if (result.paused) {
-     *   const final = await agent.resume('Yes, order ORD-123');
-     * }
-     * ```
-     *
-     * Note: `onEvent` streaming is not yet supported on `resume()`.
-     * The resumed turn completes without emitting AgentStreamEvents.
-     * Use `result.content` and `agent.getNarrative()` for post-resume data.
-     */
-    resume(humanResponse: string): Promise<AgentResult>;
-    /**
-     * Create a scope recorder that captures LLM responses + context during traversal.
-     * Shared by run() and resume() — eliminates duplication and ensures both paths
-     * track runtimeStageId for stream bridge tool events.
-     */
-    private createLLMCaptureRecorder;
-    /** Extract AgentResult from executor state — shared by run() and resume(). */
-    private buildResult;
-    getNarrativeEntries(): import("footprintjs").CombinedNarrativeEntry[];
-    getSnapshot(): import("footprintjs").RuntimeSnapshot | undefined;
-    /**
-     * Subscribe to the agent's live stream of events — `turn_start`,
-     * `llm_start`/`llm_end`, `tool_start`/`tool_end`, `token` (when
-     * streaming), `turn_end`. The returned function unsubscribes.
-     *
-     * Multiple observers are supported; each gets every event. A throwing
-     * observer never propagates — the library error-isolates each call.
-     *
-     * @example
-     * ```ts
-     * const stop = agent.observe((e) => {
-     *   if (e.type === 'llm_end') metrics.record(e.usage);
-     * });
-     * // later:
-     * stop();
-     * ```
-     */
-    observe(handler: AgentStreamEventHandler): () => void;
-    /**
-     * Attach a recorder POST-BUILD. Mirrors the build-time `.recorder()`
-     * AgentBuilder method — the recorder participates in every subsequent
-     * `.run()` (gets `clear()` lifecycle + receives events through the
-     * executor's emit channel via `forwardEmitRecorders`).
-     *
-     * Why post-build attach matters: UI consumers like Lens receive an
-     * already-built agent via `<Lens for={agent} />` and can't influence
-     * the build-time `.recorder()` chain. Without this method they'd
-     * have to subscribe via `observe()` and get a translated AgentStreamEvent
-     * shape (no runtimeStageId, no subflowPath). With this method they
-     * get the full EmitEvent — proper recorder pattern, multi-agent ready.
-     *
-     * Returns a detach function; calling it removes the recorder from
-     * subsequent runs. Idempotent by recorder id (matching the same
-     * contract as build-time recorders).
-     *
-     * @example
-     * ```ts
-     * import { agentTimeline } from 'agentfootprint';
-     * const t = agentTimeline({ name: 'Neo' });
-     * const stop = agent.attachRecorder(t);
-     * await agent.run('hello');
-     * console.log(t.getTimeline());
-     * stop();  // detach
-     * ```
-     */
-    attachRecorder(recorder: any): () => void;
-    getSpec(): unknown;
-    getMessages(): Message[];
-    resetConversation(): void;
-    /**
-     * Forward a strict follow-up captured during the run to the pending
-     * queue. Isolated into a method so TypeScript doesn't narrow the
-     * field type to `never` via control-flow from the earlier reset.
-     */
-    private flushStrictFollowUp;
-    /**
-     * Build the static AgentLoopConfig. Called ONCE by the cached-chart
-     * builder (`getStandaloneChart` / `toFlowChart`). Contains no per-run
-     * inputs — `onStreamEvent` flows through args per turn, and the
-     * `onInstructionsFired` callback writes into `this.runStrictFollowUp`
-     * which `run()` resets at each turn's start.
-     */
-    private buildConfig;
-}
-//# sourceMappingURL=AgentRunner.d.ts.map

package/dist/types/lib/concepts/AgentRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AgentRunner.d.ts","sourceRoot":"","sources":["../../../../src/lib/concepts/AgentRunner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,SAAS,IAAI,aAAa,EAI3B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAkB,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAoB,MAAM,iBAAiB,CAAC;AAE/F,OAAO,KAAK,EAAoB,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAGjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAQxD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,OAAO,KAAK,EAAE,WAAW,EAAe,WAAW,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAe9E,yEAAyE;AACzE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACzE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACzD,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC,iEAAiE;IACjE,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC,wEAAwE;IACxE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAK;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAe;IACnD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAA2C;IACjF,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAA8B;IACjE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAoC;IACrE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAU;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAU;IAC/C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAgC;IACvE,OAAO,CAAC,mBAAmB,CAAiB;IAC5C;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY,CAAC,CAAoC;IACzD,OAAO,CAAC,YAAY,CAAC,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,CAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAU;IAC3C,OAAO,CAAC,iBAAiB,CAAyB;IAClD;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgC;IAEjE;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB,CAAC,CAAgB;IAC9C,OAAO,CAAC,kBAAkB,CAAC,CAAgB;IAE3C;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB,CAAC,CAAuD;gBAErE,OAAO,EAAE,kBAAkB;IAwDvC;;;OAGG;IACH,WAAW,IAAI,aAAa;IAa5B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAW1B,yCAAyC;IACnC,GAAG,CACP,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,iEAAiE;QACjE,OAAO,CAAC,EAAE,uBAAuB,CAAC;QAClC,4EAA4E;QAC5E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;QAClC;;;;;WAKG;QACH,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3E;;;WAGG;QACH,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB;;;WAGG;QACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;KACjC,GACA,OAAO,CAAC,WAAW,CAAC;IAqMvB;;;;;;;;;;;;;;;;;OAiBG;IAEG,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAoCzD;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IA2ChC,8EAA8E;IAC9E,OAAO,CAAC,WAAW;IAgDnB,mBAAmB;IAGnB,WAAW;IAIX;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,OAAO,EAAE,uBAAuB,GAAG,MAAM,IAAI;IAIrD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IAEH,cAAc,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,IAAI;IAqBzC,OAAO,IAAI,OAAO;IAYlB,WAAW,IAAI,OAAO,EAAE;IAGxB,iBAAiB,IAAI,IAAI;IAQzB;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;CAyDpB"}

package/dist/types/lib/concepts/index.d.ts

@@ -1,3 +0,0 @@
-export { Agent, AgentRunner } from './Agent';
-export type { AgentOptions, CustomRouteBranch, CustomRouteConfig } from './Agent';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/concepts/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/concepts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC7C,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}