@bevel-software/platform-core-backend 0.14.0 → 0.19.0

package/dist/modules/mcp/mcp.service.d.ts

@@ -1,16 +1,16 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import '@utcp/http';
 import '@utcp/mcp';
 import { type ISecretsVaultService } from '../secrets-vault/secrets-vault.contract.js';
 import type { IToolManualService } from '../tool-manuals/tool-manuals.contract.js';
 import type { SpillStore } from '../workspace/spill-store.js';
-import type { McpSessionStore } from './mcp-session-store.js';
 import type { InternalTokenService } from '../tool-auth/internal-token.service.js';
+import { type DownstreamPoolOptions } from './downstream-pool.js';
+import { type AgentPreambleReader } from '../agent-instructions/index.js';
 /**
  * Configuration for the loopback proxy. `loopbackBaseUrl` is the backend's own
  * address (`http://127.0.0.1:<port>`) and `manualName` is BOTH the UTCP manual
- * namespace the per-session client registers under AND the prefix its `${VAR}`
+ * namespace the per-request client registers under AND the prefix its `${VAR}`
  * placeholders resolve through (`<manualName>_API_URL` / `_CONNECTION_KEY`).
  */
 export interface McpProxyOptions {
@@ -20,14 +20,31 @@ export interface McpProxyOptions {
     spillStore: SpillStore;
     /** Public web address of the frontend, for the needs-authorization setup link. */
     publicFrontendUrl: string;
+    /**
+     * Reads `mcp-description.md` on the default branch with platform rights
+     * (see modules/agent-instructions). Called on every request that needs it
+     * (an `initialize`, or a `tools/list` for the tool prefix), so an edit
+     * reaches the next request without a restart. Optional so constructions
+     * that never exercise it (tests) keep working: without it every request
+     * carries the platform header alone.
+     */
+    readAgentPreamble?: AgentPreambleReader;
+    /** Bounds of the downstream (`mcp.json`) connection pool; defaults are 4h idle / 5000 entries. */
+    downstreamPool?: Pick<DownstreamPoolOptions<unknown>, 'idleTtlMs' | 'maxEntries' | 'now'>;
+}
+/** Who a request is from — everything the proxy needs, resolved from that request's own bearer. */
+export interface McpCaller {
+    userId: string;
+    /** The connection-key id (per-key metering rides on it), or null for an OAuth/JWT bearer. */
+    tokenId: string | null;
+    /** The raw bearer the request carried. */
+    bearer: string;
 }
 /**
- * Lifetime of the internal token minted as an OAuth/JWT session's loopback
- * bearer. Longer than the session store's 4h idle eviction (see
- * `DEFAULT_IDLE_TTL_MS` in mcp-session-store.ts) so the credential is not the
- * first thing to die under a session's normal lifecycle. A continuously-active
- * session CAN outlive it — its tool calls then fail at the loopback and the
- * client recovers by re-initializing, which mints a fresh token.
+ * Lifetime of the internal token minted as an OAuth/JWT request's loopback
+ * bearer. A request only needs it for as long as it runs, but one `tools/call`
+ * can legitimately run for a long time (`ask`, a long `call_tool_chain`), so
+ * the lifetime is generous rather than tight.
  *
  * Exported because `POST /api/mcp/local-token` (mcp.routes.ts) performs the
  * same OAuth-access-token → internal-token exchange for the LOCAL MCP server,
@@ -36,58 +53,119 @@ export interface McpProxyOptions {
  */
 export declare const MCP_LOOPBACK_TOKEN_TTL_MS: number;
 /**
- * The MCP server is a GENERIC proxy over the UTCP tool surface. It owns no tool
- * logic: per MCP session it stands up a `UtcpClient` pointed at the backend's
- * own `GET /api/agent/utcp` manual (over loopback, authenticated with the
- * caller's connection key), discovers every tool, and re-exposes each one to
- * the MCP client. A tool call is dispatched straight back through the same REST
- * endpoint the tool's UTCP `tool_call_template` names — so the agent logic,
+ * The MCP server is a GENERIC, STATELESS proxy over the UTCP tool surface. It
+ * owns no tool logic and no session: every HTTP request gets its own MCP
+ * `Server`, built from that request's bearer. When the request needs tools it
+ * stands up a `UtcpClient` pointed at the backend's own `GET /api/agent/all-tools`
+ * catalog (over loopback, authenticated as the caller, so ACL filtering lives
+ * ONCE behind the REST surface), discovers every tool, and re-exposes each one
+ * to the MCP client. A tool call is dispatched straight back through the same
+ * REST endpoint the tool's UTCP `tool_call_template` names — so the agent logic,
  * thread continuity, and per-key token metering all live ONCE behind that REST
  * endpoint (`AgentAskService` for `ask`), never duplicated here.
  *
+ * Because nothing is held between requests, a platform restart between two
+ * requests of one client conversation is undetectable by the client.
+ *
+ * There is NO catalog cache at this layer, deliberately: the catalog is
+ * re-derived per request, and if that ever proves too slow the fix belongs in
+ * the source path (all-tools/ACL), which serves every other caller too.
+ *
+ * The one exception to "nothing between requests" is proxied third-party MCP
+ * servers (`mcp` manuals): those are session-ful by nature, so their
+ * connections live in a {@link DownstreamPool} keyed by (user, manual) — lazy,
+ * single-flight, idle-evicted, bounded, and healed by session recovery. Losing
+ * any of it costs a reconnect, never correctness.
+ *
  * Dispatch always uses `callToolStreaming`, which is uniform across tool kinds:
  * a plain `http` tool yields exactly one chunk (its final result, emitted as
  * the tool result with no progress), while a `streamable_http` tool yields many
- * (the all-but-last become `notifications/progress`, the last is the result).
- * Because of that, adding — or later upgrading a tool to streaming — never
- * touches this file.
+ * (the all-but-last become `notifications/progress` on the request's own
+ * response stream, the last is the result).
  *
  * Auth note: `/api/agent/*` accepts connection keys and internal tokens only.
- * Connection-key sessions pass the caller's own key through to the loopback;
- * OAuth/JWT sessions can't (their bearer would 401 there), so `createSession`
- * mints a least-privilege internal token for the resolved user and uses THAT
- * as the session's loopback bearer instead.
+ * Connection-key requests pass the caller's own key through to the loopback;
+ * OAuth/JWT requests can't (their bearer would 401 there), so the proxy mints a
+ * least-privilege internal token for the resolved user and uses THAT as the
+ * request's loopback bearer instead.
  */
 export declare class McpService {
-    private readonly sessionStore;
     private readonly opts;
     private readonly secretsVault?;
     private readonly toolManuals?;
     private readonly internalTokens?;
     private readonly revokeOAuthAccess?;
     private readonly manualFailures;
+    private readonly surfaceLog;
+    private readonly tokenRefreshes;
     /**
-     * Invalidate remembered manual failures — wired to the secrets vault's
-     * mutation listener, so a just-repaired credential is retried on the very
-     * next session build. `null` = a shared secret changed (affects everyone).
+     * The tools each pooled manual last advertised, by manual definition. A
+     * downstream can only be asked what its tools are over a connection, and a
+     * caller whose sign-in is missing or broken has no connection — so their
+     * tools would silently vanish from the surface, and a call would answer
+     * "Unknown tool" instead of "sign in again on /connect". These definitions
+     * keep the manual on the surface for such a caller; the call-time credential
+     * check then answers with the link, and an interactive client is sent back
+     * through authorization. Definitions, never credentials or results. Keyed
+     * by catalog name — one entry per manual, replaced when the manual is next
+     * discovered — and used only while the manual's definition is the one the
+     * tools were discovered from, so an edited `mcp.json` never serves the old
+     * server's tools.
      */
-    clearManualFailures(userId: string | null): void;
-    constructor(sessionStore: McpSessionStore, opts: McpProxyOptions, secretsVault?: ISecretsVaultService | undefined, toolManuals?: IToolManualService | undefined, internalTokens?: InternalTokenService | undefined, revokeOAuthAccess?: ((bearer: string) => Promise<void>) | undefined);
+    private readonly knownDownstreamTools;
+    private readonly downstream;
+    constructor(opts: McpProxyOptions, secretsVault?: ISecretsVaultService | undefined, toolManuals?: IToolManualService | undefined, internalTokens?: InternalTokenService | undefined, revokeOAuthAccess?: ((bearer: string) => Promise<void>) | undefined);
     /**
-     * Subscribe to store-driven evictions (idle-TTL sweep, size-cap eviction) so
-     * the route layer can drop its transport mirror. Returns an unsubscribe fn.
+     * A secret changed — wired to the secrets vault's mutation listener.
+     * `null` = a shared secret changed (affects everyone).
+     *
+     * Two things were built from the old value: remembered manual failures (so a
+     * just-repaired credential is retried on the very next request) and pooled
+     * downstream connections (dialed and discovered with the old credential).
+     * Both are dropped; the next request rebuilds whatever it needs.
      */
-    onSessionEvicted(listener: (sessionId: string) => void): () => void;
+    onSecretsChanged(userId: string | null): void;
     /**
-     * Build a fresh per-session (transport, server) pair. Async because tool
-     * discovery (a loopback round-trip authenticated with `bearer`) happens here,
-     * before the server is returned, so `tools/list` is ready the moment the
-     * client asks. The route awaits this, then `server.connect(transport)`.
+     * A credential changed, so a refresh window that FAILED to produce one no
+     * longer describes anything: a token the user has just re-authorized (or an
+     * admin has just re-keyed) must be tried on the very next rejection, not sit
+     * out the remainder of a minute earned by the credential it replaced.
+     *
+     * Only settled, non-`refreshed` windows are forgotten. A refresh of our own
+     * is itself a secrets mutation, and clearing on that would hand a provider
+     * that keeps minting tokens the downstream keeps refusing one refresh per
+     * call — precisely the loop the once-a-minute guard exists to bound. An
+     * in-flight attempt (no outcome yet) is left alone for the same reason: it
+     * may be the very refresh that raised this notification.
      */
-    createSession(userId: string, tokenId: string | null, bearer: string, onSessionInitialized: (sessionId: string) => void): Promise<{
-        transport: StreamableHTTPServerTransport;
-        server: Server;
-    }>;
+    private forgetStaleRefreshWindows;
+    /**
+     * Build the MCP `Server` for ONE request. The route connects it to a fresh
+     * stateless transport, lets it answer, and closes both with the response.
+     *
+     * Cheap by construction: nothing is fetched up front except what the
+     * request's own messages need. The agent instructions are read only when the
+     * request carries an `initialize` (the only place they ride); the tool
+     * catalog is built on the first handler that needs it and shared by every
+     * message of the request (a JSON-RPC batch), never beyond it.
+     */
+    createRequestServer(caller: McpCaller, messages: unknown): Promise<Server>;
+    /**
+     * The request's tool surface: catalog over loopback, a fresh UTCP client,
+     * every manual registered (pooled for `mcp` ones), tools flattened.
+     *
+     * Logs one line with the time each half took — the per-request overhead
+     * the stateless design trades for restart-invisibility, kept visible so it
+     * is measured rather than assumed.
+     */
+    private buildSurface;
+    /**
+     * The instructions and tool prefix. A reader failure (a disk fault; ENOENT
+     * is not one, the reader answers null for that) falls back to the header
+     * alone and the fixed prefix line with a logged warning: a request never
+     * fails over its preamble.
+     */
+    private composeAgentInstructions;
     /** Loopback GET of the default-branch skill catalog (via the `list_skills` tool). */
     private fetchSkillList;
     /** Loopback GET of one skill's body (via the `get_skill` tool); null if unavailable. */
@@ -96,10 +174,9 @@ export declare class McpService {
      * The ONE loopback round-trip: fetch `path` on our own REST surface with the
      * caller's bearer, parse JSON. Failures are logged under `label` (never the
      * bearer) and degrade to null — a loopback hiccup must not throw into the
-     * MCP session. GET when `json` is absent, POST with a JSON body when present.
-     * Bounded: a hung loopback (e.g. mid-restart) must not block `createSession`
-     * or a prompts handler indefinitely; a timeout aborts and degrades to null
-     * like any other failure.
+     * MCP request. GET when `json` is absent, POST with a JSON body when present.
+     * Bounded: a hung loopback (e.g. mid-restart) must not block a request
+     * indefinitely; a timeout aborts and degrades to null like any other failure.
      */
     private loopbackJson;
     /** POST a skill tool endpoint over loopback with the caller's bearer; parsed JSON or null. */
@@ -109,41 +186,113 @@ export declare class McpService {
      * validated into `CallTemplate`s at the boundary. The KB manual is guaranteed
      * present (a fallback covers an unavailable endpoint); a user manual that
      * fails validation is dropped + logged so one bad `.tool` can't break the
-     * session. HTTP transport loses the `CallTemplate` type, so we re-validate the
+     * request. HTTP transport loses the `CallTemplate` type, so we re-validate the
      * received JSON even though the producing endpoint already validated it.
      */
     private fetchManualTemplates;
     /** The KB manual's discovery template — the fallback if `all-tools` is unavailable. */
     private kbManualTemplate;
     /**
-     * One `CodeModeUtcpClient` per session. Reserved `API_URL`/`CONNECTION_KEY` are
+     * One `CodeModeUtcpClient` per request. Reserved `API_URL`/`CONNECTION_KEY` are
      * seeded (namespaced) ONLY for Bevel-hosted manuals — the KB manual and inline
      * `.tool` sub-manuals, whose discovery template targets the loopback (`${API_URL}`).
      * Third-party http/mcp `.tool`s point at arbitrary user URLs, so we must NOT seed
      * them the caller's bearer: a malicious `.tool` referencing `${CONNECTION_KEY}`
      * would otherwise exfiltrate the caller's token to its own endpoint. Tool
      * `${SECRET}` refs resolve lazily via the per-user `bevel-secrets` loader.
+     *
+     * Not `close()`d: a request's client holds no connection of its own (its
+     * `mcp` manuals route to the pool, so its own `mcp` protocol instance never
+     * opens a session), and dropping the reference is the whole teardown.
      */
     private buildClient;
     /**
-     * Register EVERY manual on the client, then flatten each discovered tool into
-     * the proxy's advertised shape. A failure registering a user `.tool` is
-     * isolated (logged + skipped) so one broken manual never breaks the session;
-     * the KB manual failing is fatal (the core toolset is unusable).
+     * Register EVERY manual for this request, then flatten each discovered tool
+     * into the proxy's advertised shape. Manuals register concurrently — they are
+     * independent, and a request pays for the slowest one rather than the sum. A
+     * failure registering a user `.tool` is isolated (logged + skipped) so one
+     * broken manual never breaks the request; the KB manual failing is fatal (the
+     * core toolset is unusable).
      *
-     * Failures are memoized per (user, manual) for a few minutes (see
-     * {@link ManualFailureMemo}): sessions rebuild constantly, and a manual with
-     * a broken credential (expired OAuth, revoked key) would otherwise re-dial
-     * its provider on every single build.
+     * `mcp` manuals never dial from here: they are attached from the downstream
+     * pool (see {@link attachDownstream}).
+     *
+     * Failures are memoized per (user, manual definition) for a few minutes (see
+     * {@link ManualFailureMemo}): the catalog is rebuilt on every request, and a
+     * manual with a broken credential (expired OAuth, revoked key) would
+     * otherwise re-dial its provider on every single one. The definition's
+     * fingerprint is part of the key, so a manual edited after a failure (a
+     * corrected `mcp.json` URL) is tried on the very next request.
      */
     private discoverTools;
     /**
-     * Run one tool call through `callToolStreaming` with a one-chunk lookahead:
-     * every chunk except the last becomes a progress notification, the last is
-     * the result. Continuity is the caller's: a tool that supports it (e.g.
-     * `ask`) returns its `sessionId` in the result verbatim, and the caller
-     * echoes it back per the tool's own schema — the proxy never rewrites args.
+     * Make one `mcp` manual's tools part of this request's client, backed by the
+     * pooled connection for (user, manual).
+     *
+     * The pooled client's discovered tools are copied into the request client's
+     * repository — so `tools/list`, `list_tools`/`tools_info` and the TypeScript
+     * interfaces `call_tool_chain` generates all see them exactly as if they had
+     * been registered here — and `routes` records that calls to this manual go to
+     * the pool. The route re-acquires at CALL time rather than holding the pooled
+     * client, so an entry evicted between discovery and the call is transparently
+     * re-created instead of used after its connection was closed. Each use holds
+     * a pool lease only for its own duration, so the pool never closes a
+     * connection an operation is still using.
      */
+    private attachDownstream;
+    /** Whether the caller's sign-in for the manual named `catalogName` is missing or broken — a check that must never throw here. */
+    private signInMissing;
+    /**
+     * Create one pooled downstream connection: a client registering just this
+     * manual.
+     *
+     * `@utcp/mcp` (1.2.0+) registers its protocol as a FACTORY, so this client
+     * gets an `mcp` protocol instance of its own: the session it opens lives in
+     * that instance, is reachable from no other client, and ends with
+     * `client.close()`. That is what makes a pool entry per (user, server) an
+     * actual isolation boundary — two users with byte-identical server
+     * definitions still never share a connection — with nothing reached into.
+     *
+     * SESSION RECOVERY is installed on the pooled client: a downstream server
+     * that restarts (or expires a session) answers our next call with the spec's
+     * 404/`-32001`, and recovery re-registers in place and retries once. It is
+     * deliberately clear of {@link ManualFailureMemo}: that memo is a circuit
+     * breaker for manuals whose REGISTRATION failed, so a recovery neither
+     * consults it nor records into it.
+     *
+     * A registration that fails closes the client it built (ending whatever the
+     * attempt opened) and throws, so the pool caches nothing and the caller's
+     * memo records the failure.
+     */
+    private connectDownstream;
+    /**
+     * A pooled manual's operation failed: may it be retried with a refreshed
+     * token? Answers {@link RETRY_WITH_REFRESHED_TOKEN} when so, otherwise the
+     * error the caller should see.
+     *
+     * Only a token rejection (401 / `invalid_token`) qualifies. Then the
+     * caller's OAuth token for this manual is refreshed once, ignoring its
+     * stored expiry, and:
+     *   - refreshed → the pooled connection (dialed with the dead token) is
+     *     dropped and the operation retried once, on a fresh one;
+     *   - rejected → the grant is gone and the vault has wiped it; the caller is
+     *     told to re-authorize on /connect, where it now shows as not connected;
+     *   - transient, or no refresh allowed / possible → the original error.
+     */
+    private afterDownstreamFailure;
+    /** {@link afterDownstreamFailure}, keeping the one distinction its symbol-or-error answer drops. */
+    private classifyDownstreamFailure;
+    /**
+     * Force-refresh the caller's OAuth token(s) for `manualName`, at most once per
+     * (user, manual) per minute. Logs ONE line per attempt — manual, user,
+     * outcome, never token material.
+     *
+     * `'guarded'` when the window refused this one (a refresh just ran, or is
+     * running, for this pair); `undefined` when there was nothing to refresh at
+     * all: no vault wired, or no OAuth variable on the manual. The two are not
+     * the same thing to the caller — see {@link classifyDownstreamFailure}.
+     */
+    private refreshDownstreamToken;
     /**
      * If the tool declares per-user credentials the caller hasn't set, return a
      * needs-authorization result (naming the tool + a setup link); otherwise null
@@ -157,16 +306,24 @@ export declare class McpService {
     /**
      * The per-user variables of `tool`'s manual the caller has NOT satisfied.
      * Shared by the call-time needs-authorization check above and the
-     * listing-time filter for connection-key sessions (which registers only
+     * listing-time filter for connection-key callers (which registers only
      * ready tools). Empty when the vault/manual services aren't wired or the
      * manual declares no per-user credential.
      */
     private missingUserSecrets;
+    /**
+     * Run one tool call through `callToolStreaming` with a one-chunk lookahead:
+     * every chunk except the last becomes a progress notification — sent on THIS
+     * request's own response stream — and the last is the result. Continuity is
+     * the caller's: a tool that supports it (e.g. `ask`) returns its `sessionId`
+     * in the result verbatim, and the caller echoes it back per the tool's own
+     * schema — the proxy never rewrites args.
+     */
     private dispatch;
     /**
      * Handle a code-mode meta-tool. The shared implementation reflects on this
-     * session's client, so `list_tools`/`tools_info` describe exactly the catalog
-     * this session discovered and `call_tool_chain` runs in that client's
+     * request's client, so `list_tools`/`tools_info` describe exactly the catalog
+     * this request discovered and `call_tool_chain` runs in that client's
      * isolated-vm — resolving over loopback with the caller's key. The workspace
      * spill store is passed in so an oversized chain result comes back as a
      * `read_file`-able ref rather than a wall of JSON.

package/dist/modules/mcp/mcp.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.service.d.ts","sourceRoot":"","sources":["../../../src/modules/mcp/mcp.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,6BAA6B,EAAE,MAAM,oDAAoD,CAAC;AAanG,OAAO,YAAY,CAAC;AACpB,OAAO,WAAW,CAAC;AAwBnB,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAEtG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAGnF;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,qGAAqG;IACrG,UAAU,EAAE,UAAU,CAAC;IACvB,kFAAkF;IAClF,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AASD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,QAAqB,CAAC;AAI5D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;IAenB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAIrB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAI7B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAKhC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC;IA5BrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA2B;IAE1D;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;gBAM7B,YAAY,EAAE,eAAe,EAC7B,IAAI,EAAE,eAAe,EAIrB,YAAY,CAAC,EAAE,oBAAoB,YAAA,EACnC,WAAW,CAAC,EAAE,kBAAkB,YAAA,EAIhC,cAAc,CAAC,EAAE,oBAAoB,YAAA,EAKrC,iBAAiB,CAAC,GAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,aAAA;IAGxE;;;OAGG;IACH,gBAAgB,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI;IAInE;;;;;OAKG;IACG,aAAa,CACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,MAAM,EAAE,MAAM,EACd,oBAAoB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GAChD,OAAO,CAAC;QAAE,SAAS,EAAE,6BAA6B,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAuKxE,qFAAqF;YACvE,cAAc;IAM5B,wFAAwF;YAC1E,UAAU;IAQxB;;;;;;;;OAQG;YACW,YAAY;IAqB1B,8FAA8F;YAChF,YAAY;IAI1B;;;;;;;OAOG;YACW,oBAAoB;IA0BlC,uFAAuF;IACvF,OAAO,CAAC,gBAAgB;IAWxB;;;;;;;;OAQG;YACW,WAAW;IAgBzB;;;;;;;;;;OAUG;YACW,aAAa;IAmC3B;;;;;;OAMG;IACH;;;;;;;;OAQG;YACW,gBAAgB;IAoB9B;;;;;;OAMG;YACW,kBAAkB;YA0ClB,QAAQ;IAsBtB;;;;;;;OAOG;YACW,gBAAgB;CAO/B;AAED;;;;;GAKG;AACH,OAAO,EACL,KAAK,WAAW,EAChB,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,mCAAmC,CAAC"}
+{"version":3,"file":"mcp.service.d.ts","sourceRoot":"","sources":["../../../src/modules/mcp/mcp.service.ts"],"names":[],"mappings":"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"}