@truefoundry/trueforge-core 0.0.0 → 0.1.0-rc.0

package/dist/core/mcp/ToolSelectorPolicy.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/mcp/ToolSelectorPolicy.ts
+var ToolSelectorPolicy_exports = {};
+__export(ToolSelectorPolicy_exports, {
+  ToolSelectorPolicy: () => ToolSelectorPolicy
+});
+module.exports = __toCommonJS(ToolSelectorPolicy_exports);
+var import_toolSelectors = require("./toolSelectors.js");
+var ToolSelectorPolicy = class {
+  preload;
+  hasPreloadedTools;
+  enableTools;
+  disableTools;
+  preloadTools;
+  requireApprovalForTools;
+  // Tool names that survived enable/disable filtering on the most recent filterAndAnnotate() call.
+  // Used by the sandbox allow-list and as the fast path for callTool gating.
+  resolvedAllowedToolNames;
+  constructor(params) {
+    this.enableTools = params.selectors.enableTools;
+    this.disableTools = params.selectors.disableTools;
+    this.preloadTools = params.selectors.preloadTools;
+    this.requireApprovalForTools = params.selectors.requireApprovalForTools ?? import_toolSelectors.DEFAULT_REQUIRE_APPROVAL_FOR_TOOLS;
+    this.preload = params.preload;
+    this.hasPreloadedTools = params.preload || this.preloadTools.length > 0;
+  }
+  /** Literal enable_tools names that are not present on the server (caller throws if non-empty). */
+  missingEnableLiterals(tools) {
+    const availableNames = new Set(tools.map((t) => t.name));
+    return (0, import_toolSelectors.literalToolNames)(this.enableTools).filter((name) => !availableNames.has(name));
+  }
+  /** Filter by enable/disable, record the resolved allow-list, and annotate per-tool preload. */
+  filterAndAnnotate(tools) {
+    const filtered = tools.filter(
+      (tool) => (0, import_toolSelectors.isToolAllowed)({
+        toolName: tool.name,
+        annotations: tool.annotations,
+        enableSelectors: this.enableTools,
+        disableSelectors: this.disableTools
+      })
+    );
+    this.resolvedAllowedToolNames = filtered.map((t) => t.name);
+    return filtered.map((tool) => ({ ...tool, preload: this.isToolPreloaded(tool.name, tool.annotations) }));
+  }
+  isToolPreloaded(toolName, annotations) {
+    if (this.preload) return true;
+    return (0, import_toolSelectors.toolMatchesAnySelector)(toolName, annotations, this.preloadTools);
+  }
+  /**
+   * Whether a tool may be called. Uses the resolved allow-list once listTools() has run; before that
+   * falls back to matching against the raw selectors, resolving annotations lazily only when needed.
+   */
+  async isAllowed(toolName, resolveAnnotations) {
+    if (this.resolvedAllowedToolNames) {
+      return this.resolvedAllowedToolNames.includes(toolName);
+    }
+    return (0, import_toolSelectors.isToolAllowed)({
+      toolName,
+      annotations: await resolveAnnotations(),
+      enableSelectors: this.enableTools,
+      disableSelectors: this.disableTools
+    });
+  }
+  /**
+   * Best-effort allow-list for the sandbox. After a listTools() call returns the concrete names;
+   * before that, `@all` with no disables means "unrestricted" (undefined), else the literal names.
+   */
+  allowedNamesForSandbox() {
+    if (this.resolvedAllowedToolNames) {
+      return this.resolvedAllowedToolNames;
+    }
+    if ((0, import_toolSelectors.selectorsIncludeAll)(this.enableTools) && this.disableTools.length === 0) {
+      return void 0;
+    }
+    return (0, import_toolSelectors.literalToolNames)(this.enableTools);
+  }
+  /**
+   * Whether the tool requires human approval. Honors `requireApprovalForTools` exactly: omit /
+   * undefined defaults to write+destructive (constructor); an explicit list — including empty —
+   * is exact.
+   */
+  requiresApproval(toolName, annotations) {
+    return (0, import_toolSelectors.toolRequiresApproval)(toolName, annotations, this.requireApprovalForTools);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolSelectorPolicy
+});
+//# sourceMappingURL=ToolSelectorPolicy.js.map

package/dist/core/mcp/ToolSelectorPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/mcp/ToolSelectorPolicy.ts"],"sourcesContent":["import type { ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';\nimport type { AgentToolSchema } from './IMCPServer';\nimport {\n  DEFAULT_REQUIRE_APPROVAL_FOR_TOOLS,\n  isToolAllowed,\n  literalToolNames,\n  selectorsIncludeAll,\n  toolMatchesAnySelector,\n  toolRequiresApproval,\n} from './toolSelectors';\n\n/**\n * Per-server tool selectors. Enable/disable/preload tags: `@all`, `@read-only`.\n * Approval tags: `@all`, `@write`, `@destructive`.\n */\nexport interface ToolSelectorConfig {\n  enableTools: string[];\n  disableTools: string[];\n  preloadTools: string[];\n  requireApprovalForTools?: string[] | undefined;\n}\n\n/**\n * Encapsulates enable/disable/preload/approval selector policy for a single MCP server. Pure: it\n * never throws or does IO — callers decide how to surface a disallowed/missing tool so each can\n * raise its own error type.\n */\nexport class ToolSelectorPolicy {\n  readonly preload: boolean;\n  readonly hasPreloadedTools: boolean;\n\n  private readonly enableTools: string[];\n  private readonly disableTools: string[];\n  private readonly preloadTools: string[];\n  private readonly requireApprovalForTools: string[];\n  // Tool names that survived enable/disable filtering on the most recent filterAndAnnotate() call.\n  // Used by the sandbox allow-list and as the fast path for callTool gating.\n  private resolvedAllowedToolNames: string[] | undefined;\n\n  constructor(params: { selectors: ToolSelectorConfig; preload: boolean }) {\n    this.enableTools = params.selectors.enableTools;\n    this.disableTools = params.selectors.disableTools;\n    this.preloadTools = params.selectors.preloadTools;\n    this.requireApprovalForTools = params.selectors.requireApprovalForTools ?? DEFAULT_REQUIRE_APPROVAL_FOR_TOOLS;\n    this.preload = params.preload;\n    this.hasPreloadedTools = params.preload || this.preloadTools.length > 0;\n  }\n\n  /** Literal enable_tools names that are not present on the server (caller throws if non-empty). */\n  missingEnableLiterals(tools: AgentToolSchema[]): string[] {\n    const availableNames = new Set(tools.map(t => t.name));\n    return literalToolNames(this.enableTools).filter(name => !availableNames.has(name));\n  }\n\n  /** Filter by enable/disable, record the resolved allow-list, and annotate per-tool preload. */\n  filterAndAnnotate(tools: AgentToolSchema[]): AgentToolSchema[] {\n    const filtered = tools.filter(tool =>\n      isToolAllowed({\n        toolName: tool.name,\n        annotations: tool.annotations,\n        enableSelectors: this.enableTools,\n        disableSelectors: this.disableTools,\n      }),\n    );\n    this.resolvedAllowedToolNames = filtered.map(t => t.name);\n    return filtered.map(tool => ({ ...tool, preload: this.isToolPreloaded(tool.name, tool.annotations) }));\n  }\n\n  private isToolPreloaded(toolName: string, annotations: ToolAnnotations | undefined): boolean {\n    // Fully-preloaded server: every allowed tool is loaded into context.\n    if (this.preload) return true;\n    // Otherwise only the tools matching `preload_tools` stay eager.\n    return toolMatchesAnySelector(toolName, annotations, this.preloadTools);\n  }\n\n  /**\n   * Whether a tool may be called. Uses the resolved allow-list once listTools() has run; before that\n   * falls back to matching against the raw selectors, resolving annotations lazily only when needed.\n   */\n  async isAllowed(toolName: string, resolveAnnotations: () => Promise<ToolAnnotations | undefined>): Promise<boolean> {\n    if (this.resolvedAllowedToolNames) {\n      return this.resolvedAllowedToolNames.includes(toolName);\n    }\n    return isToolAllowed({\n      toolName,\n      annotations: await resolveAnnotations(),\n      enableSelectors: this.enableTools,\n      disableSelectors: this.disableTools,\n    });\n  }\n\n  /**\n   * Best-effort allow-list for the sandbox. After a listTools() call returns the concrete names;\n   * before that, `@all` with no disables means \"unrestricted\" (undefined), else the literal names.\n   */\n  allowedNamesForSandbox(): string[] | undefined {\n    if (this.resolvedAllowedToolNames) {\n      return this.resolvedAllowedToolNames;\n    }\n    if (selectorsIncludeAll(this.enableTools) && this.disableTools.length === 0) {\n      return undefined;\n    }\n    return literalToolNames(this.enableTools);\n  }\n\n  /**\n   * Whether the tool requires human approval. Honors `requireApprovalForTools` exactly: omit /\n   * undefined defaults to write+destructive (constructor); an explicit list — including empty —\n   * is exact.\n   */\n  requiresApproval(toolName: string, annotations: ToolAnnotations | undefined): boolean {\n    return toolRequiresApproval(toolName, annotations, this.requireApprovalForTools);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,2BAOO;AAkBA,IAAM,qBAAN,MAAyB;AAAA,EACrB;AAAA,EACA;AAAA,EAEQ;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA,EAGT;AAAA,EAER,YAAY,QAA6D;AACvE,SAAK,cAAc,OAAO,UAAU;AACpC,SAAK,eAAe,OAAO,UAAU;AACrC,SAAK,eAAe,OAAO,UAAU;AACrC,SAAK,0BAA0B,OAAO,UAAU,2BAA2B;AAC3E,SAAK,UAAU,OAAO;AACtB,SAAK,oBAAoB,OAAO,WAAW,KAAK,aAAa,SAAS;AAAA,EACxE;AAAA;AAAA,EAGA,sBAAsB,OAAoC;AACxD,UAAM,iBAAiB,IAAI,IAAI,MAAM,IAAI,OAAK,EAAE,IAAI,CAAC;AACrD,eAAO,uCAAiB,KAAK,WAAW,EAAE,OAAO,UAAQ,CAAC,eAAe,IAAI,IAAI,CAAC;AAAA,EACpF;AAAA;AAAA,EAGA,kBAAkB,OAA6C;AAC7D,UAAM,WAAW,MAAM;AAAA,MAAO,cAC5B,oCAAc;AAAA,QACZ,UAAU,KAAK;AAAA,QACf,aAAa,KAAK;AAAA,QAClB,iBAAiB,KAAK;AAAA,QACtB,kBAAkB,KAAK;AAAA,MACzB,CAAC;AAAA,IACH;AACA,SAAK,2BAA2B,SAAS,IAAI,OAAK,EAAE,IAAI;AACxD,WAAO,SAAS,IAAI,WAAS,EAAE,GAAG,MAAM,SAAS,KAAK,gBAAgB,KAAK,MAAM,KAAK,WAAW,EAAE,EAAE;AAAA,EACvG;AAAA,EAEQ,gBAAgB,UAAkB,aAAmD;AAE3F,QAAI,KAAK,QAAS,QAAO;AAEzB,eAAO,6CAAuB,UAAU,aAAa,KAAK,YAAY;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UAAU,UAAkB,oBAAkF;AAClH,QAAI,KAAK,0BAA0B;AACjC,aAAO,KAAK,yBAAyB,SAAS,QAAQ;AAAA,IACxD;AACA,eAAO,oCAAc;AAAA,MACnB;AAAA,MACA,aAAa,MAAM,mBAAmB;AAAA,MACtC,iBAAiB,KAAK;AAAA,MACtB,kBAAkB,KAAK;AAAA,IACzB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,yBAA+C;AAC7C,QAAI,KAAK,0BAA0B;AACjC,aAAO,KAAK;AAAA,IACd;AACA,YAAI,0CAAoB,KAAK,WAAW,KAAK,KAAK,aAAa,WAAW,GAAG;AAC3E,aAAO;AAAA,IACT;AACA,eAAO,uCAAiB,KAAK,WAAW;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAiB,UAAkB,aAAmD;AACpF,eAAO,2CAAqB,UAAU,aAAa,KAAK,uBAAuB;AAAA,EACjF;AACF;","names":[]}

package/dist/core/mcp/ToolSelectorPolicy.mjs

@@ -0,0 +1,90 @@
+// src/core/mcp/ToolSelectorPolicy.ts
+import {
+  DEFAULT_REQUIRE_APPROVAL_FOR_TOOLS,
+  isToolAllowed,
+  literalToolNames,
+  selectorsIncludeAll,
+  toolMatchesAnySelector,
+  toolRequiresApproval
+} from "./toolSelectors.mjs";
+var ToolSelectorPolicy = class {
+  preload;
+  hasPreloadedTools;
+  enableTools;
+  disableTools;
+  preloadTools;
+  requireApprovalForTools;
+  // Tool names that survived enable/disable filtering on the most recent filterAndAnnotate() call.
+  // Used by the sandbox allow-list and as the fast path for callTool gating.
+  resolvedAllowedToolNames;
+  constructor(params) {
+    this.enableTools = params.selectors.enableTools;
+    this.disableTools = params.selectors.disableTools;
+    this.preloadTools = params.selectors.preloadTools;
+    this.requireApprovalForTools = params.selectors.requireApprovalForTools ?? DEFAULT_REQUIRE_APPROVAL_FOR_TOOLS;
+    this.preload = params.preload;
+    this.hasPreloadedTools = params.preload || this.preloadTools.length > 0;
+  }
+  /** Literal enable_tools names that are not present on the server (caller throws if non-empty). */
+  missingEnableLiterals(tools) {
+    const availableNames = new Set(tools.map((t) => t.name));
+    return literalToolNames(this.enableTools).filter((name) => !availableNames.has(name));
+  }
+  /** Filter by enable/disable, record the resolved allow-list, and annotate per-tool preload. */
+  filterAndAnnotate(tools) {
+    const filtered = tools.filter(
+      (tool) => isToolAllowed({
+        toolName: tool.name,
+        annotations: tool.annotations,
+        enableSelectors: this.enableTools,
+        disableSelectors: this.disableTools
+      })
+    );
+    this.resolvedAllowedToolNames = filtered.map((t) => t.name);
+    return filtered.map((tool) => ({ ...tool, preload: this.isToolPreloaded(tool.name, tool.annotations) }));
+  }
+  isToolPreloaded(toolName, annotations) {
+    if (this.preload) return true;
+    return toolMatchesAnySelector(toolName, annotations, this.preloadTools);
+  }
+  /**
+   * Whether a tool may be called. Uses the resolved allow-list once listTools() has run; before that
+   * falls back to matching against the raw selectors, resolving annotations lazily only when needed.
+   */
+  async isAllowed(toolName, resolveAnnotations) {
+    if (this.resolvedAllowedToolNames) {
+      return this.resolvedAllowedToolNames.includes(toolName);
+    }
+    return isToolAllowed({
+      toolName,
+      annotations: await resolveAnnotations(),
+      enableSelectors: this.enableTools,
+      disableSelectors: this.disableTools
+    });
+  }
+  /**
+   * Best-effort allow-list for the sandbox. After a listTools() call returns the concrete names;
+   * before that, `@all` with no disables means "unrestricted" (undefined), else the literal names.
+   */
+  allowedNamesForSandbox() {
+    if (this.resolvedAllowedToolNames) {
+      return this.resolvedAllowedToolNames;
+    }
+    if (selectorsIncludeAll(this.enableTools) && this.disableTools.length === 0) {
+      return void 0;
+    }
+    return literalToolNames(this.enableTools);
+  }
+  /**
+   * Whether the tool requires human approval. Honors `requireApprovalForTools` exactly: omit /
+   * undefined defaults to write+destructive (constructor); an explicit list — including empty —
+   * is exact.
+   */
+  requiresApproval(toolName, annotations) {
+    return toolRequiresApproval(toolName, annotations, this.requireApprovalForTools);
+  }
+};
+export {
+  ToolSelectorPolicy
+};
+//# sourceMappingURL=ToolSelectorPolicy.mjs.map

package/dist/core/mcp/ToolSelectorPolicy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/mcp/ToolSelectorPolicy.ts"],"sourcesContent":["import type { ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';\nimport type { AgentToolSchema } from './IMCPServer';\nimport {\n  DEFAULT_REQUIRE_APPROVAL_FOR_TOOLS,\n  isToolAllowed,\n  literalToolNames,\n  selectorsIncludeAll,\n  toolMatchesAnySelector,\n  toolRequiresApproval,\n} from './toolSelectors';\n\n/**\n * Per-server tool selectors. Enable/disable/preload tags: `@all`, `@read-only`.\n * Approval tags: `@all`, `@write`, `@destructive`.\n */\nexport interface ToolSelectorConfig {\n  enableTools: string[];\n  disableTools: string[];\n  preloadTools: string[];\n  requireApprovalForTools?: string[] | undefined;\n}\n\n/**\n * Encapsulates enable/disable/preload/approval selector policy for a single MCP server. Pure: it\n * never throws or does IO — callers decide how to surface a disallowed/missing tool so each can\n * raise its own error type.\n */\nexport class ToolSelectorPolicy {\n  readonly preload: boolean;\n  readonly hasPreloadedTools: boolean;\n\n  private readonly enableTools: string[];\n  private readonly disableTools: string[];\n  private readonly preloadTools: string[];\n  private readonly requireApprovalForTools: string[];\n  // Tool names that survived enable/disable filtering on the most recent filterAndAnnotate() call.\n  // Used by the sandbox allow-list and as the fast path for callTool gating.\n  private resolvedAllowedToolNames: string[] | undefined;\n\n  constructor(params: { selectors: ToolSelectorConfig; preload: boolean }) {\n    this.enableTools = params.selectors.enableTools;\n    this.disableTools = params.selectors.disableTools;\n    this.preloadTools = params.selectors.preloadTools;\n    this.requireApprovalForTools = params.selectors.requireApprovalForTools ?? DEFAULT_REQUIRE_APPROVAL_FOR_TOOLS;\n    this.preload = params.preload;\n    this.hasPreloadedTools = params.preload || this.preloadTools.length > 0;\n  }\n\n  /** Literal enable_tools names that are not present on the server (caller throws if non-empty). */\n  missingEnableLiterals(tools: AgentToolSchema[]): string[] {\n    const availableNames = new Set(tools.map(t => t.name));\n    return literalToolNames(this.enableTools).filter(name => !availableNames.has(name));\n  }\n\n  /** Filter by enable/disable, record the resolved allow-list, and annotate per-tool preload. */\n  filterAndAnnotate(tools: AgentToolSchema[]): AgentToolSchema[] {\n    const filtered = tools.filter(tool =>\n      isToolAllowed({\n        toolName: tool.name,\n        annotations: tool.annotations,\n        enableSelectors: this.enableTools,\n        disableSelectors: this.disableTools,\n      }),\n    );\n    this.resolvedAllowedToolNames = filtered.map(t => t.name);\n    return filtered.map(tool => ({ ...tool, preload: this.isToolPreloaded(tool.name, tool.annotations) }));\n  }\n\n  private isToolPreloaded(toolName: string, annotations: ToolAnnotations | undefined): boolean {\n    // Fully-preloaded server: every allowed tool is loaded into context.\n    if (this.preload) return true;\n    // Otherwise only the tools matching `preload_tools` stay eager.\n    return toolMatchesAnySelector(toolName, annotations, this.preloadTools);\n  }\n\n  /**\n   * Whether a tool may be called. Uses the resolved allow-list once listTools() has run; before that\n   * falls back to matching against the raw selectors, resolving annotations lazily only when needed.\n   */\n  async isAllowed(toolName: string, resolveAnnotations: () => Promise<ToolAnnotations | undefined>): Promise<boolean> {\n    if (this.resolvedAllowedToolNames) {\n      return this.resolvedAllowedToolNames.includes(toolName);\n    }\n    return isToolAllowed({\n      toolName,\n      annotations: await resolveAnnotations(),\n      enableSelectors: this.enableTools,\n      disableSelectors: this.disableTools,\n    });\n  }\n\n  /**\n   * Best-effort allow-list for the sandbox. After a listTools() call returns the concrete names;\n   * before that, `@all` with no disables means \"unrestricted\" (undefined), else the literal names.\n   */\n  allowedNamesForSandbox(): string[] | undefined {\n    if (this.resolvedAllowedToolNames) {\n      return this.resolvedAllowedToolNames;\n    }\n    if (selectorsIncludeAll(this.enableTools) && this.disableTools.length === 0) {\n      return undefined;\n    }\n    return literalToolNames(this.enableTools);\n  }\n\n  /**\n   * Whether the tool requires human approval. Honors `requireApprovalForTools` exactly: omit /\n   * undefined defaults to write+destructive (constructor); an explicit list — including empty —\n   * is exact.\n   */\n  requiresApproval(toolName: string, annotations: ToolAnnotations | undefined): boolean {\n    return toolRequiresApproval(toolName, annotations, this.requireApprovalForTools);\n  }\n}\n"],"mappings":";AAEA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAkBA,IAAM,qBAAN,MAAyB;AAAA,EACrB;AAAA,EACA;AAAA,EAEQ;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA,EAGT;AAAA,EAER,YAAY,QAA6D;AACvE,SAAK,cAAc,OAAO,UAAU;AACpC,SAAK,eAAe,OAAO,UAAU;AACrC,SAAK,eAAe,OAAO,UAAU;AACrC,SAAK,0BAA0B,OAAO,UAAU,2BAA2B;AAC3E,SAAK,UAAU,OAAO;AACtB,SAAK,oBAAoB,OAAO,WAAW,KAAK,aAAa,SAAS;AAAA,EACxE;AAAA;AAAA,EAGA,sBAAsB,OAAoC;AACxD,UAAM,iBAAiB,IAAI,IAAI,MAAM,IAAI,OAAK,EAAE,IAAI,CAAC;AACrD,WAAO,iBAAiB,KAAK,WAAW,EAAE,OAAO,UAAQ,CAAC,eAAe,IAAI,IAAI,CAAC;AAAA,EACpF;AAAA;AAAA,EAGA,kBAAkB,OAA6C;AAC7D,UAAM,WAAW,MAAM;AAAA,MAAO,UAC5B,cAAc;AAAA,QACZ,UAAU,KAAK;AAAA,QACf,aAAa,KAAK;AAAA,QAClB,iBAAiB,KAAK;AAAA,QACtB,kBAAkB,KAAK;AAAA,MACzB,CAAC;AAAA,IACH;AACA,SAAK,2BAA2B,SAAS,IAAI,OAAK,EAAE,IAAI;AACxD,WAAO,SAAS,IAAI,WAAS,EAAE,GAAG,MAAM,SAAS,KAAK,gBAAgB,KAAK,MAAM,KAAK,WAAW,EAAE,EAAE;AAAA,EACvG;AAAA,EAEQ,gBAAgB,UAAkB,aAAmD;AAE3F,QAAI,KAAK,QAAS,QAAO;AAEzB,WAAO,uBAAuB,UAAU,aAAa,KAAK,YAAY;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UAAU,UAAkB,oBAAkF;AAClH,QAAI,KAAK,0BAA0B;AACjC,aAAO,KAAK,yBAAyB,SAAS,QAAQ;AAAA,IACxD;AACA,WAAO,cAAc;AAAA,MACnB;AAAA,MACA,aAAa,MAAM,mBAAmB;AAAA,MACtC,iBAAiB,KAAK;AAAA,MACtB,kBAAkB,KAAK;AAAA,IACzB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,yBAA+C;AAC7C,QAAI,KAAK,0BAA0B;AACjC,aAAO,KAAK;AAAA,IACd;AACA,QAAI,oBAAoB,KAAK,WAAW,KAAK,KAAK,aAAa,WAAW,GAAG;AAC3E,aAAO;AAAA,IACT;AACA,WAAO,iBAAiB,KAAK,WAAW;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAiB,UAAkB,aAAmD;AACpF,WAAO,qBAAqB,UAAU,aAAa,KAAK,uBAAuB;AAAA,EACjF;AACF;","names":[]}

package/dist/core/mcp/ToolSet.d.ts

@@ -0,0 +1,31 @@
+import type { CallToolRequest } from '@modelcontextprotocol/sdk/types.js';
+import type { ApprovalDecision } from '../events/schema';
+import type { InternalToolCallInfo } from '../llm/LLMTypes';
+import { type CallToolResponse, type IToolSet, type ListToolsResponse, type ToolSource } from './IMCPServer';
+import { type ToolSelectorConfig } from './ToolSelectorPolicy';
+/**
+ * Per-agent {@link IToolSet} view over a shared, policy-free {@link ToolSource}, applying the
+ * enable/disable/preload/approval selectors. Many can wrap one source without policy bleed.
+ */
+export declare class ToolSet implements IToolSet {
+    readonly name: string;
+    readonly id: string;
+    readonly description?: string | undefined;
+    readonly preload: boolean;
+    readonly hasPreloadedTools: boolean;
+    private readonly source;
+    private readonly policy;
+    constructor(params: {
+        source: ToolSource;
+        selectors: ToolSelectorConfig;
+        preload: boolean;
+    });
+    getAllowedToolNamesForSandbox(): string[] | undefined;
+    listTools(): Promise<ListToolsResponse>;
+    callTool(params: CallToolRequest['params'], decision?: ApprovalDecision): Promise<CallToolResponse>;
+    toolCallInfo(params: CallToolRequest['params'], resolveUnderlyingTool?: boolean): Promise<InternalToolCallInfo>;
+    private assertToolAllowed;
+    private buildToolCallInfo;
+    private resolveAnnotations;
+}
+//# sourceMappingURL=ToolSet.d.ts.map

package/dist/core/mcp/ToolSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolSet.d.ts","sourceRoot":"","sources":["../../../src/core/mcp/ToolSet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,oCAAoC,CAAC;AAE3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAKL,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,iBAAiB,EACtB,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAEnF;;;GAGG;AACH,qBAAa,OAAQ,YAAW,QAAQ;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IAEpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAE5C,YAAY,MAAM,EAAE;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,SAAS,EAAE,kBAAkB,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,EAW1F;IAED,6BAA6B,IAAI,MAAM,EAAE,GAAG,SAAS,CAEpD;IAEK,SAAS,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAiB5C;IAEK,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6BxG;IAEK,YAAY,CAChB,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,EACjC,qBAAqB,CAAC,EAAE,OAAO,GAC9B,OAAO,CAAC,oBAAoB,CAAC,CAG/B;YAEa,iBAAiB;YAOjB,iBAAiB;YAWjB,kBAAkB;CAKjC"}

package/dist/core/mcp/ToolSet.js

@@ -0,0 +1,119 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/mcp/ToolSet.ts
+var ToolSet_exports = {};
+__export(ToolSet_exports, {
+  ToolSet: () => ToolSet
+});
+module.exports = __toCommonJS(ToolSet_exports);
+var import_errors = require("../errors.js");
+var import_IMCPServer = require("./IMCPServer.js");
+var import_ToolSelectorPolicy = require("./ToolSelectorPolicy.js");
+var ToolSet = class {
+  name;
+  id;
+  description;
+  preload;
+  hasPreloadedTools;
+  source;
+  policy;
+  constructor(params) {
+    this.source = params.source;
+    this.name = params.source.name;
+    this.id = params.source.id;
+    this.description = params.source.description;
+    this.policy = new import_ToolSelectorPolicy.ToolSelectorPolicy({
+      selectors: params.selectors,
+      preload: params.preload
+    });
+    this.preload = this.policy.preload;
+    this.hasPreloadedTools = this.policy.hasPreloadedTools;
+  }
+  getAllowedToolNamesForSandbox() {
+    return this.policy.allowedNamesForSandbox();
+  }
+  async listTools() {
+    const response = await this.source.listTools();
+    if ((0, import_IMCPServer.isAuthRequired)(response)) return response;
+    const tools = response.result.tools;
+    const missingTools = this.policy.missingEnableLiterals(tools);
+    if (missingTools.length > 0) {
+      throw new import_errors.McpConnectionError(
+        `Requested tools not found in MCP server ${this.name}: ${missingTools.join(", ")}`,
+        422
+      );
+    }
+    return {
+      result: { tools: this.policy.filterAndAnnotate(tools) },
+      wasInitialized: response.wasInitialized
+    };
+  }
+  async callTool(params, decision) {
+    const listed = await this.source.listTools();
+    if ((0, import_IMCPServer.isAuthRequired)(listed)) return listed;
+    const annotations = findAnnotations(listed.result.tools, params.name);
+    await this.assertToolAllowed(params.name, annotations);
+    const tool_info = await this.buildToolCallInfo(params, annotations);
+    if (!decision && tool_info.is_approval_required) {
+      return { approvalRequired: { tool_info } };
+    }
+    if (decision?.status === "deny") {
+      const reason = decision.reason ?? "no reason provided";
+      return (0, import_IMCPServer.toolResultResponse)({
+        text: JSON.stringify({ error: `User denied tool call: ${reason}` }),
+        isError: true
+      });
+    }
+    const response = await this.source.callTool(params, decision);
+    if (listed.wasInitialized && (0, import_IMCPServer.isCallToolResponseResult)(response) && !response.wasInitialized) {
+      return { ...response, wasInitialized: listed.wasInitialized };
+    }
+    return response;
+  }
+  async toolCallInfo(params, resolveUnderlyingTool) {
+    const annotations = await this.resolveAnnotations(params.name);
+    return this.buildToolCallInfo(params, annotations, resolveUnderlyingTool);
+  }
+  async assertToolAllowed(toolName, annotations) {
+    const allowed = await this.policy.isAllowed(toolName, () => Promise.resolve(annotations));
+    if (!allowed) {
+      throw new import_errors.McpConnectionError(`Tool '${toolName}' is not allowed on MCP server ${this.name}`, 403);
+    }
+  }
+  async buildToolCallInfo(params, annotations, resolveUnderlyingTool) {
+    return {
+      ...await this.source.toolCallInfo(params, resolveUnderlyingTool),
+      is_approval_required: this.policy.requiresApproval(params.name, annotations)
+    };
+  }
+  async resolveAnnotations(toolName) {
+    const listed = await this.source.listTools();
+    if ((0, import_IMCPServer.isAuthRequired)(listed)) return void 0;
+    return findAnnotations(listed.result.tools, toolName);
+  }
+};
+function findAnnotations(tools, toolName) {
+  return tools.find((t) => t.name === toolName)?.annotations;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolSet
+});
+//# sourceMappingURL=ToolSet.js.map

package/dist/core/mcp/ToolSet.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/mcp/ToolSet.ts"],"sourcesContent":["import type { CallToolRequest, ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';\nimport { McpConnectionError } from '../errors';\nimport type { ApprovalDecision } from '../events/schema';\nimport type { InternalToolCallInfo } from '../llm/LLMTypes';\nimport {\n  isAuthRequired,\n  isCallToolResponseResult,\n  toolResultResponse,\n  type AgentToolSchema,\n  type CallToolResponse,\n  type IToolSet,\n  type ListToolsResponse,\n  type ToolSource,\n} from './IMCPServer';\nimport { ToolSelectorPolicy, type ToolSelectorConfig } from './ToolSelectorPolicy';\n\n/**\n * Per-agent {@link IToolSet} view over a shared, policy-free {@link ToolSource}, applying the\n * enable/disable/preload/approval selectors. Many can wrap one source without policy bleed.\n */\nexport class ToolSet implements IToolSet {\n  readonly name: string;\n  readonly id: string;\n  readonly description?: string | undefined;\n  readonly preload: boolean;\n  readonly hasPreloadedTools: boolean;\n\n  private readonly source: ToolSource;\n  private readonly policy: ToolSelectorPolicy;\n\n  constructor(params: { source: ToolSource; selectors: ToolSelectorConfig; preload: boolean }) {\n    this.source = params.source;\n    this.name = params.source.name;\n    this.id = params.source.id;\n    this.description = params.source.description;\n    this.policy = new ToolSelectorPolicy({\n      selectors: params.selectors,\n      preload: params.preload,\n    });\n    this.preload = this.policy.preload;\n    this.hasPreloadedTools = this.policy.hasPreloadedTools;\n  }\n\n  getAllowedToolNamesForSandbox(): string[] | undefined {\n    return this.policy.allowedNamesForSandbox();\n  }\n\n  async listTools(): Promise<ListToolsResponse> {\n    const response = await this.source.listTools();\n    if (isAuthRequired(response)) return response;\n\n    const tools = response.result.tools;\n    const missingTools = this.policy.missingEnableLiterals(tools);\n    if (missingTools.length > 0) {\n      throw new McpConnectionError(\n        `Requested tools not found in MCP server ${this.name}: ${missingTools.join(', ')}`,\n        422,\n      );\n    }\n\n    return {\n      result: { tools: this.policy.filterAndAnnotate(tools) },\n      wasInitialized: response.wasInitialized,\n    };\n  }\n\n  async callTool(params: CallToolRequest['params'], decision?: ApprovalDecision): Promise<CallToolResponse> {\n    // Prime the source and surface auth-required before the annotation-based allow/approval checks\n    // (which would otherwise see missing annotations and wrongly 403).\n    const listed = await this.source.listTools();\n    if (isAuthRequired(listed)) return listed;\n    const annotations = findAnnotations(listed.result.tools, params.name);\n\n    await this.assertToolAllowed(params.name, annotations);\n\n    const tool_info = await this.buildToolCallInfo(params, annotations);\n    if (!decision && tool_info.is_approval_required) {\n      return { approvalRequired: { tool_info } };\n    }\n\n    if (decision?.status === 'deny') {\n      const reason = decision.reason ?? 'no reason provided';\n      return toolResultResponse({\n        text: JSON.stringify({ error: `User denied tool call: ${reason}` }),\n        isError: true,\n      });\n    }\n\n    const response = await this.source.callTool(params, decision);\n    // The priming listTools() may have captured the first-connect init; carry it forward since the\n    // subsequent callTool sees an already-open connection and reports none.\n    if (listed.wasInitialized && isCallToolResponseResult(response) && !response.wasInitialized) {\n      return { ...response, wasInitialized: listed.wasInitialized };\n    }\n    return response;\n  }\n\n  async toolCallInfo(\n    params: CallToolRequest['params'],\n    resolveUnderlyingTool?: boolean,\n  ): Promise<InternalToolCallInfo> {\n    const annotations = await this.resolveAnnotations(params.name);\n    return this.buildToolCallInfo(params, annotations, resolveUnderlyingTool);\n  }\n\n  private async assertToolAllowed(toolName: string, annotations: ToolAnnotations | undefined): Promise<void> {\n    const allowed = await this.policy.isAllowed(toolName, () => Promise.resolve(annotations));\n    if (!allowed) {\n      throw new McpConnectionError(`Tool '${toolName}' is not allowed on MCP server ${this.name}`, 403);\n    }\n  }\n\n  private async buildToolCallInfo(\n    params: CallToolRequest['params'],\n    annotations: ToolAnnotations | undefined,\n    resolveUnderlyingTool?: boolean,\n  ): Promise<InternalToolCallInfo> {\n    return {\n      ...(await this.source.toolCallInfo(params, resolveUnderlyingTool)),\n      is_approval_required: this.policy.requiresApproval(params.name, annotations),\n    };\n  }\n\n  private async resolveAnnotations(toolName: string): Promise<ToolAnnotations | undefined> {\n    const listed = await this.source.listTools();\n    if (isAuthRequired(listed)) return undefined;\n    return findAnnotations(listed.result.tools, toolName);\n  }\n}\n\nfunction findAnnotations(tools: AgentToolSchema[], toolName: string): ToolAnnotations | undefined {\n  return tools.find(t => t.name === toolName)?.annotations;\n}\n"],"mappings":"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","names":[]}

package/dist/core/mcp/ToolSet.mjs

@@ -0,0 +1,98 @@
+// src/core/mcp/ToolSet.ts
+import { McpConnectionError } from "../errors.mjs";
+import {
+  isAuthRequired,
+  isCallToolResponseResult,
+  toolResultResponse
+} from "./IMCPServer.mjs";
+import { ToolSelectorPolicy } from "./ToolSelectorPolicy.mjs";
+var ToolSet = class {
+  name;
+  id;
+  description;
+  preload;
+  hasPreloadedTools;
+  source;
+  policy;
+  constructor(params) {
+    this.source = params.source;
+    this.name = params.source.name;
+    this.id = params.source.id;
+    this.description = params.source.description;
+    this.policy = new ToolSelectorPolicy({
+      selectors: params.selectors,
+      preload: params.preload
+    });
+    this.preload = this.policy.preload;
+    this.hasPreloadedTools = this.policy.hasPreloadedTools;
+  }
+  getAllowedToolNamesForSandbox() {
+    return this.policy.allowedNamesForSandbox();
+  }
+  async listTools() {
+    const response = await this.source.listTools();
+    if (isAuthRequired(response)) return response;
+    const tools = response.result.tools;
+    const missingTools = this.policy.missingEnableLiterals(tools);
+    if (missingTools.length > 0) {
+      throw new McpConnectionError(
+        `Requested tools not found in MCP server ${this.name}: ${missingTools.join(", ")}`,
+        422
+      );
+    }
+    return {
+      result: { tools: this.policy.filterAndAnnotate(tools) },
+      wasInitialized: response.wasInitialized
+    };
+  }
+  async callTool(params, decision) {
+    const listed = await this.source.listTools();
+    if (isAuthRequired(listed)) return listed;
+    const annotations = findAnnotations(listed.result.tools, params.name);
+    await this.assertToolAllowed(params.name, annotations);
+    const tool_info = await this.buildToolCallInfo(params, annotations);
+    if (!decision && tool_info.is_approval_required) {
+      return { approvalRequired: { tool_info } };
+    }
+    if (decision?.status === "deny") {
+      const reason = decision.reason ?? "no reason provided";
+      return toolResultResponse({
+        text: JSON.stringify({ error: `User denied tool call: ${reason}` }),
+        isError: true
+      });
+    }
+    const response = await this.source.callTool(params, decision);
+    if (listed.wasInitialized && isCallToolResponseResult(response) && !response.wasInitialized) {
+      return { ...response, wasInitialized: listed.wasInitialized };
+    }
+    return response;
+  }
+  async toolCallInfo(params, resolveUnderlyingTool) {
+    const annotations = await this.resolveAnnotations(params.name);
+    return this.buildToolCallInfo(params, annotations, resolveUnderlyingTool);
+  }
+  async assertToolAllowed(toolName, annotations) {
+    const allowed = await this.policy.isAllowed(toolName, () => Promise.resolve(annotations));
+    if (!allowed) {
+      throw new McpConnectionError(`Tool '${toolName}' is not allowed on MCP server ${this.name}`, 403);
+    }
+  }
+  async buildToolCallInfo(params, annotations, resolveUnderlyingTool) {
+    return {
+      ...await this.source.toolCallInfo(params, resolveUnderlyingTool),
+      is_approval_required: this.policy.requiresApproval(params.name, annotations)
+    };
+  }
+  async resolveAnnotations(toolName) {
+    const listed = await this.source.listTools();
+    if (isAuthRequired(listed)) return void 0;
+    return findAnnotations(listed.result.tools, toolName);
+  }
+};
+function findAnnotations(tools, toolName) {
+  return tools.find((t) => t.name === toolName)?.annotations;
+}
+export {
+  ToolSet
+};
+//# sourceMappingURL=ToolSet.mjs.map

package/dist/core/mcp/ToolSet.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/mcp/ToolSet.ts"],"sourcesContent":["import type { CallToolRequest, ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';\nimport { McpConnectionError } from '../errors';\nimport type { ApprovalDecision } from '../events/schema';\nimport type { InternalToolCallInfo } from '../llm/LLMTypes';\nimport {\n  isAuthRequired,\n  isCallToolResponseResult,\n  toolResultResponse,\n  type AgentToolSchema,\n  type CallToolResponse,\n  type IToolSet,\n  type ListToolsResponse,\n  type ToolSource,\n} from './IMCPServer';\nimport { ToolSelectorPolicy, type ToolSelectorConfig } from './ToolSelectorPolicy';\n\n/**\n * Per-agent {@link IToolSet} view over a shared, policy-free {@link ToolSource}, applying the\n * enable/disable/preload/approval selectors. Many can wrap one source without policy bleed.\n */\nexport class ToolSet implements IToolSet {\n  readonly name: string;\n  readonly id: string;\n  readonly description?: string | undefined;\n  readonly preload: boolean;\n  readonly hasPreloadedTools: boolean;\n\n  private readonly source: ToolSource;\n  private readonly policy: ToolSelectorPolicy;\n\n  constructor(params: { source: ToolSource; selectors: ToolSelectorConfig; preload: boolean }) {\n    this.source = params.source;\n    this.name = params.source.name;\n    this.id = params.source.id;\n    this.description = params.source.description;\n    this.policy = new ToolSelectorPolicy({\n      selectors: params.selectors,\n      preload: params.preload,\n    });\n    this.preload = this.policy.preload;\n    this.hasPreloadedTools = this.policy.hasPreloadedTools;\n  }\n\n  getAllowedToolNamesForSandbox(): string[] | undefined {\n    return this.policy.allowedNamesForSandbox();\n  }\n\n  async listTools(): Promise<ListToolsResponse> {\n    const response = await this.source.listTools();\n    if (isAuthRequired(response)) return response;\n\n    const tools = response.result.tools;\n    const missingTools = this.policy.missingEnableLiterals(tools);\n    if (missingTools.length > 0) {\n      throw new McpConnectionError(\n        `Requested tools not found in MCP server ${this.name}: ${missingTools.join(', ')}`,\n        422,\n      );\n    }\n\n    return {\n      result: { tools: this.policy.filterAndAnnotate(tools) },\n      wasInitialized: response.wasInitialized,\n    };\n  }\n\n  async callTool(params: CallToolRequest['params'], decision?: ApprovalDecision): Promise<CallToolResponse> {\n    // Prime the source and surface auth-required before the annotation-based allow/approval checks\n    // (which would otherwise see missing annotations and wrongly 403).\n    const listed = await this.source.listTools();\n    if (isAuthRequired(listed)) return listed;\n    const annotations = findAnnotations(listed.result.tools, params.name);\n\n    await this.assertToolAllowed(params.name, annotations);\n\n    const tool_info = await this.buildToolCallInfo(params, annotations);\n    if (!decision && tool_info.is_approval_required) {\n      return { approvalRequired: { tool_info } };\n    }\n\n    if (decision?.status === 'deny') {\n      const reason = decision.reason ?? 'no reason provided';\n      return toolResultResponse({\n        text: JSON.stringify({ error: `User denied tool call: ${reason}` }),\n        isError: true,\n      });\n    }\n\n    const response = await this.source.callTool(params, decision);\n    // The priming listTools() may have captured the first-connect init; carry it forward since the\n    // subsequent callTool sees an already-open connection and reports none.\n    if (listed.wasInitialized && isCallToolResponseResult(response) && !response.wasInitialized) {\n      return { ...response, wasInitialized: listed.wasInitialized };\n    }\n    return response;\n  }\n\n  async toolCallInfo(\n    params: CallToolRequest['params'],\n    resolveUnderlyingTool?: boolean,\n  ): Promise<InternalToolCallInfo> {\n    const annotations = await this.resolveAnnotations(params.name);\n    return this.buildToolCallInfo(params, annotations, resolveUnderlyingTool);\n  }\n\n  private async assertToolAllowed(toolName: string, annotations: ToolAnnotations | undefined): Promise<void> {\n    const allowed = await this.policy.isAllowed(toolName, () => Promise.resolve(annotations));\n    if (!allowed) {\n      throw new McpConnectionError(`Tool '${toolName}' is not allowed on MCP server ${this.name}`, 403);\n    }\n  }\n\n  private async buildToolCallInfo(\n    params: CallToolRequest['params'],\n    annotations: ToolAnnotations | undefined,\n    resolveUnderlyingTool?: boolean,\n  ): Promise<InternalToolCallInfo> {\n    return {\n      ...(await this.source.toolCallInfo(params, resolveUnderlyingTool)),\n      is_approval_required: this.policy.requiresApproval(params.name, annotations),\n    };\n  }\n\n  private async resolveAnnotations(toolName: string): Promise<ToolAnnotations | undefined> {\n    const listed = await this.source.listTools();\n    if (isAuthRequired(listed)) return undefined;\n    return findAnnotations(listed.result.tools, toolName);\n  }\n}\n\nfunction findAnnotations(tools: AgentToolSchema[], toolName: string): ToolAnnotations | undefined {\n  return tools.find(t => t.name === toolName)?.annotations;\n}\n"],"mappings":"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","names":[]}

package/dist/core/mcp/convertMCPServers.d.ts

@@ -0,0 +1,22 @@
+import type { ChatCompletionTool } from 'openai/resources/chat';
+import type { MCPServerInitInfo } from '../events/schema';
+import type { MCPAuthRequired } from '../mcp/IMCPServer';
+import { type IToolSet } from './IMCPServer';
+export interface MappedMCPTool {
+    toolSet: IToolSet;
+    originalToolName: string;
+}
+export interface ConvertToolsResult {
+    tools: ChatCompletionTool[];
+    toolMapping: Map<string, MappedMCPTool>;
+}
+export interface ConvertMCPServersToToolsResult {
+    convertedTools: ConvertToolsResult;
+    initializationInfo: MCPServerInitInfo[];
+    authRequirementInfo: MCPAuthRequired[];
+}
+export declare function convertMCPServersToTools(params: {
+    tfyManagedServers: IToolSet[];
+    userServers: IToolSet[];
+}): Promise<ConvertMCPServersToToolsResult>;
+//# sourceMappingURL=convertMCPServers.d.ts.map

package/dist/core/mcp/convertMCPServers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertMCPServers.d.ts","sourceRoot":"","sources":["../../../src/core/mcp/convertMCPServers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,cAAc,CAAC;AAG7D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,QAAQ,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,8BAA8B;IAC7C,cAAc,EAAE,kBAAkB,CAAC;IACnC,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;IACxC,mBAAmB,EAAE,eAAe,EAAE,CAAC;CACxC;AAED,wBAAsB,wBAAwB,CAAC,MAAM,EAAE;IACrD,iBAAiB,EAAE,QAAQ,EAAE,CAAC;IAC9B,WAAW,EAAE,QAAQ,EAAE,CAAC;CACzB,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAiE1C"}

package/dist/core/mcp/convertMCPServers.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/mcp/convertMCPServers.ts
+var convertMCPServers_exports = {};
+__export(convertMCPServers_exports, {
+  convertMCPServersToTools: () => convertMCPServersToTools
+});
+module.exports = __toCommonJS(convertMCPServers_exports);
+var import_IMCPServer = require("./IMCPServer.js");
+var import_toolNames = require("./toolNames.js");
+async function convertMCPServersToTools(params) {
+  const { tfyManagedServers, userServers } = params;
+  const tools = [];
+  const toolMapping = /* @__PURE__ */ new Map();
+  const initializationInfo = [];
+  const authRequirementInfo = [];
+  const registeredNames = /* @__PURE__ */ new Set();
+  const filteredUserServers = userServers.filter((s) => s.preload || s.hasPreloadedTools);
+  const sortedTfyServers = [...tfyManagedServers].sort((a, b) => a.name > b.name ? 1 : -1);
+  const sortedUserServers = [...filteredUserServers].sort((a, b) => a.name > b.name ? 1 : -1);
+  const allServers = [...sortedTfyServers, ...sortedUserServers];
+  const listResults = await Promise.all(
+    allServers.map(async (server) => ({ serverName: server.name, response: await server.listTools() }))
+  );
+  for (let i = 0; i < allServers.length; i++) {
+    const listResult = listResults[i];
+    if (!listResult) continue;
+    const { serverName, response: listResponse } = listResult;
+    if ((0, import_IMCPServer.isAuthRequired)(listResponse)) {
+      authRequirementInfo.push(listResponse.authRequired);
+      continue;
+    }
+    const { result: mcpTools, wasInitialized } = listResponse;
+    if (wasInitialized) {
+      initializationInfo.push(wasInitialized);
+    }
+    const toolSet = allServers[i];
+    if (toolSet === void 0) {
+      throw new Error(`Unreachable: missing tool set at index ${String(i)}`);
+    }
+    const sortedTools = [...mcpTools.tools].sort((a, b) => a.name > b.name ? 1 : -1);
+    for (const mcpTool of sortedTools) {
+      if (!mcpTool.preload) continue;
+      const { name: toolName } = (0, import_toolNames.getUniqueSanitizedToolName)(mcpTool.name, registeredNames);
+      registeredNames.add(toolName);
+      const description = `mcp server: ${serverName}
+${mcpTool.description ?? ""}`;
+      tools.push({
+        type: "function",
+        function: {
+          name: toolName,
+          description,
+          parameters: {
+            type: "object",
+            properties: mcpTool.inputSchema.properties ?? {},
+            required: mcpTool.inputSchema.required ?? []
+          }
+        }
+      });
+      toolMapping.set(toolName, {
+        toolSet,
+        originalToolName: mcpTool.name
+      });
+    }
+  }
+  return { convertedTools: { tools, toolMapping }, initializationInfo, authRequirementInfo };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertMCPServersToTools
+});
+//# sourceMappingURL=convertMCPServers.js.map

package/dist/core/mcp/convertMCPServers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/mcp/convertMCPServers.ts"],"sourcesContent":["import type { ChatCompletionTool } from 'openai/resources/chat';\nimport type { MCPServerInitInfo } from '../events/schema';\nimport type { MCPAuthRequired } from '../mcp/IMCPServer';\nimport { type IToolSet, isAuthRequired } from './IMCPServer';\nimport { getUniqueSanitizedToolName } from './toolNames';\n\nexport interface MappedMCPTool {\n  toolSet: IToolSet;\n  originalToolName: string;\n}\n\nexport interface ConvertToolsResult {\n  tools: ChatCompletionTool[];\n  toolMapping: Map<string, MappedMCPTool>;\n}\n\nexport interface ConvertMCPServersToToolsResult {\n  convertedTools: ConvertToolsResult;\n  initializationInfo: MCPServerInitInfo[];\n  authRequirementInfo: MCPAuthRequired[];\n}\n\nexport async function convertMCPServersToTools(params: {\n  tfyManagedServers: IToolSet[];\n  userServers: IToolSet[];\n}): Promise<ConvertMCPServersToToolsResult> {\n  const { tfyManagedServers, userServers } = params;\n  const tools: ChatCompletionTool[] = [];\n  const toolMapping = new Map<string, MappedMCPTool>();\n  const initializationInfo: MCPServerInitInfo[] = [];\n  const authRequirementInfo: MCPAuthRequired[] = [];\n  const registeredNames = new Set<string>();\n\n  // Skip non-preloaded servers that have no preloaded tools, to avoid unnecessary listTools() calls and OAuth triggers.\n  // Non-preloaded servers with some preloaded tools are kept so those tools can be registered.\n  const filteredUserServers = userServers.filter(s => s.preload || s.hasPreloadedTools);\n\n  // TFY-managed servers first so they claim their original tool names before user servers.\n  const sortedTfyServers = [...tfyManagedServers].sort((a, b) => (a.name > b.name ? 1 : -1));\n  const sortedUserServers = [...filteredUserServers].sort((a, b) => (a.name > b.name ? 1 : -1));\n  const allServers = [...sortedTfyServers, ...sortedUserServers];\n\n  const listResults = await Promise.all(\n    allServers.map(async server => ({ serverName: server.name, response: await server.listTools() })),\n  );\n\n  for (let i = 0; i < allServers.length; i++) {\n    const listResult = listResults[i];\n    if (!listResult) continue;\n    const { serverName, response: listResponse } = listResult;\n    if (isAuthRequired(listResponse)) {\n      authRequirementInfo.push(listResponse.authRequired);\n      continue;\n    }\n    const { result: mcpTools, wasInitialized } = listResponse;\n    if (wasInitialized) {\n      initializationInfo.push(wasInitialized);\n    }\n\n    const toolSet = allServers[i];\n    if (toolSet === undefined) {\n      throw new Error(`Unreachable: missing tool set at index ${String(i)}`);\n    }\n    const sortedTools = [...mcpTools.tools].sort((a, b) => (a.name > b.name ? 1 : -1));\n    for (const mcpTool of sortedTools) {\n      if (!mcpTool.preload) continue;\n      const { name: toolName } = getUniqueSanitizedToolName(mcpTool.name, registeredNames);\n      registeredNames.add(toolName);\n      const description = `mcp server: ${serverName}\\n${mcpTool.description ?? ''}`;\n      tools.push({\n        type: 'function',\n        function: {\n          name: toolName,\n          description: description,\n          parameters: {\n            type: 'object',\n            properties: mcpTool.inputSchema.properties ?? {},\n            required: mcpTool.inputSchema.required ?? [],\n          },\n        },\n      });\n\n      toolMapping.set(toolName, {\n        toolSet,\n        originalToolName: mcpTool.name,\n      });\n    }\n  }\n\n  return { convertedTools: { tools, toolMapping }, initializationInfo, authRequirementInfo };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,wBAA8C;AAC9C,uBAA2C;AAkB3C,eAAsB,yBAAyB,QAGH;AAC1C,QAAM,EAAE,mBAAmB,YAAY,IAAI;AAC3C,QAAM,QAA8B,CAAC;AACrC,QAAM,cAAc,oBAAI,IAA2B;AACnD,QAAM,qBAA0C,CAAC;AACjD,QAAM,sBAAyC,CAAC;AAChD,QAAM,kBAAkB,oBAAI,IAAY;AAIxC,QAAM,sBAAsB,YAAY,OAAO,OAAK,EAAE,WAAW,EAAE,iBAAiB;AAGpF,QAAM,mBAAmB,CAAC,GAAG,iBAAiB,EAAE,KAAK,CAAC,GAAG,MAAO,EAAE,OAAO,EAAE,OAAO,IAAI,EAAG;AACzF,QAAM,oBAAoB,CAAC,GAAG,mBAAmB,EAAE,KAAK,CAAC,GAAG,MAAO,EAAE,OAAO,EAAE,OAAO,IAAI,EAAG;AAC5F,QAAM,aAAa,CAAC,GAAG,kBAAkB,GAAG,iBAAiB;AAE7D,QAAM,cAAc,MAAM,QAAQ;AAAA,IAChC,WAAW,IAAI,OAAM,YAAW,EAAE,YAAY,OAAO,MAAM,UAAU,MAAM,OAAO,UAAU,EAAE,EAAE;AAAA,EAClG;AAEA,WAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC1C,UAAM,aAAa,YAAY,CAAC;AAChC,QAAI,CAAC,WAAY;AACjB,UAAM,EAAE,YAAY,UAAU,aAAa,IAAI;AAC/C,YAAI,kCAAe,YAAY,GAAG;AAChC,0BAAoB,KAAK,aAAa,YAAY;AAClD;AAAA,IACF;AACA,UAAM,EAAE,QAAQ,UAAU,eAAe,IAAI;AAC7C,QAAI,gBAAgB;AAClB,yBAAmB,KAAK,cAAc;AAAA,IACxC;AAEA,UAAM,UAAU,WAAW,CAAC;AAC5B,QAAI,YAAY,QAAW;AACzB,YAAM,IAAI,MAAM,0CAA0C,OAAO,CAAC,CAAC,EAAE;AAAA,IACvE;AACA,UAAM,cAAc,CAAC,GAAG,SAAS,KAAK,EAAE,KAAK,CAAC,GAAG,MAAO,EAAE,OAAO,EAAE,OAAO,IAAI,EAAG;AACjF,eAAW,WAAW,aAAa;AACjC,UAAI,CAAC,QAAQ,QAAS;AACtB,YAAM,EAAE,MAAM,SAAS,QAAI,6CAA2B,QAAQ,MAAM,eAAe;AACnF,sBAAgB,IAAI,QAAQ;AAC5B,YAAM,cAAc,eAAe,UAAU;AAAA,EAAK,QAAQ,eAAe,EAAE;AAC3E,YAAM,KAAK;AAAA,QACT,MAAM;AAAA,QACN,UAAU;AAAA,UACR,MAAM;AAAA,UACN;AAAA,UACA,YAAY;AAAA,YACV,MAAM;AAAA,YACN,YAAY,QAAQ,YAAY,cAAc,CAAC;AAAA,YAC/C,UAAU,QAAQ,YAAY,YAAY,CAAC;AAAA,UAC7C;AAAA,QACF;AAAA,MACF,CAAC;AAED,kBAAY,IAAI,UAAU;AAAA,QACxB;AAAA,QACA,kBAAkB,QAAQ;AAAA,MAC5B,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO,EAAE,gBAAgB,EAAE,OAAO,YAAY,GAAG,oBAAoB,oBAAoB;AAC3F;","names":[]}