@frontmcp/sdk 0.6.3 → 0.7.2

package/esm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/sdk",
-  "version": "0.6.3",
+  "version": "0.7.2",
   "description": "FrontMCP SDK",
   "author": "AgentFront <info@agentfront.dev>",
   "homepage": "https://docs.agentfront.dev",
@@ -40,16 +40,6 @@
         "default": "./index.mjs"
       }
     },
-    "./mcp-apps": {
-      "require": {
-        "types": "../mcp-apps/index.d.ts",
-        "default": "../mcp-apps/index.js"
-      },
-      "import": {
-        "types": "../mcp-apps/index.d.ts",
-        "default": "./mcp-apps/index.mjs"
-      }
-    },
     "./transport": {
       "require": {
         "types": "../transport/index.d.ts",
@@ -76,12 +66,22 @@
     }
   },
   "dependencies": {
-    "@frontmcp/uipack": "0.6.3",
+    "@frontmcp/utils": "0.7.2",
+    "@frontmcp/di": "0.7.2",
+    "@frontmcp/uipack": "0.7.2",
     "@modelcontextprotocol/sdk": "1.25.1",
+    "@langchain/core": "^1.1.8",
+    "@langchain/openai": "^1.2.0",
+    "@langchain/anthropic": "^1.3.3",
     "ioredis": "^5.8.0",
     "jose": "^6.1.3",
     "reflect-metadata": "^0.2.2"
   },
+  "optionalDependencies": {
+    "@langchain/google-genai": "^2.1.3",
+    "@langchain/mistralai": "^1.0.2",
+    "@langchain/groq": "^1.0.2"
+  },
   "devDependencies": {
     "@vercel/kv": "^3.0.0",
     "typescript": "^5.9.3"

package/flows/flow.instance.d.ts

@@ -30,3 +30,4 @@ export declare class FlowInstance<Name extends FlowName> extends FlowEntry<Name>
     private runWithContext;
     run(input: FlowInputOf<Name>, deps: Map<Token, Type>): Promise<FlowOutputOf<Name> | undefined>;
 }
+//# sourceMappingURL=flow.instance.d.ts.map

package/flows/flow.instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.instance.d.ts","sourceRoot":"","sources":["../../src/flows/flow.instance.ts"],"names":[],"mappings":"AAGA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAIL,SAAS,EACT,WAAW,EACX,QAAQ,EACR,YAAY,EAEZ,UAAU,EAKV,SAAS,EACT,aAAa,EACb,KAAK,EACL,IAAI,EACL,MAAM,WAAW,CAAC;AACnB,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAG7D,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AA4BjC,qBAAa,YAAY,CAAC,IAAI,SAAS,QAAQ,CAAE,SAAQ,SAAS,CAAC,IAAI,CAAC;IACtE,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,OAAO,CAAC,IAAI,CAAkB;IAC9B,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,KAAK,CAAe;gBAEhB,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,CAAC,SAAS,CAAC,EAAE,eAAe,EAAE,gBAAgB;cAUrF,UAAU;IA4DpB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAa3D;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;;;;;;OASG;YACW,cAAc;IAiCtB,GAAG,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;CAsTrG"}

package/flows/flow.registry.d.ts

@@ -1,6 +1,7 @@
+import { Token, Type } from '@frontmcp/di';
 import ProviderRegistry from '../provider/provider.registry';
 import { RegistryAbstract, RegistryBuildMapResult } from '../regsitry';
-import { FlowInputOf, FlowName, FlowOutputOf, FlowRecord, FlowType, Token, Type } from '../common';
+import { FlowInputOf, FlowName, FlowOutputOf, FlowRecord, FlowType } from '../common';
 import { FlowInstance } from './flow.instance';
 export default class FlowRegistry extends RegistryAbstract<FlowInstance<FlowName>, FlowRecord, FlowType[]> {
     constructor(providers: ProviderRegistry, list: FlowType[]);
@@ -17,3 +18,4 @@ export default class FlowRegistry extends RegistryAbstract<FlowInstance<FlowName
      */
     private getContextStorage;
 }
+//# sourceMappingURL=flow.registry.d.ts.map

package/flows/flow.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.registry.d.ts","sourceRoot":"","sources":["../../src/flows/flow.registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAa,MAAM,cAAc,CAAC;AACtD,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAc,MAAM,WAAW,CAAC;AAElG,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI/C,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,gBAAgB,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;gBAC5F,SAAS,EAAE,gBAAgB,EAAE,IAAI,EAAE,QAAQ,EAAE;cAItC,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,sBAAsB,CAAC,UAAU,CAAC;IAgBjF,SAAS,CAAC,UAAU;IAkBpB,0EAA0E;cAC1D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3C,OAAO,CAAC,aAAa;IASf,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxD,OAAO,CAAC,IAAI,SAAS,QAAQ,EAC3B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,EACxB,IAAI,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,GACtB,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAgD1C;;;OAGG;IACH,OAAO,CAAC,iBAAiB;CAO1B"}

package/flows/flow.stages.d.ts

@@ -10,3 +10,4 @@ export declare function cloneStageMap<C>(table: StageMap<C>): StageMap<C>;
 export declare function resolveStageKey(type: HookMetadata['type'], stage: string): string;
 export declare function collectFlowHookMap<C>(FlowClass: any): StageMap<C>;
 export declare function mergeHookMetasIntoStageMap<C>(FlowClass: any, table: StageMap<C>, metas: HookMetadata[], orderStart?: number): void;
+//# sourceMappingURL=flow.stages.d.ts.map

package/flows/flow.stages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.stages.d.ts","sourceRoot":"","sources":["../../src/flows/flow.stages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAA0B,MAAM,WAAW,CAAC;AAGjE,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAM1D,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,QAIjD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAIhE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,UAQxE;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,CAoDjE;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,SAAS,EAAE,GAAG,EACd,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,KAAK,EAAE,YAAY,EAAE,EACrB,UAAU,SAAU,QA0CrB"}

package/flows/flow.utils.d.ts

@@ -1,4 +1,5 @@
-import { FlowMetadata, FlowRecord, FlowType, Token } from '../common';
+import { Token } from '@frontmcp/di';
+import { FlowMetadata, FlowRecord, FlowType } from '../common';
 export declare function collectFlowMetadata(cls: FlowType): FlowMetadata<never>;
 export declare function normalizeFlow(item: FlowType): FlowRecord;
 /**
@@ -6,3 +7,4 @@ export declare function normalizeFlow(item: FlowType): FlowRecord;
  * - CLASS_TOKEN: deps come from the class constructor
  */
 export declare function flowDiscoveryDeps(rec: FlowRecord): Token[];
+//# sourceMappingURL=flow.utils.d.ts.map

package/flows/flow.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.utils.d.ts","sourceRoot":"","sources":["../../src/flows/flow.utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAqC,MAAM,cAAc,CAAC;AACxE,OAAO,EAAY,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAsB,MAAM,WAAW,CAAC;AAE7F,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAMtE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAQxD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,UAAU,GAAG,KAAK,EAAE,CAK1D"}

package/front-mcp/front-mcp.d.ts

@@ -1,4 +1,4 @@
-import { FrontMcpConfigType, FrontMcpInterface } from '../common';
+import { FrontMcpConfigType, FrontMcpInterface, ScopeEntry } from '../common';
 export declare class FrontMcpInstance implements FrontMcpInterface {
     config: FrontMcpConfigType;
     readonly ready: Promise<void>;
@@ -8,6 +8,15 @@ export declare class FrontMcpInstance implements FrontMcpInterface {
     constructor(config: FrontMcpConfigType);
     initialize(): Promise<void>;
     start(): void;
+    /**
+     * Get the configuration used to create this FrontMCP instance.
+     */
+    getConfig(): FrontMcpConfigType;
+    /**
+     * Get all initialized scope instances.
+     * Useful for graph visualization and introspection.
+     */
+    getScopes(): ScopeEntry[];
     static bootstrap(options: FrontMcpConfigType): Promise<void>;
     /**
      * Creates and initializes a FrontMCP instance without starting the HTTP server.
@@ -21,4 +30,15 @@ export declare class FrontMcpInstance implements FrontMcpInterface {
      * export default FrontMcpInstance.createHandler(config);
      */
     static createHandler(options: FrontMcpConfigType): Promise<unknown>;
+    /**
+     * Creates and initializes a FrontMCP instance without starting any server.
+     * Returns the instance for graph extraction and introspection purposes.
+     *
+     * @example
+     * // For graph visualization
+     * const instance = await FrontMcpInstance.createForGraph(config);
+     * const scopes = instance.getScopes();
+     */
+    static createForGraph(options: FrontMcpConfigType): Promise<FrontMcpInstance>;
 }
+//# sourceMappingURL=front-mcp.d.ts.map

package/front-mcp/front-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"front-mcp.d.ts","sourceRoot":"","sources":["../../src/front-mcp/front-mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAkB,UAAU,EAAE,MAAM,WAAW,CAAC;AAM9F,qBAAa,gBAAiB,YAAW,iBAAiB;IACxD,MAAM,EAAE,kBAAkB,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,kBAAkB;IAKhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAWjC,KAAK;IAQL;;OAEG;IACH,SAAS,IAAI,kBAAkB;IAI/B;;;OAGG;IACH,SAAS,IAAI,UAAU,EAAE;WAIL,SAAS,CAAC,OAAO,EAAE,kBAAkB;IAOzD;;;;;;;;;;OAUG;WACiB,aAAa,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAahF;;;;;;;;OAQG;WACiB,cAAc,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAK3F"}

package/front-mcp/front-mcp.providers.d.ts

@@ -13,10 +13,11 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
             theme?: "light" | "dark" | undefined;
         }[] | undefined;
     };
-    providers: import("../common").Type<unknown>[];
-    tools: import("../common").Type<unknown>[];
-    resources: import("../common").Type<unknown>[];
-    apps: import("../common").Type<unknown>[];
+    providers: import("@frontmcp/di").Type<unknown>[];
+    tools: import("@frontmcp/di").Type<unknown>[];
+    resources: import("@frontmcp/di").Type<unknown>[];
+    plugins: import("@frontmcp/di").Type<unknown>[];
+    apps: import("@frontmcp/di").Type<unknown>[];
     serve: boolean;
     transport: {
         sessionMode: "stateful" | "stateless" | import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>;
@@ -63,6 +64,10 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
                 token?: string | undefined;
             } | undefined;
         } | undefined;
+        distributed?: {
+            enabled: boolean | "auto";
+            providerCaching?: boolean | undefined;
+        } | undefined;
     };
     splitByApp: false;
     http?: {
@@ -128,7 +133,7 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
     logging?: {
         level: import("../common").LogLevel;
         enableConsole: boolean;
-        transports: import("../common").Type<unknown>[];
+        transports: import("@frontmcp/di").Type<unknown>[];
         prefix?: string | undefined;
     } | undefined;
     auth?: {
@@ -396,10 +401,11 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
             theme?: "light" | "dark" | undefined;
         }[] | undefined;
     };
-    providers: import("../common").Type<unknown>[];
-    tools: import("../common").Type<unknown>[];
-    resources: import("../common").Type<unknown>[];
-    apps: import("../common").Type<unknown>[];
+    providers: import("@frontmcp/di").Type<unknown>[];
+    tools: import("@frontmcp/di").Type<unknown>[];
+    resources: import("@frontmcp/di").Type<unknown>[];
+    plugins: import("@frontmcp/di").Type<unknown>[];
+    apps: import("@frontmcp/di").Type<unknown>[];
     serve: boolean;
     transport: {
         sessionMode: "stateful" | "stateless" | import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>;
@@ -446,6 +452,10 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
                 token?: string | undefined;
             } | undefined;
         } | undefined;
+        distributed?: {
+            enabled: boolean | "auto";
+            providerCaching?: boolean | undefined;
+        } | undefined;
     };
     splitByApp: true;
     http?: {
@@ -511,11 +521,11 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
     logging?: {
         level: import("../common").LogLevel;
         enableConsole: boolean;
-        transports: import("../common").Type<unknown>[];
+        transports: import("@frontmcp/di").Type<unknown>[];
         prefix?: string | undefined;
     } | undefined;
     auth?: undefined;
-}> | import("../common").ProviderFactoryType<FrontMcpServer, readonly [import("../common").Reference<{
+}> | import("../common").ProviderFactoryType<FrontMcpServer, readonly [import("@frontmcp/di").Reference<{
     info: {
         name: string;
         version: string;
@@ -528,10 +538,11 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
             theme?: "light" | "dark" | undefined;
         }[] | undefined;
     };
-    providers: import("../common").Type<unknown>[];
-    tools: import("../common").Type<unknown>[];
-    resources: import("../common").Type<unknown>[];
-    apps: import("../common").Type<unknown>[];
+    providers: import("@frontmcp/di").Type<unknown>[];
+    tools: import("@frontmcp/di").Type<unknown>[];
+    resources: import("@frontmcp/di").Type<unknown>[];
+    plugins: import("@frontmcp/di").Type<unknown>[];
+    apps: import("@frontmcp/di").Type<unknown>[];
     serve: boolean;
     transport: {
         sessionMode: "stateful" | "stateless" | import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>;
@@ -578,6 +589,10 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
                 token?: string | undefined;
             } | undefined;
         } | undefined;
+        distributed?: {
+            enabled: boolean | "auto";
+            providerCaching?: boolean | undefined;
+        } | undefined;
     };
     splitByApp: false;
     http?: {
@@ -643,7 +658,7 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
     logging?: {
         level: import("../common").LogLevel;
         enableConsole: boolean;
-        transports: import("../common").Type<unknown>[];
+        transports: import("@frontmcp/di").Type<unknown>[];
         prefix?: string | undefined;
     } | undefined;
     auth?: {
@@ -911,10 +926,11 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
             theme?: "light" | "dark" | undefined;
         }[] | undefined;
     };
-    providers: import("../common").Type<unknown>[];
-    tools: import("../common").Type<unknown>[];
-    resources: import("../common").Type<unknown>[];
-    apps: import("../common").Type<unknown>[];
+    providers: import("@frontmcp/di").Type<unknown>[];
+    tools: import("@frontmcp/di").Type<unknown>[];
+    resources: import("@frontmcp/di").Type<unknown>[];
+    plugins: import("@frontmcp/di").Type<unknown>[];
+    apps: import("@frontmcp/di").Type<unknown>[];
     serve: boolean;
     transport: {
         sessionMode: "stateful" | "stateless" | import("zod/v4/core").$InferOuterFunctionType<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>;
@@ -961,6 +977,10 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
                 token?: string | undefined;
             } | undefined;
         } | undefined;
+        distributed?: {
+            enabled: boolean | "auto";
+            providerCaching?: boolean | undefined;
+        } | undefined;
     };
     splitByApp: true;
     http?: {
@@ -1026,8 +1046,9 @@ export declare function createMcpGlobalProviders(metadata: FrontMcpConfigType):
     logging?: {
         level: import("../common").LogLevel;
         enableConsole: boolean;
-        transports: import("../common").Type<unknown>[];
+        transports: import("@frontmcp/di").Type<unknown>[];
         prefix?: string | undefined;
     } | undefined;
     auth?: undefined;
 }>]>)[];
+//# sourceMappingURL=front-mcp.providers.d.ts.map

package/front-mcp/front-mcp.providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"front-mcp.providers.d.ts","sourceRoot":"","sources":["../../src/front-mcp/front-mcp.providers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,iBAAiB,EAAiB,MAAM,WAAW,CAAC;AAGjG,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAuBpD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAEpE"}

package/front-mcp/front-mcp.tokens.d.ts

@@ -1,2 +1,4 @@
-import { FrontMcpConfigType, Token } from '../common';
+import { Token } from '@frontmcp/di';
+import { FrontMcpConfigType } from '../common';
 export declare const FrontMcpConfig: Token<FrontMcpConfigType>;
+//# sourceMappingURL=front-mcp.tokens.d.ts.map

package/front-mcp/front-mcp.tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"front-mcp.tokens.d.ts","sourceRoot":"","sources":["../../src/front-mcp/front-mcp.tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,kBAAkB,CAA4B,CAAC"}

package/front-mcp/index.d.ts

@@ -1,2 +1,3 @@
 export * from './front-mcp';
 export { FrontMcpConfig } from './front-mcp.tokens';
+//# sourceMappingURL=index.d.ts.map

package/front-mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/front-mcp/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/front-mcp/serverless-handler.d.ts

@@ -26,3 +26,4 @@ export declare function getServerlessHandler(): unknown;
  * @throws Error if handler initialization failed or not initialized
  */
 export declare function getServerlessHandlerAsync(): Promise<unknown>;
+//# sourceMappingURL=serverless-handler.d.ts.map

package/front-mcp/serverless-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverless-handler.d.ts","sourceRoot":"","sources":["../../src/front-mcp/serverless-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAE3D;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAE3E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAK9C;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAalE"}

package/hooks/hook.instance.d.ts

@@ -5,3 +5,4 @@ export declare class HookInstance<Name extends FlowName, In = FlowInputOf<Name>,
     protected initialize(): Promise<void>;
     run(input: In, ctx: Ctx): Promise<void>;
 }
+//# sourceMappingURL=hook.instance.d.ts.map

package/hooks/hook.instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.instance.d.ts","sourceRoot":"","sources":["../../src/hooks/hook.instance.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,SAAS,EAET,UAAU,EACV,yBAAyB,EACzB,UAAU,EACV,KAAK,EACN,MAAM,WAAW,CAAC;AAEnB,qBAAa,YAAY,CACvB,IAAI,SAAS,QAAQ,EACrB,EAAE,GAAG,WAAW,CAAC,IAAI,CAAC,EACtB,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,EAC1B,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,CACrB,SAAQ,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC;IACvC,MAAM,EAAE,cAAc,CAAC;gBAEX,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,yBAAyB,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK;IAOrG,SAAS,CAAC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;CAS9C"}

package/hooks/hook.registry.d.ts

@@ -34,3 +34,4 @@ export default class HookRegistry extends RegistryAbstract<HookEntry, HookRecord
     /** Hooks for a specific *flow + stage*, sorted by priority (desc). */
     getFlowStageHooks<Name extends FlowName>(flow: Name, stage: FlowStagesOf<Name> | string): HookEntry<FlowInputOf<Name>, Name, FlowStagesOf<Name>, FlowCtxOf<Name>>[];
 }
+//# sourceMappingURL=hook.registry.d.ts.map

package/hooks/hook.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.registry.d.ts","sourceRoot":"","sources":["../../src/hooks/hook.registry.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,SAAS,EACT,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,UAAU,EACV,qBAAqB,EACrB,QAAQ,EACR,UAAU,EACV,KAAK,EACN,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,gBAAgB,MAAM,+BAA+B,CAAC;AAG7D,MAAM,CAAC,OAAO,OAAO,YACnB,SAAQ,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,CAC1D,YAAW,qBAAqB;IAEhC,KAAK,EAAE,UAAU,CAAC;IAElB,iFAAiF;IACjF,YAAY,EAAE,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,CAAa;IAEnD,kEAAkE;IAClE,OAAO,CAAC,YAAY,CAAsC;IAC1D,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,gBAAgB,CAAsD;gBAElE,SAAS,EAAE,gBAAgB,EAAE,IAAI,EAAE,QAAQ,EAAE;cAKtC,QAAQ,IAAI,sBAAsB,CAAC,UAAU,CAAC;IAWjE,SAAS,CAAC,UAAU;IASd,UAAU;IAOhB,kCAAkC;IAClC,OAAO,CAAC,WAAW;IAInB,qEAAqE;IACrE,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,aAAa;IA4BrB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,UAAU,EAAE;IAWzD,0FAA0F;IAC1F,oBAAoB,CAAC,IAAI,SAAS,QAAQ,EACxC,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,MAAM,GACf,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE;IA8B5E,qFAAqF;IACrF,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE;IAItC,uCAAuC;IACvC,QAAQ,IAAI,SAAS,EAAE;IAIvB,2DAA2D;IAC3D,YAAY,CAAC,IAAI,SAAS,QAAQ,EAChC,IAAI,EAAE,IAAI,GACT,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE;IAS5E,sEAAsE;IACtE,iBAAiB,CAAC,IAAI,SAAS,QAAQ,EACrC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,GACjC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE;CAS7E"}

package/hooks/hooks.utils.d.ts

@@ -1,3 +1,5 @@
-import { HookMetadata, HookRecord, Token } from '../common';
+import { Token } from '@frontmcp/di';
+import { HookMetadata, HookRecord } from '../common';
 export declare function collectHook(cls: Token): HookMetadata[];
 export declare function normalizeHooksFromCls(instance: any): HookRecord[];
+//# sourceMappingURL=hooks.utils.d.ts.map

package/hooks/hooks.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.utils.d.ts","sourceRoot":"","sources":["../../src/hooks/hooks.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAwB,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAoC,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGvF,wBAAgB,WAAW,CAAC,GAAG,EAAE,KAAK,GAAG,YAAY,EAAE,CAEtD;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,GAAG,GAAG,UAAU,EAAE,CAwBjE"}

package/index.d.ts

@@ -3,20 +3,22 @@ export { FrontMcpInstance, FrontMcpConfig } from './front-mcp';
 export { getServerlessHandler, getServerlessHandlerAsync, setServerlessHandler, setServerlessHandlerPromise, setServerlessHandlerError, } from './front-mcp/serverless-handler';
 export * from './common';
 export * from './errors';
+export * from './remote-mcp';
 export type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
 export { FrontMcpContext, Context, FrontMcpContextArgs, FrontMcpContextConfig, FrontMcpContextStorage, ContextStorage, FRONTMCP_CONTEXT, FrontMcpContextProvider, RequestMetadata, TransportAccessor, TraceContext, parseTraceContext, generateTraceContext, createChildSpanContext, } from './context';
 export { ToolChangeEvent, ToolChangeKind, ToolChangeScope } from './tool/tool.events';
+export { Agent, FrontMcpAgent, agent, frontMcpAgent, AgentContext, AgentMetadata, AgentLlmConfig, AgentLlmBuiltinConfig, AgentSwarmConfig, AgentExecutionConfig, AgentType, WithConfig, withConfig, AgentLlmAdapter, AgentPrompt, AgentMessage, AgentCompletion, AgentToolCall, AgentToolDefinition, } from './agent';
 export declare const ToolHook: {
-    Stage: (stage: "execute" | "finalize" | "parseInput" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
-    Will: (stage: "execute" | "finalize" | "parseInput" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
-    Did: (stage: "execute" | "finalize" | "parseInput" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
-    Around: (stage: "execute" | "finalize" | "parseInput" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
+    Stage: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
+    Will: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
+    Did: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
+    Around: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "findTool" | "checkToolAuthorization" | "createToolCallContext" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "applyUI", opts?: import("./common").HookOptions<import("./tool/flows/call-tool.flow").default>) => MethodDecorator;
 };
 export declare const ListToolsHook: {
-    Stage: (stage: "parseInput" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
-    Will: (stage: "parseInput" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
-    Did: (stage: "parseInput" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
-    Around: (stage: "parseInput" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
+    Stage: (stage: "parseInput" | "ensureRemoteCapabilities" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
+    Will: (stage: "parseInput" | "ensureRemoteCapabilities" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
+    Did: (stage: "parseInput" | "ensureRemoteCapabilities" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
+    Around: (stage: "parseInput" | "ensureRemoteCapabilities" | "findTools" | "resolveConflicts" | "parseTools", opts?: import("./common").HookOptions<import("./tool/flows/tools-list.flow").default>) => MethodDecorator;
 };
 export declare const HttpHook: {
     Stage: (stage: "finalize" | "acquireQuota" | "acquireSemaphore" | "releaseSemaphore" | "releaseQuota" | "traceRequest" | "checkAuthorization" | "router" | "handleLegacySse" | "handleSse" | "handleStreamableHttp" | "handleStatefulHttp" | "handleStatelessHttp" | "handleDeleteSession" | "audit" | "metrics", opts?: import("./common").HookOptions<import("./scope/flows/http.request.flow").default>) => MethodDecorator;
@@ -25,20 +27,27 @@ export declare const HttpHook: {
     Around: (stage: "finalize" | "acquireQuota" | "acquireSemaphore" | "releaseSemaphore" | "releaseQuota" | "traceRequest" | "checkAuthorization" | "router" | "handleLegacySse" | "handleSse" | "handleStreamableHttp" | "handleStatefulHttp" | "handleStatelessHttp" | "handleDeleteSession" | "audit" | "metrics", opts?: import("./common").HookOptions<import("./scope/flows/http.request.flow").default>) => MethodDecorator;
 };
 export declare const ResourceHook: {
-    Stage: (stage: "execute" | "finalize" | "parseInput" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
-    Will: (stage: "execute" | "finalize" | "parseInput" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
-    Did: (stage: "execute" | "finalize" | "parseInput" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
-    Around: (stage: "execute" | "finalize" | "parseInput" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
+    Stage: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
+    Will: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
+    Did: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
+    Around: (stage: "execute" | "finalize" | "parseInput" | "ensureRemoteCapabilities" | "validateOutput" | "findResource" | "createResourceContext", opts?: import("./common").HookOptions<import("./resource").ReadResourceFlow>) => MethodDecorator;
 };
 export declare const ListResourcesHook: {
-    Stage: (stage: "parseInput" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
-    Will: (stage: "parseInput" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
-    Did: (stage: "parseInput" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
-    Around: (stage: "parseInput" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
+    Stage: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
+    Will: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
+    Did: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
+    Around: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findResources" | "parseResources", opts?: import("./common").HookOptions<import("./resource").ResourcesListFlow>) => MethodDecorator;
 };
 export declare const ListResourceTemplatesHook: {
-    Stage: (stage: "parseInput" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
-    Will: (stage: "parseInput" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
-    Did: (stage: "parseInput" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
-    Around: (stage: "parseInput" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
+    Stage: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
+    Will: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
+    Did: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
+    Around: (stage: "parseInput" | "ensureRemoteCapabilities" | "resolveConflicts" | "findTemplates" | "parseTemplates", opts?: import("./common").HookOptions<import("./resource").ResourceTemplatesListFlow>) => MethodDecorator;
 };
+export declare const AgentCallHook: {
+    Stage: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("./common").HookOptions<import("./agent").CallAgentFlow>) => MethodDecorator;
+    Will: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("./common").HookOptions<import("./agent").CallAgentFlow>) => MethodDecorator;
+    Did: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("./common").HookOptions<import("./agent").CallAgentFlow>) => MethodDecorator;
+    Around: (stage: "execute" | "finalize" | "parseInput" | "acquireQuota" | "acquireSemaphore" | "validateInput" | "validateOutput" | "releaseSemaphore" | "releaseQuota" | "findAgent" | "checkAgentAuthorization" | "createAgentContext", opts?: import("./common").HookOptions<import("./agent").CallAgentFlow>) => MethodDecorator;
+};
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAoB1B,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,oBAAoB,EACpB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,gCAAgC,CAAC;AACxC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAG7B,YAAY,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAG1E,OAAO,EAEL,eAAe,EACf,OAAO,EACP,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EAEvB,eAAe,EACf,iBAAiB,EAEjB,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGtF,OAAO,EAEL,KAAK,EACL,aAAa,EACb,KAAK,EACL,aAAa,EAEb,YAAY,EAEZ,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,EACT,UAAU,EACV,UAAU,EAEV,eAAe,EACf,WAAW,EACX,YAAY,EACZ,eAAe,EACf,aAAa,EACb,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,QAAQ;;;;;CAAiC,CAAC;AACvD,eAAO,MAAM,aAAa;;;;;CAAkC,CAAC;AAC7D,eAAO,MAAM,QAAQ;;;;;CAA8B,CAAC;AAGpD,eAAO,MAAM,YAAY;;;;;CAAyC,CAAC;AACnE,eAAO,MAAM,iBAAiB;;;;;CAA0C,CAAC;AACzE,eAAO,MAAM,yBAAyB;;;;;CAAmD,CAAC;AAG1F,eAAO,MAAM,aAAa;;;;;CAAmC,CAAC"}