@frontmcp/sdk 0.6.2 → 0.7.1

package/agent/flows/call-agent.flow.d.ts

@@ -0,0 +1,306 @@
+import { FlowBase, FlowRunOptions, AgentContext, AgentEntry } from '../../common';
+import { z } from 'zod';
+import { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+declare const inputSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        method: z.ZodLiteral<"tools/call">;
+        params: z.ZodObject<{
+            _meta: z.ZodOptional<z.ZodObject<{
+                progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": z.ZodOptional<z.ZodObject<{
+                    taskId: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$loose>>;
+            task: z.ZodOptional<z.ZodObject<{
+                ttl: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            name: z.ZodString;
+            arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    ctx: z.ZodAny;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodObject<{
+        progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        "io.modelcontextprotocol/related-task": z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
+    content: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+        annotations: z.ZodOptional<z.ZodObject<{
+            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            lastModified: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+        annotations: z.ZodOptional<z.ZodObject<{
+            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            lastModified: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"audio">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+        annotations: z.ZodOptional<z.ZodObject<{
+            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            lastModified: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        uri: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+        annotations: z.ZodOptional<z.ZodObject<{
+            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            lastModified: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        icons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            src: z.ZodString;
+            mimeType: z.ZodOptional<z.ZodString>;
+            sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            theme: z.ZodOptional<z.ZodEnum<{
+                light: "light";
+                dark: "dark";
+            }>>;
+        }, z.core.$strip>>>;
+        name: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        type: z.ZodLiteral<"resource_link">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<readonly [z.ZodObject<{
+            uri: z.ZodString;
+            mimeType: z.ZodOptional<z.ZodString>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            uri: z.ZodString;
+            mimeType: z.ZodOptional<z.ZodString>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            blob: z.ZodString;
+        }, z.core.$strip>]>;
+        annotations: z.ZodOptional<z.ZodObject<{
+            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            lastModified: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>]>>>;
+    structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    isError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+declare const stateSchema: z.ZodObject<{
+    input: z.ZodObject<{
+        name: z.ZodString;
+        arguments: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>;
+    authInfo: z.ZodType<AuthInfo>;
+    agent: z.ZodCustom<AgentEntry<import("../../common").ToolInputType, import("../../common").ToolOutputType, unknown, unknown>, AgentEntry<import("../../common").ToolInputType, import("../../common").ToolOutputType, unknown, unknown>>;
+    agentContext: z.ZodCustom<AgentContext<import("../../common").ToolInputType, import("../../common").ToolOutputType, unknown, unknown>, AgentContext<import("../../common").ToolInputType, import("../../common").ToolOutputType, unknown, unknown>>;
+    rawOutput: z.ZodOptional<z.ZodAny>;
+    output: z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{
+            progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            "io.modelcontextprotocol/related-task": z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        content: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+            annotations: z.ZodOptional<z.ZodObject<{
+                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    user: "user";
+                    assistant: "assistant";
+                }>>>;
+                priority: z.ZodOptional<z.ZodNumber>;
+                lastModified: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            data: z.ZodString;
+            mimeType: z.ZodString;
+            annotations: z.ZodOptional<z.ZodObject<{
+                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    user: "user";
+                    assistant: "assistant";
+                }>>>;
+                priority: z.ZodOptional<z.ZodNumber>;
+                lastModified: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"audio">;
+            data: z.ZodString;
+            mimeType: z.ZodString;
+            annotations: z.ZodOptional<z.ZodObject<{
+                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    user: "user";
+                    assistant: "assistant";
+                }>>>;
+                priority: z.ZodOptional<z.ZodNumber>;
+                lastModified: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            uri: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+            annotations: z.ZodOptional<z.ZodObject<{
+                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    user: "user";
+                    assistant: "assistant";
+                }>>>;
+                priority: z.ZodOptional<z.ZodNumber>;
+                lastModified: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>>;
+            _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+            icons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                src: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+                sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                theme: z.ZodOptional<z.ZodEnum<{
+                    light: "light";
+                    dark: "dark";
+                }>>;
+            }, z.core.$strip>>>;
+            name: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            type: z.ZodLiteral<"resource_link">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"resource">;
+            resource: z.ZodUnion<readonly [z.ZodObject<{
+                uri: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+                _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                uri: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+                _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                blob: z.ZodString;
+            }, z.core.$strip>]>;
+            annotations: z.ZodOptional<z.ZodObject<{
+                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    user: "user";
+                    assistant: "assistant";
+                }>>>;
+                priority: z.ZodOptional<z.ZodNumber>;
+                lastModified: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strip>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>]>>>;
+        structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        isError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    _agentOwnerId: z.ZodOptional<z.ZodString>;
+    progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    executionMeta: z.ZodOptional<z.ZodObject<{
+        iterations: z.ZodOptional<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        usage: z.ZodOptional<z.ZodObject<{
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            completionTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const plan: {
+    readonly pre: ["parseInput", "findAgent", "checkAgentAuthorization", "createAgentContext", "acquireQuota", "acquireSemaphore"];
+    readonly execute: ["validateInput", "execute", "validateOutput"];
+    readonly finalize: ["releaseSemaphore", "releaseQuota", "finalize"];
+};
+declare global {
+    interface ExtendFlows {
+        'agents:call-agent': FlowRunOptions<CallAgentFlow, typeof plan, typeof inputSchema, typeof outputSchema, typeof stateSchema>;
+    }
+}
+declare const name: "agents:call-agent";
+export default class CallAgentFlow extends FlowBase<typeof name> {
+    logger: import("../../common").FrontMcpLogger;
+    /**
+     * Parse and validate the incoming request.
+     */
+    parseInput(): Promise<void>;
+    /**
+     * Find the agent in the registry.
+     */
+    findAgent(): Promise<void>;
+    /**
+     * Check if the agent's parent app is authorized.
+     */
+    checkAgentAuthorization(): Promise<void>;
+    /**
+     * Create the agent execution context.
+     */
+    createAgentContext(): Promise<void>;
+    /**
+     * Acquire quota for rate limiting.
+     */
+    acquireQuota(): Promise<void>;
+    /**
+     * Acquire semaphore for concurrency control.
+     */
+    acquireSemaphore(): Promise<void>;
+    /**
+     * Validate the agent input against its schema.
+     */
+    validateInput(): Promise<void>;
+    /**
+     * Execute the agent.
+     */
+    execute(): Promise<void>;
+    /**
+     * Validate the agent output.
+     */
+    validateOutput(): Promise<void>;
+    /**
+     * Release the semaphore.
+     */
+    releaseSemaphore(): Promise<void>;
+    /**
+     * Release the quota.
+     */
+    releaseQuota(): Promise<void>;
+    /**
+     * Finalize the agent response.
+     *
+     * Validates output and sends the response.
+     *
+     * Note: This stage runs even when execute fails (as part of cleanup).
+     * If rawOutput is undefined, it means an error occurred during execution
+     * and the error will be propagated by the flow framework - we should not
+     * throw a new error here.
+     */
+    finalize(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=call-agent.flow.d.ts.map

package/agent/flows/call-agent.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-agent.flow.d.ts","sourceRoot":"","sources":["../../../src/agent/flows/call-agent.flow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAQ,QAAQ,EAAyB,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/G,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,gDAAgD,CAAC;AAc1E,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;iBAIf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAuB,CAAC;AAE1C,QAAA,MAAM,WAAW;;;;;cAKiB,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBnD,CAAC;AAMH,QAAA,MAAM,IAAI;;;;CAI2B,CAAC;AAMtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,mBAAmB,EAAE,cAAc,CACjC,aAAa,EACb,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,mBAA4B,CAAC;AAc1C,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAC9D,MAAM,wCAA2C;IAEjD;;OAEG;IAEG,UAAU;IA4ChB;;OAEG;IAEG,SAAS;IA2Cf;;OAEG;IAEG,uBAAuB;IAuC7B;;OAEG;IAEG,kBAAkB;IAmCxB;;OAEG;IAEG,YAAY;IAOlB;;OAEG;IAEG,gBAAgB;IAOtB;;OAEG;IAEG,aAAa;IAsBnB;;OAEG;IAEG,OAAO;IA0Bb;;OAEG;IAEG,cAAc;IAcpB;;OAEG;IAEG,gBAAgB;IAOtB;;OAEG;IAEG,YAAY;IAOlB;;;;;;;;;OASG;IAEG,QAAQ;CA2Df"}

package/agent/flows/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CallAgentFlow } from './call-agent.flow';
+//# sourceMappingURL=index.d.ts.map

package/agent/flows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agent/flows/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mBAAmB,CAAC"}

package/agent/hooks/agent.hooks.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Hook decorators for the call-agent flow.
+ *
+ * Use these decorators to hook into agent execution stages:
+ *
+ * @example
+ * ```typescript
+ * import { AgentHook } from '@frontmcp/sdk';
+ *
+ * @Agent({
+ *   name: 'my-agent',
+ *   // ...
+ * })
+ * export class MyAgent extends AgentContext {
+ *   @AgentHook.Will.execute()
+ *   onBeforeExecute() {
+ *     this.logger.info('About to execute agent...');
+ *   }
+ *
+ *   @AgentHook.Did.execute()
+ *   onAfterExecute() {
+ *     this.logger.info('Agent execution completed');
+ *   }
+ *
+ *   @AgentHook.Stage('validateInput')
+ *   onValidateInput() {
+ *     this.logger.info('Validating input...');
+ *   }
+ * }
+ * ```
+ */
+declare const Will: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("../../common").HookOptions<import("..").CallAgentFlow>) => MethodDecorator, Did: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("../../common").HookOptions<import("..").CallAgentFlow>) => MethodDecorator, Stage: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("../../common").HookOptions<import("..").CallAgentFlow>) => MethodDecorator;
+/**
+ * Agent hook decorators for the call-agent flow.
+ *
+ * Available hooks:
+ * - `AgentHook.Will.*` - Run before a stage
+ * - `AgentHook.Did.*` - Run after a stage
+ * - `AgentHook.Stage(name)` - Run at a specific stage
+ *
+ * Stages available:
+ * - Pre stages: parseInput, findAgent, checkAgentAuthorization, createAgentContext, acquireQuota, acquireSemaphore
+ * - Execute stages: validateInput, execute, validateOutput
+ * - Finalize stages: releaseSemaphore, releaseQuota, finalize
+ */
+export declare const AgentHook: {
+    Will: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("../../common").HookOptions<import("..").CallAgentFlow>) => MethodDecorator;
+    Did: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("../../common").HookOptions<import("..").CallAgentFlow>) => MethodDecorator;
+    Stage: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("../../common").HookOptions<import("..").CallAgentFlow>) => MethodDecorator;
+};
+export { Will as WillAgentStage, Did as DidAgentStage, Stage as OnAgentStage };
+//# sourceMappingURL=agent.hooks.d.ts.map

package/agent/hooks/agent.hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.hooks.d.ts","sourceRoot":"","sources":["../../../src/agent/hooks/agent.hooks.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,QAAA,MAAQ,IAAI,8TAAE,GAAG,8TAAE,KAAK,4TAA0D,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS;;;;CAAuB,CAAC;AAG9C,OAAO,EAAE,IAAI,IAAI,cAAc,EAAE,GAAG,IAAI,aAAa,EAAE,KAAK,IAAI,YAAY,EAAE,CAAC"}

package/agent/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './agent.hooks';
+//# sourceMappingURL=index.d.ts.map

package/agent/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agent/hooks/index.ts"],"names":[],"mappings":"AAEA,cAAc,eAAe,CAAC"}

package/agent/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Agent system for FrontMCP SDK.
+ *
+ * This module provides the infrastructure for creating autonomous AI agents
+ * that can have their own LLM providers, isolated scopes, and be invoked as tools.
+ *
+ * @example Creating an agent
+ * ```typescript
+ * import { Agent, AgentContext } from '@frontmcp/sdk';
+ * import { z } from 'zod';
+ *
+ * @Agent({
+ *   name: 'research-agent',
+ *   description: 'Researches topics and compiles reports',
+ *   systemInstructions: 'You are a research assistant...',
+ *   inputSchema: {
+ *     topic: z.string().describe('Topic to research'),
+ *   },
+ *   llm: {
+ *     adapter: 'openai',
+ *     model: 'gpt-4-turbo',
+ *     apiKey: { env: 'OPENAI_API_KEY' },
+ *   },
+ *   tools: [WebSearchTool, SummarizeTool],
+ * })
+ * export default class ResearchAgent extends AgentContext {
+ *   async execute(input: { topic: string }) {
+ *     // Agent implementation
+ *     return { summary: 'Research results...' };
+ *   }
+ * }
+ * ```
+ *
+ * @module agent
+ */
+export * from './agent.events';
+export * from './agent.utils';
+export { AgentInstance } from './agent.instance';
+export { default as AgentRegistry, IndexedAgent } from './agent.registry';
+export * from './agent-execution-loop';
+export * from './flows';
+export * from './hooks';
+export * from './adapters';
+export { AgentContext, AgentCtorArgs } from '../common/interfaces/agent.interface';
+export { AgentEntry, AgentCallArgs, AgentCallExtra, ParsedAgentResult } from '../common/entries/agent.entry';
+export { AgentMetadata, AgentLlmConfig, AgentLlmBuiltinConfig, AgentLlmAdapterConfig, AgentSwarmConfig, AgentExecutionConfig, AgentExportsConfig, AgentApiKeyConfig, AgentLlmProviderType, WithConfig, withConfig, AgentType, frontMcpAgentMetadataSchema, } from '../common/metadata/agent.metadata';
+export { annotatedFrontMcpAgentsSchema } from '../common/schemas';
+export { AgentRecord, AgentKind, AgentClassTokenRecord, AgentFunctionTokenRecord, AgentValueRecord, AgentFactoryRecord, } from '../common/records/agent.record';
+export { FrontMcpAgentTokens, extendedAgentMetadata } from '../common/tokens/agent.tokens';
+export { Agent, FrontMcpAgent, agent, frontMcpAgent, AgentInputOf, AgentOutputOf, FrontMcpAgentExecuteHandler, } from '../common/decorators/agent.decorator';
+//# sourceMappingURL=index.d.ts.map

package/agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1E,cAAc,wBAAwB,CAAC;AAGvC,cAAc,SAAS,CAAC;AAGxB,cAAc,SAAS,CAAC;AAGxB,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAEnF,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAE7G,OAAO,EACL,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,UAAU,EACV,UAAU,EACV,SAAS,EACT,2BAA2B,GAC5B,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EACL,WAAW,EACX,SAAS,EACT,qBAAqB,EACrB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3F,OAAO,EACL,KAAK,EACL,aAAa,EACb,KAAK,EACL,aAAa,EACb,YAAY,EACZ,aAAa,EACb,2BAA2B,GAC5B,MAAM,sCAAsC,CAAC"}

package/app/app.registry.d.ts

@@ -11,3 +11,4 @@ export default class AppRegistry extends RegistryAbstract<AppEntry, AppRecord, A
     protected initialize(): Promise<void>;
     getApps(): AppEntry[];
 }
+//# sourceMappingURL=app.registry.d.ts.map

package/app/app.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.registry.d.ts","sourceRoot":"","sources":["../../src/app/app.registry.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAW,SAAS,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAEjF,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAGvE,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,gBAAgB,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;IACvF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;gBAE1B,eAAe,EAAE,gBAAgB,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,aAAa;IAKpF,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,sBAAsB,CAAC,SAAS,CAAC;IActE,SAAS,CAAC,UAAU;IAapB,0EAA0E;cAC1D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB3C,OAAO,IAAI,QAAQ,EAAE;CAGtB"}

package/app/app.utils.d.ts

@@ -1,4 +1,5 @@
-import { LocalAppMetadata, AppType, Token, AppRecord } from '../common';
+import { Token } from '@frontmcp/di';
+import { LocalAppMetadata, AppType, AppRecord } from '../common';
 export declare function collectAppMetadata(cls: AppType): LocalAppMetadata;
 /**
  * Normalize a raw app metadata list into useful maps/sets.
@@ -13,3 +14,4 @@ export declare function normalizeApp(item: AppType): AppRecord;
  * - LOCAL_CLASS: deps come from the class constructor
  */
 export declare function appDiscoveryDeps(rec: AppRecord): Token[];
+//# sourceMappingURL=app.utils.d.ts.map

package/app/app.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.utils.d.ts","sourceRoot":"","sources":["../../src/app/app.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,EAAqC,MAAM,cAAc,CAAC;AAE9E,OAAO,EACL,gBAAgB,EAEhB,OAAO,EACP,SAAS,EAIV,MAAM,WAAW,CAAC;AAGnB,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAMjE;AAmBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAwCrD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,GAAG,KAAK,EAAE,CAOxD"}

package/app/instances/app.local.instance.d.ts

@@ -5,6 +5,7 @@ import ResourceRegistry from '../../resource/resource.registry';
 import PromptRegistry from '../../prompt/prompt.registry';
 import AdapterRegistry from '../../adapter/adapter.regsitry';
 import PluginRegistry from '../../plugin/plugin.registry';
+import AgentRegistry from '../../agent/agent.registry';
 export declare class AppLocalInstance extends AppEntry<LocalAppMetadata> {
     readonly id: string;
     private scopeProviders;
@@ -14,6 +15,7 @@ export declare class AppLocalInstance extends AppEntry<LocalAppMetadata> {
     private appTools;
     private appResources;
     private appPrompts;
+    private appAgents;
     constructor(record: AppRecord, scopeProviders: ProviderRegistry);
     protected initialize(): Promise<void>;
     get providers(): Readonly<ProviderRegistry>;
@@ -22,4 +24,6 @@ export declare class AppLocalInstance extends AppEntry<LocalAppMetadata> {
     get tools(): Readonly<ToolRegistry>;
     get resources(): Readonly<ResourceRegistry>;
     get prompts(): Readonly<PromptRegistry>;
+    get agents(): Readonly<AgentRegistry>;
 }
+//# sourceMappingURL=app.local.instance.d.ts.map

package/app/instances/app.local.instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.local.instance.d.ts","sourceRoot":"","sources":["../../../src/app/instances/app.local.instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErE,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAChE,OAAO,YAAY,MAAM,0BAA0B,CAAC;AACpD,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAChE,OAAO,cAAc,MAAM,8BAA8B,CAAC;AAC1D,OAAO,eAAe,MAAM,gCAAgC,CAAC;AAC7D,OAAO,cAAmC,MAAM,8BAA8B,CAAC;AAC/E,OAAO,aAAa,MAAM,4BAA4B,CAAC;AAEvD,qBAAa,gBAAiB,SAAQ,QAAQ,CAAC,gBAAgB,CAAC;IAC9D,SAAkB,EAAE,EAAE,MAAM,CAAC;IAE7B,OAAO,CAAC,cAAc,CAAmB;IACzC,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,SAAS,CAAgB;gBAErB,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB;cAO/C,UAAU;IAuC1B,IAAI,SAAS,IAAI,QAAQ,CAAC,gBAAgB,CAAC,CAE1C;IAED,IAAI,QAAQ,IAAI,QAAQ,CAAC,eAAe,CAAC,CAExC;IAED,IAAI,OAAO,IAAI,QAAQ,CAAC,cAAc,CAAC,CAEtC;IAED,IAAI,KAAK,IAAI,QAAQ,CAAC,YAAY,CAAC,CAElC;IAED,IAAI,SAAS,IAAI,QAAQ,CAAC,gBAAgB,CAAC,CAE1C;IAED,IAAI,OAAO,IAAI,QAAQ,CAAC,cAAc,CAAC,CAEtC;IAED,IAAI,MAAM,IAAI,QAAQ,CAAC,aAAa,CAAC,CAEpC;CACF"}

package/app/instances/app.remote.instance.d.ts

@@ -1,13 +1,111 @@
+/**
+ * @file app.remote.instance.ts
+ * @description Remote MCP app instance that proxies to a remote MCP server
+ *
+ * This implementation uses standard registries (ToolRegistry, ResourceRegistry, PromptRegistry)
+ * like local apps, but with lazy capability discovery and TTL-based caching.
+ */
 import { AdapterRegistryInterface, AppEntry, AppRecord, PluginRegistryInterface, PromptRegistryInterface, ProviderRegistryInterface, RemoteAppMetadata, ResourceRegistryInterface, ToolRegistryInterface } from '../../common';
 import ProviderRegistry from '../../provider/provider.registry';
+import { McpClientService } from '../../remote-mcp';
+/**
+ * Remote MCP app instance that connects to and proxies a remote MCP server.
+ *
+ * This class uses standard registries (ToolRegistry, ResourceRegistry, PromptRegistry)
+ * like local apps, providing consistent behavior for:
+ * - Hook lifecycle (beforeExec, afterExec)
+ * - Tool/resource/prompt discovery
+ * - Change event notifications
+ *
+ * Key features:
+ * - Lazy capability discovery: Capabilities are discovered on first access
+ * - TTL-based caching: Capabilities are cached with configurable TTL
+ * - Full hook support: Remote tools participate in the hook lifecycle
+ */
 export declare class AppRemoteInstance extends AppEntry<RemoteAppMetadata> {
     readonly id: string;
+    /**
+     * Remote apps return true to indicate entries should be adopted directly
+     * from the app's registries rather than through child registry hierarchy.
+     */
+    get isRemote(): boolean;
+    private readonly scopeProviders;
+    private readonly mcpClient;
+    private readonly appOwner;
+    private readonly capabilityCache;
+    private readonly _tools;
+    private readonly _resources;
+    private readonly _prompts;
+    private readonly _plugins;
+    private readonly _adapters;
+    private isConnected;
+    private capabilitiesLoaded;
+    private loadingPromise;
+    private _unsubscribeCapability?;
     constructor(record: AppRecord, scopeProviders: ProviderRegistry);
     protected initialize(): Promise<void>;
+    /**
+     * Ensure capabilities are loaded, using cache if available.
+     * This is called lazily when tools/resources/prompts are accessed.
+     */
+    ensureCapabilitiesLoaded(): Promise<void>;
+    /**
+     * Force refresh capabilities from the remote server.
+     */
+    refreshCapabilities(): Promise<void>;
     get providers(): ProviderRegistryInterface;
     get adapters(): AdapterRegistryInterface;
     get plugins(): PluginRegistryInterface;
     get tools(): ToolRegistryInterface;
     get resources(): ResourceRegistryInterface;
     get prompts(): PromptRegistryInterface;
+    /**
+     * Get the MCP client service for this remote app
+     */
+    getMcpClient(): McpClientService;
+    /**
+     * Check if this remote app is connected
+     */
+    getIsConnected(): boolean;
+    /**
+     * Check if capabilities have been loaded
+     */
+    getCapabilitiesLoaded(): boolean;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        totalEntries: number;
+        activeEntries: number;
+        expiredEntries: number;
+    };
+    /**
+     * Disconnect from the remote server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Reconnect to the remote server
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Get or create the MCP client service from scope
+     */
+    private getOrCreateMcpClientService;
+    /**
+     * Build the connection request from metadata
+     */
+    private buildConnectRequest;
+    /**
+     * Map urlType to transport type
+     */
+    private mapUrlTypeToTransportType;
+    /**
+     * Map remote auth config from metadata format to MCP client format
+     */
+    private mapRemoteAuth;
+    /**
+     * Discover remote capabilities and register them in standard registries.
+     */
+    private discoverAndRegisterCapabilities;
 }
+//# sourceMappingURL=app.remote.instance.d.ts.map

package/app/instances/app.remote.instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.remote.instance.d.ts","sourceRoot":"","sources":["../../../src/app/instances/app.remote.instance.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,wBAAwB,EACxB,QAAQ,EACR,SAAS,EACT,uBAAuB,EACvB,uBAAuB,EACvB,yBAAyB,EACzB,iBAAiB,EAEjB,yBAAyB,EACzB,qBAAqB,EAKtB,MAAM,cAAc,CAAC;AAEtB,OAAO,gBAAgB,MAAM,kCAAkC,CAAC;AAIhE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAyCpD;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAkB,SAAQ,QAAQ,CAAC,iBAAiB,CAAC;IAChE,SAAkB,EAAE,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,IAAa,QAAQ,IAAI,OAAO,CAE/B;IAED,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAGlD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAGjD,OAAO,CAAC,WAAW,CAAS;IAG5B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,cAAc,CAA8B;IAGpD,OAAO,CAAC,sBAAsB,CAAC,CAAa;gBAEhC,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB;cA8B/C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC3C;;;OAGG;IACG,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB/C;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAU1C,IAAa,SAAS,IAAI,yBAAyB,CAElD;IAED,IAAa,QAAQ,IAAI,wBAAwB,CAEhD;IAED,IAAa,OAAO,IAAI,uBAAuB,CAE9C;IAED,IAAa,KAAK,IAAI,qBAAqB,CAE1C;IAED,IAAa,SAAS,IAAI,yBAAyB,CAElD;IAED,IAAa,OAAO,IAAI,uBAAuB,CAE9C;IAED;;OAEG;IACH,YAAY,IAAI,gBAAgB;IAIhC;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,qBAAqB,IAAI,OAAO;IAIhC;;OAEG;IACH,aAAa,IAAI;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE;IAIxF;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAejC;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAWhC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAkBnC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAejC;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;OAEG;YACW,+BAA+B;CAgF9C"}

package/app/instances/index.d.ts

@@ -1,2 +1,3 @@
 export * from './app.local.instance';
 export * from './app.remote.instance';
+//# sourceMappingURL=index.d.ts.map

package/app/instances/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/app/instances/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

package/auth/auth.registry.d.ts

@@ -43,3 +43,4 @@ export declare class AuthRegistry extends RegistryAbstract<AuthProviderEntry, Au
     getPrimary(): FrontMcpAuth;
     getAuthProviders(): AuthProviderEntry[];
 }
+//# sourceMappingURL=auth.registry.d.ts.map

package/auth/auth.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.registry.d.ts","sourceRoot":"","sources":["../../src/auth/auth.registry.ts"],"names":[],"mappings":"AACA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EACL,YAAY,EAEZ,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAElB,aAAa,EAEb,UAAU,EAEV,gBAAgB,EAQjB,MAAM,WAAW,CAAC;AAInB,OAAO,EAAuB,2BAA2B,EAAe,MAAM,aAAa,CAAC;AAY5F,qBAAa,YACX,SAAQ,gBAAgB,CAAC,iBAAiB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,CAClF,YAAW,qBAAqB;IAEhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAc;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IAEtC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,2BAA2B,CAAC;IAEhD;;OAEG;IACH,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;gBAGtC,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,gBAAgB,EAC3B,QAAQ,EAAE,gBAAgB,EAAE,EAC5B,KAAK,EAAE,aAAa,EACpB,YAAY,CAAC,EAAE,gBAAgB;IAuCjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;IACH,OAAO,CAAC,cAAc;IA0BtB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;cAwBN,QAAQ,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,sBAAsB,CAAC,kBAAkB,CAAC;IAgBjG,SAAS,CAAC,UAAU;cAqBJ,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3C,UAAU,IAAI,YAAY;IAO1B,gBAAgB,IAAI,iBAAiB,EAAE;CAGxC"}

package/auth/auth.utils.d.ts

@@ -1,4 +1,5 @@
-import { AuthProviderMetadata, AuthProviderType, Token, AuthProviderRecord } from '../common';
+import { Token } from '@frontmcp/di';
+import { AuthProviderMetadata, AuthProviderType, AuthProviderRecord } from '../common';
 export declare function collectAuthMetadata(cls: AuthProviderType): AuthProviderMetadata;
 export declare function normalizeAuth(item: AuthProviderType): AuthProviderRecord;
 /**
@@ -8,3 +9,4 @@ export declare function normalizeAuth(item: AuthProviderType): AuthProviderRecor
  * - CLASS / CLASS_TOKEN: deps come from the class constructor or static with(...)
  */
 export declare function authDiscoveryDeps(rec: AuthProviderRecord): Token[];
+//# sourceMappingURL=auth.utils.d.ts.map

package/auth/auth.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.utils.d.ts","sourceRoot":"","sources":["../../src/auth/auth.utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAgD,MAAM,cAAc,CAAC;AACnF,OAAO,EACL,oBAAoB,EAEpB,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,WAAW,CAAC;AAEnB,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,oBAAoB,CAM/E;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG,kBAAkB,CAoDxE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,GAAG,KAAK,EAAE,CAelE"}