agentfootprint 1.0.0

package/dist/types/providers/tools/PermissionPolicy.d.ts

@@ -0,0 +1,76 @@
+/**
+ * PermissionPolicy — centralized, shareable permission policy for tool gating.
+ *
+ * Addresses the "per-agent, not centralized" con of gatedTools().
+ * Create one policy, share it across multiple agents/swarms.
+ *
+ * Features:
+ *   - grant/revoke at runtime (mid-conversation permission changes)
+ *   - wildcard support ('*' grants all)
+ *   - role-based presets (pass a Set of tool IDs per role)
+ *   - onChange callback for audit/logging
+ *
+ * Usage:
+ *   // Centralized policy — shared across agents
+ *   const policy = new PermissionPolicy(['search', 'calc']);
+ *
+ *   const agent1 = Agent.create({ provider })
+ *     .toolProvider(gatedTools(tools, policy.checker()))
+ *     .build();
+ *
+ *   const agent2 = Agent.create({ provider })
+ *     .toolProvider(gatedTools(otherTools, policy.checker()))
+ *     .build();
+ *
+ *   // Runtime changes — both agents see it immediately
+ *   policy.grant('admin-tool');
+ *   policy.revoke('search');
+ *
+ *   // Role-based
+ *   const policy = PermissionPolicy.fromRoles({
+ *     user: ['search', 'calc'],
+ *     admin: ['search', 'calc', 'delete-user', 'run-code'],
+ *   }, 'user');  // current role
+ *   policy.setRole('admin');  // upgrade mid-conversation
+ */
+import type { PermissionChecker } from './gatedTools';
+export interface PermissionPolicyOptions {
+    /** Called when permissions change (grant/revoke/setRole). For audit logging. */
+    onChange?: (event: PermissionChangeEvent) => void;
+}
+export interface PermissionChangeEvent {
+    type: 'grant' | 'revoke' | 'role-change';
+    toolId?: string;
+    role?: string;
+    allowed: string[];
+}
+export declare class PermissionPolicy {
+    private allowed;
+    private readonly onChange?;
+    private roles?;
+    private currentRole?;
+    constructor(initialAllowed?: Iterable<string>, options?: PermissionPolicyOptions);
+    /**
+     * Create a policy from role definitions.
+     * The active role determines which tools are allowed.
+     */
+    static fromRoles(roles: Record<string, readonly string[]>, activeRole: string, options?: PermissionPolicyOptions): PermissionPolicy;
+    /** Grant access to a tool. Takes effect on next resolve() call. */
+    grant(toolId: string): this;
+    /** Revoke access to a tool. */
+    revoke(toolId: string): this;
+    /** Switch to a different role (role-based policies only). */
+    setRole(role: string): this;
+    /** Current role (if using role-based policy). */
+    getRole(): string | undefined;
+    /** Check if a tool is allowed. */
+    isAllowed(toolId: string): boolean;
+    /** Get all currently allowed tool IDs. */
+    getAllowed(): string[];
+    /**
+     * Returns a PermissionChecker compatible with gatedTools().
+     * This is the bridge — create one policy, pass checker() to multiple gatedTools.
+     */
+    checker(): PermissionChecker;
+}
+//# sourceMappingURL=PermissionPolicy.d.ts.map

package/dist/types/providers/tools/PermissionPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionPolicy.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/PermissionPolicy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,WAAW,uBAAuB;IACtC,gFAAgF;IAChF,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACnD;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,aAAa,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAyC;IAGnE,OAAO,CAAC,KAAK,CAAC,CAAoC;IAClD,OAAO,CAAC,WAAW,CAAC,CAAS;gBAEjB,cAAc,GAAE,QAAQ,CAAC,MAAM,CAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB;IAKpF;;;OAGG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,EACxC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,uBAAuB,GAChC,gBAAgB;IAQnB,mEAAmE;IACnE,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM3B,+BAA+B;IAC/B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B,6DAA6D;IAC7D,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAS3B,iDAAiD;IACjD,OAAO,IAAI,MAAM,GAAG,SAAS;IAI7B,kCAAkC;IAClC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC,0CAA0C;IAC1C,UAAU,IAAI,MAAM,EAAE;IAItB;;;OAGG;IACH,OAAO,IAAI,iBAAiB;CAG7B"}

package/dist/types/providers/tools/agentAsTool.d.ts

@@ -0,0 +1,40 @@
+/**
+ * agentAsTool — wraps a RunnerLike as a ToolDefinition.
+ *
+ * Turns any agent (or runner) into a callable tool. The LLM can invoke it
+ * like any other tool, passing a message. The runner executes and returns
+ * the result as tool output.
+ *
+ * This is the primitive for delegation patterns: an orchestrator agent
+ * can call specialist agents as tools (Swarm handoff, hierarchy, etc.).
+ *
+ * Usage:
+ *   const researchTool = agentAsTool({
+ *     id: 'research',
+ *     description: 'Research a topic in depth.',
+ *     runner: researchAgent,
+ *   });
+ *   const orchestrator = Agent.create({ provider })
+ *     .tool(researchTool)
+ *     .build();
+ */
+import type { ToolDefinition } from '../../types/tools';
+import type { RunnerLike } from '../../types/multiAgent';
+export interface AgentAsToolConfig {
+    /** Tool ID (sent to the LLM). */
+    readonly id: string;
+    /** Tool description (sent to the LLM). */
+    readonly description: string;
+    /** The runner to delegate to. */
+    readonly runner: RunnerLike;
+    /** Input schema override. Defaults to `{ message: string }`. */
+    readonly inputSchema?: Record<string, unknown>;
+    /** Extract the message from tool input. Defaults to `input.message`. */
+    readonly inputMapper?: (input: Record<string, unknown>) => string;
+    /** AbortSignal propagation. */
+    readonly signal?: AbortSignal;
+    /** Timeout for the runner. */
+    readonly timeoutMs?: number;
+}
+export declare function agentAsTool(config: AgentAsToolConfig): ToolDefinition;
+//# sourceMappingURL=agentAsTool.d.ts.map

package/dist/types/providers/tools/agentAsTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentAsTool.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/agentAsTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,iCAAiC;IACjC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,wEAAwE;IACxE,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC;IAClE,+BAA+B;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAUD,wBAAgB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,cAAc,CA0BrE"}

package/dist/types/providers/tools/compositeTools.d.ts

@@ -0,0 +1,18 @@
+/**
+ * compositeTools — ToolProvider that merges multiple ToolProviders.
+ *
+ * Resolves all providers and merges their tool lists. If multiple providers
+ * return a tool with the same name, later providers win (last-write-wins).
+ *
+ * Execute delegates to the provider that owns the tool (by resolve order,
+ * last provider that resolved a tool of that name handles execution).
+ *
+ * Usage:
+ *   const tools = compositeTools([
+ *     staticTools([searchTool]),
+ *     dynamicTools((ctx) => ctx.turnNumber > 3 ? [submitTool] : []),
+ *   ]);
+ */
+import type { ToolProvider } from '../../core';
+export declare function compositeTools(providers: readonly ToolProvider[]): ToolProvider;
+//# sourceMappingURL=compositeTools.d.ts.map

package/dist/types/providers/tools/compositeTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositeTools.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/compositeTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAoC,MAAM,YAAY,CAAC;AAGjF,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAmC/E"}

package/dist/types/providers/tools/dynamicTools.d.ts

@@ -0,0 +1,27 @@
+/**
+ * dynamicTools — resolver-only ToolProvider that resolves tools based on context.
+ *
+ * The resolver function receives the current ToolContext and returns
+ * the tools available for this turn. Useful when:
+ * - Different tools are available based on conversation state
+ * - Tools are loaded from an external source (MCP, DB, API)
+ * - Tool availability depends on user permissions
+ *
+ * This provider does NOT include `execute` — the core loop calls
+ * `ToolDefinition.handler` directly from the resolved set. This avoids
+ * stale cache issues and temporal coupling between resolve/execute.
+ *
+ * For providers where execution is remote (MCP, A2A), implement
+ * `ToolProvider` directly with both `resolve` and `execute`.
+ *
+ * Usage:
+ *   agentLoop().toolProvider(dynamicTools((ctx) => {
+ *     if (ctx.message.includes('code')) return [runCodeTool];
+ *     return [searchTool];
+ *   }))
+ */
+import type { ToolProvider, ToolContext } from '../../core';
+import type { ToolDefinition } from '../../types/tools';
+export type ToolResolver = (context: ToolContext) => ToolDefinition[] | Promise<ToolDefinition[]>;
+export declare function dynamicTools(resolver: ToolResolver): ToolProvider;
+//# sourceMappingURL=dynamicTools.d.ts.map

package/dist/types/providers/tools/dynamicTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicTools.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/dynamicTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,WAAW,KAAK,cAAc,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;AAElG,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,CAiBjE"}

package/dist/types/providers/tools/gatedTools.d.ts

@@ -0,0 +1,52 @@
+/**
+ * gatedTools — Permission-based tool filtering with defense in depth.
+ *
+ * Wraps any ToolProvider to filter tools based on a permission check.
+ * Two layers of enforcement:
+ *   1. resolve() — blocked tools are hidden from LLM (it never sees them)
+ *   2. execute() — if LLM somehow calls a blocked tool, returns error
+ *
+ * The permission check runs every loop iteration (per-turn), so permissions
+ * can change mid-conversation (e.g., user grants access after auth step).
+ *
+ * Narrative integration: blocked execution returns an error result that
+ * flows through the normal tool result path → recorders see it via
+ * onToolCall, LLM sees it in conversation history and can respond.
+ *
+ * Optional onBlocked callback for observability (logging, metrics).
+ *
+ * Usage:
+ *   // Static permission set
+ *   const tools = gatedTools(
+ *     staticTools([searchTool, adminTool, codeTool]),
+ *     (toolId) => userPermissions.has(toolId),
+ *   );
+ *
+ *   // Context-aware (per-turn)
+ *   const tools = gatedTools(
+ *     staticTools(allTools),
+ *     (toolId, ctx) => {
+ *       if (ctx.turnNumber > 5) return false; // rate limit
+ *       return allowedTools.has(toolId);
+ *     },
+ *   );
+ *
+ *   // With observability
+ *   const tools = gatedTools(
+ *     staticTools(allTools),
+ *     (toolId) => permissions.has(toolId),
+ *     { onBlocked: (toolId, phase) => console.log(`Blocked ${toolId} at ${phase}`) },
+ *   );
+ */
+import type { ToolProvider, ToolContext } from '../../core';
+/**
+ * Permission checker — called for each tool on each turn.
+ * Return true to allow, false to block.
+ */
+export type PermissionChecker = (toolId: string, context: ToolContext) => boolean | Promise<boolean>;
+export interface GatedToolsOptions {
+    /** Called when a tool is blocked (at resolve or execute phase). For logging/metrics. */
+    onBlocked?: (toolId: string, phase: 'resolve' | 'execute', context?: ToolContext) => void;
+}
+export declare function gatedTools(inner: ToolProvider, isAllowed: PermissionChecker, options?: GatedToolsOptions): ToolProvider;
+//# sourceMappingURL=gatedTools.d.ts.map

package/dist/types/providers/tools/gatedTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatedTools.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/gatedTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAErG,MAAM,WAAW,iBAAiB;IAChC,wFAAwF;IACxF,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;CAC3F;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,YAAY,CAoDd"}

package/dist/types/providers/tools/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * providers/tools/ — Built-in ToolProvider implementations.
+ */
+export { staticTools } from './staticTools';
+export { dynamicTools } from './dynamicTools';
+export type { ToolResolver } from './dynamicTools';
+export { noTools } from './noTools';
+export { agentAsTool } from './agentAsTool';
+export type { AgentAsToolConfig } from './agentAsTool';
+export { compositeTools } from './compositeTools';
+export { gatedTools } from './gatedTools';
+export type { PermissionChecker, GatedToolsOptions } from './gatedTools';
+export { PermissionPolicy } from './PermissionPolicy';
+export type { PermissionPolicyOptions, PermissionChangeEvent } from './PermissionPolicy';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/providers/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/types/providers/tools/noTools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * noTools — ToolProvider that provides no tools.
+ */
+import type { ToolProvider } from '../../core';
+export declare function noTools(): ToolProvider;
+//# sourceMappingURL=noTools.d.ts.map

package/dist/types/providers/tools/noTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noTools.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/noTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,wBAAgB,OAAO,IAAI,YAAY,CAItC"}

package/dist/types/providers/tools/staticTools.d.ts

@@ -0,0 +1,7 @@
+/**
+ * staticTools — ToolProvider with a fixed list of tools.
+ */
+import type { ToolProvider } from '../../core';
+import type { ToolDefinition } from '../../types/tools';
+export declare function staticTools(tools: ToolDefinition[]): ToolProvider;
+//# sourceMappingURL=staticTools.d.ts.map

package/dist/types/providers/tools/staticTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticTools.d.ts","sourceRoot":"","sources":["../../../../src/providers/tools/staticTools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,YAAY,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,YAAY,CAsBjE"}

package/dist/types/providers.barrel.d.ts

@@ -0,0 +1,34 @@
+/**
+ * agentfootprint/providers — Connect to LLM providers.
+ *
+ * Import from here to connect your agent to Anthropic, OpenAI, Bedrock, Ollama, or mock.
+ *
+ * @example
+ * ```typescript
+ * import { mock, anthropic, createProvider } from 'agentfootprint/providers';
+ *
+ * // Testing — deterministic, $0
+ * const provider = mock([{ content: 'Hello!' }]);
+ *
+ * // Production — swap one line
+ * const provider = createProvider(anthropic('claude-sonnet-4-20250514'));
+ * ```
+ */
+export { anthropic, openai, ollama, bedrock } from './models';
+export type { ModelConfig, ModelOptions, ModelPricing } from './models';
+export { DEFAULT_PRICING, lookupPricing } from './models';
+export { MockAdapter, mock, MockRetriever, mockRetriever, createProvider } from './adapters';
+export { AnthropicAdapter, OpenAIAdapter, BedrockAdapter } from './adapters';
+export { BrowserAnthropicAdapter, BrowserOpenAIAdapter } from './adapters';
+export type { MockResponse, MockRetrievalResponse, AnthropicAdapterOptions, OpenAIAdapterOptions, BedrockAdapterOptions, BrowserAnthropicAdapterOptions, BrowserOpenAIAdapterOptions, } from './adapters';
+export { mcpToolProvider, a2aRunner } from './adapters';
+export type { MCPClient, MCPToolProviderOptions, A2AClient, A2ARunnerOptions } from './adapters';
+export type { LLMProvider, LLMCallOptions, LLMResponse, LLMStreamChunk, TokenUsage } from './types';
+export type { PromptProvider, PromptContext, ToolProvider, ToolContext, ToolExecutionResult } from './core';
+export { agentAsTool, compositeTools, gatedTools } from './providers';
+export type { AgentAsToolConfig } from './providers';
+export { staticPrompt, templatePrompt, skillBasedPrompt, compositePrompt } from './providers';
+export type { Skill, SkillBasedPromptOptions, CompositePromptOptions } from './providers';
+export { InMemoryStore } from './adapters/memory/inMemory';
+export type { ConversationStore, MemoryConfig } from './adapters/memory/types';
+//# sourceMappingURL=providers.barrel.d.ts.map

package/dist/types/providers.barrel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.barrel.d.ts","sourceRoot":"","sources":["../../src/providers.barrel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAC9D,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG1D,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC3E,YAAY,EACV,YAAY,EACZ,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACxD,YAAY,EAAE,SAAS,EAAE,sBAAsB,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGjG,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACpG,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAG5G,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACtE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrD,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9F,YAAY,EAAE,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAG1F,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC"}

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

@@ -0,0 +1,6 @@
+/**
+ * recorders/ — AgentRecorder implementations.
+ */
+export { TokenRecorder, CostRecorder, TurnRecorder, ToolUsageRecorder, QualityRecorder, GuardrailRecorder, CompositeRecorder, PermissionRecorder, agentObservability, } from './v2';
+export type { TokenStats, LLMCallEntry, CostEntry, CostRecorderOptions, TurnEntry, ToolUsageStats, ToolStats, QualityScore, QualityJudge, Violation, GuardrailCheck, PermissionEvent, AgentObservabilityOptions, AgentObservabilityRecorder, } from './v2';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/recorders/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,MAAM,CAAC;AACd,YAAY,EACV,UAAU,EACV,YAAY,EACZ,SAAS,EACT,mBAAmB,EACnB,SAAS,EACT,cAAc,EACd,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,eAAe,EACf,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,MAAM,CAAC"}

package/dist/types/recorders/v2/CompositeRecorder.d.ts

@@ -0,0 +1,30 @@
+/**
+ * CompositeRecorder — fans out events to multiple AgentRecorders.
+ *
+ * Convenience wrapper that dispatches each event to all child recorders.
+ * Error in one recorder does not affect others (error isolation).
+ *
+ * Usage:
+ *   const composite = new CompositeRecorder([
+ *     new TokenRecorder(),
+ *     new QualityRecorder(judge),
+ *     new GuardrailRecorder(check),
+ *   ]);
+ *   agent.recorder(composite);
+ */
+import type { AgentRecorder, TurnStartEvent, LLMCallEvent, ToolCallEvent, TurnCompleteEvent, AgentErrorEvent } from '../../core';
+export declare class CompositeRecorder implements AgentRecorder {
+    readonly id: string;
+    private readonly recorders;
+    constructor(recorders: readonly AgentRecorder[], id?: string);
+    onTurnStart(event: TurnStartEvent): void;
+    onLLMCall(event: LLMCallEvent): void;
+    onToolCall(event: ToolCallEvent): void;
+    onTurnComplete(event: TurnCompleteEvent): void;
+    onError(event: AgentErrorEvent): void;
+    clear(): void;
+    /** Access child recorders for inspection. */
+    getRecorders(): readonly AgentRecorder[];
+    private dispatch;
+}
+//# sourceMappingURL=CompositeRecorder.d.ts.map

package/dist/types/recorders/v2/CompositeRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/v2/CompositeRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,qBAAa,iBAAkB,YAAW,aAAa;IACrD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;gBAEzC,SAAS,EAAE,SAAS,aAAa,EAAE,EAAE,EAAE,SAAuB;IAK1E,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAIxC,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAIpC,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAItC,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAI9C,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAIrC,KAAK,IAAI,IAAI;IAUb,6CAA6C;IAC7C,YAAY,IAAI,SAAS,aAAa,EAAE;IAIxC,OAAO,CAAC,QAAQ;CAYjB"}

package/dist/types/recorders/v2/CostRecorder.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CostRecorder (v2) — calculates USD cost from AgentRecorder LLM call events.
+ *
+ * Unlike the v1 CostRecorder (which observes scope writes), this one
+ * receives structured LLMCallEvent objects from the core loop.
+ *
+ * Usage:
+ *   const cost = new CostRecorder({ pricingTable: { 'claude-sonnet': { input: 3, output: 15 } } });
+ *   agent.recorder(cost);
+ *   await agent.run(...);
+ *   console.log(`$${cost.getTotalCost().toFixed(4)}`);
+ */
+import type { AgentRecorder, LLMCallEvent } from '../../core';
+export interface ModelPricing {
+    /** Cost per 1M input tokens in USD. */
+    readonly input: number;
+    /** Cost per 1M output tokens in USD. */
+    readonly output: number;
+}
+export interface CostEntry {
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly inputCost: number;
+    readonly outputCost: number;
+    readonly totalCost: number;
+}
+export interface CostRecorderOptions {
+    readonly id?: string;
+    /** Pricing per model (per 1M tokens). Models not in this table get $0 cost. */
+    readonly pricingTable?: Record<string, ModelPricing>;
+}
+export declare class CostRecorder implements AgentRecorder {
+    readonly id: string;
+    private entries;
+    private pricingTable;
+    constructor(options?: CostRecorderOptions);
+    onLLMCall(event: LLMCallEvent): void;
+    getTotalCost(): number;
+    getEntries(): CostEntry[];
+    clear(): void;
+}
+//# sourceMappingURL=CostRecorder.d.ts.map

package/dist/types/recorders/v2/CostRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CostRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/v2/CostRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE9D,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACtD;AAED,qBAAa,YAAa,YAAW,aAAa;IAChD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,YAAY,CAA+B;gBAEvC,OAAO,GAAE,mBAAwB;IAK7C,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAmBpC,YAAY,IAAI,MAAM;IAItB,UAAU,IAAI,SAAS,EAAE;IAIzB,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/recorders/v2/ExplainRecorder.d.ts

@@ -0,0 +1,67 @@
+/**
+ * ExplainRecorder — collects grounding evidence during traversal.
+ *
+ * Captures sources (tool results), claims (LLM output), and decisions
+ * as they happen — no post-processing of narrative entries.
+ *
+ * Usage:
+ *   const explain = new ExplainRecorder();
+ *   agent.recorder(explain);
+ *   await agent.run('Check order');
+ *
+ *   explain.getSources();    // tool results (ground truth)
+ *   explain.getClaims();     // LLM responses (to verify)
+ *   explain.getDecisions();  // tool call decisions (what the LLM chose to do)
+ *   explain.explain();       // structured summary
+ */
+import type { AgentRecorder, LLMCallEvent, ToolCallEvent, TurnStartEvent, TurnCompleteEvent } from '../../core';
+/** A source of truth — data returned by a tool. */
+export interface ToolSource {
+    readonly toolName: string;
+    readonly args: Record<string, unknown>;
+    readonly result: string;
+    readonly turnNumber?: number;
+}
+/** A claim made by the LLM in its response. */
+export interface LLMClaim {
+    readonly content: string;
+    readonly model?: string;
+    readonly iteration: number;
+}
+/** A decision the LLM made (tool call). */
+export interface AgentDecision {
+    readonly toolName: string;
+    readonly args: Record<string, unknown>;
+    readonly latencyMs: number;
+}
+/** Structured explanation of an agent's execution. */
+export interface Explanation {
+    readonly sources: readonly ToolSource[];
+    readonly claims: readonly LLMClaim[];
+    readonly decisions: readonly AgentDecision[];
+    readonly summary: string;
+}
+export declare class ExplainRecorder implements AgentRecorder {
+    readonly id: string;
+    private sources;
+    private claims;
+    private decisions;
+    private currentTurn;
+    constructor(id?: string);
+    onTurnStart(event: TurnStartEvent): void;
+    private lastModel?;
+    private lastIteration;
+    onLLMCall(event: LLMCallEvent): void;
+    onToolCall(event: ToolCallEvent): void;
+    onTurnComplete(event: TurnCompleteEvent): void;
+    /** Tool results — the ground truth data. */
+    getSources(): readonly ToolSource[];
+    /** LLM responses — what it claimed. */
+    getClaims(): readonly LLMClaim[];
+    /** Tool call decisions — what the LLM chose to do. Returns snapshot-safe copies. */
+    getDecisions(): readonly AgentDecision[];
+    /** Structured explanation of the agent's execution. */
+    explain(): Explanation;
+    clear(): void;
+}
+//# sourceMappingURL=ExplainRecorder.d.ts.map

package/dist/types/recorders/v2/ExplainRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExplainRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/v2/ExplainRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,mDAAmD;AACnD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,+CAA+C;AAC/C,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,2CAA2C;AAC3C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,SAAS,aAAa,EAAE,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,eAAgB,YAAW,aAAa;IACnD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,WAAW,CAAK;gBAEZ,EAAE,SAAqB;IAInC,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAIxC,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAK;IAE1B,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAMpC,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAiBtC,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAS9C,4CAA4C;IAC5C,UAAU,IAAI,SAAS,UAAU,EAAE;IAInC,uCAAuC;IACvC,SAAS,IAAI,SAAS,QAAQ,EAAE;IAIhC,oFAAoF;IACpF,YAAY,IAAI,SAAS,aAAa,EAAE;IAIxC,uDAAuD;IACvD,OAAO,IAAI,WAAW;IActB,KAAK,IAAI,IAAI;CAQd"}

package/dist/types/recorders/v2/GuardrailRecorder.d.ts

@@ -0,0 +1,45 @@
+/**
+ * GuardrailRecorder — checks safety/policy constraints during execution.
+ *
+ * Calls a check function on each turn completion. If the check returns
+ * a violation, it is recorded. Violations can be reviewed after execution
+ * or used to trigger alerts.
+ *
+ * The check function receives the turn completion event and returns
+ * either null (no violation) or a Violation object.
+ *
+ * Usage:
+ *   const guardrail = new GuardrailRecorder(async (event) => {
+ *     if (event.content.includes('CONFIDENTIAL')) {
+ *       return { rule: 'pii-leak', message: 'Output contains confidential data' };
+ *     }
+ *     return null;
+ *   });
+ *   agent.recorder(guardrail);
+ *   await agent.run(...);
+ *   if (guardrail.hasViolations()) { ... }
+ */
+import type { AgentRecorder, TurnCompleteEvent } from '../../core';
+export interface Violation {
+    /** Rule or policy that was violated. */
+    readonly rule: string;
+    /** Human-readable description. */
+    readonly message: string;
+    /** Severity level. Defaults to 'warning'. */
+    readonly severity?: 'info' | 'warning' | 'error';
+    /** Which turn triggered the violation. */
+    readonly turnNumber: number;
+}
+export type GuardrailCheck = (event: TurnCompleteEvent) => Violation | null | Promise<Violation | null>;
+export declare class GuardrailRecorder implements AgentRecorder {
+    readonly id: string;
+    private readonly check;
+    private violations;
+    constructor(check: GuardrailCheck, id?: string);
+    onTurnComplete(event: TurnCompleteEvent): void;
+    getViolations(): Violation[];
+    hasViolations(): boolean;
+    getViolationsByRule(rule: string): Violation[];
+    clear(): void;
+}
+//# sourceMappingURL=GuardrailRecorder.d.ts.map

package/dist/types/recorders/v2/GuardrailRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GuardrailRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/v2/GuardrailRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAInE,MAAM,WAAW,SAAS;IACxB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACjD,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,cAAc,GAAG,CAC3B,KAAK,EAAE,iBAAiB,KACrB,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;AAIlD,qBAAa,iBAAkB,YAAW,aAAa;IACrD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,UAAU,CAAmB;gBAEzB,KAAK,EAAE,cAAc,EAAE,EAAE,SAAuB;IAK5D,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAa9C,aAAa,IAAI,SAAS,EAAE;IAI5B,aAAa,IAAI,OAAO;IAIxB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE;IAI9C,KAAK,IAAI,IAAI;CAGd"}

package/dist/types/recorders/v2/OTelRecorder.d.ts

@@ -0,0 +1,50 @@
+/**
+ * OTelRecorder — exports agent events as OpenTelemetry spans.
+ *
+ * Takes a duck-typed Tracer from the consumer — zero @opentelemetry dependency in core.
+ * Follows OpenTelemetry Semantic Conventions for GenAI where applicable.
+ *
+ * Usage:
+ *   import { trace } from '@opentelemetry/api';
+ *   import { OTelRecorder } from 'agentfootprint/observe';
+ *
+ *   const recorder = new OTelRecorder(trace.getTracer('agentfootprint'));
+ *   agent.recorder(recorder);
+ */
+import type { AgentRecorder, TurnStartEvent, LLMCallEvent, ToolCallEvent, TurnCompleteEvent, AgentErrorEvent } from '../../core';
+/** Duck-typed OpenTelemetry Span — no @opentelemetry/api dependency. */
+interface OTelSpan {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setStatus?(status: {
+        code: number;
+        message?: string;
+    }): void;
+    end(): void;
+}
+/** Duck-typed OpenTelemetry Tracer — consumer provides their own. */
+export interface OTelTracer {
+    startSpan(name: string, options?: {
+        attributes?: Record<string, string | number | boolean>;
+    }): OTelSpan;
+}
+export interface OTelRecorderOptions {
+    /** Recorder ID. Default: 'otel-recorder'. */
+    id?: string;
+    /** Service name for span attributes. Default: 'agentfootprint'. */
+    serviceName?: string;
+}
+export declare class OTelRecorder implements AgentRecorder {
+    readonly id: string;
+    private readonly tracer;
+    private readonly serviceName;
+    private turnSpan?;
+    constructor(tracer: OTelTracer, options?: OTelRecorderOptions);
+    onTurnStart(event: TurnStartEvent): void;
+    onLLMCall(event: LLMCallEvent): void;
+    onToolCall(event: ToolCallEvent): void;
+    onTurnComplete(event: TurnCompleteEvent): void;
+    onError(event: AgentErrorEvent): void;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=OTelRecorder.d.ts.map

package/dist/types/recorders/v2/OTelRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OTelRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/v2/OTelRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,wEAAwE;AACxE,UAAU,QAAQ;IAChB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAClE,SAAS,CAAC,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7D,GAAG,IAAI,IAAI,CAAC;CACb;AAED,qEAAqE;AACrE,MAAM,WAAW,UAAU;IACzB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAA;KAAE,GAAG,QAAQ,CAAC;CACzG;AAED,MAAM,WAAW,mBAAmB;IAClC,6CAA6C;IAC7C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,YAAa,YAAW,aAAa;IAChD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,CAAW;gBAEhB,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,mBAAmB;IAM7D,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IASxC,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAepC,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAWtC,cAAc,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAS9C,OAAO,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAYrC,KAAK,IAAI,IAAI;CAGd"}