@mcpc-tech/core 0.2.0-beta.10

package/src/plugins/search-tool.mjs

@@ -0,0 +1,217 @@
+// ../__mcpc__core_0.2.0-beta.10/node_modules/@mcpc/core/src/plugins/search-tool.ts
+import rg from "@mcpc-tech/ripgrep-napi";
+import { tmpdir } from "node:os";
+import { jsonSchema } from "ai";
+import { resolve } from "node:path";
+import { relative } from "node:path";
+function createSearchPlugin(options = {}) {
+  const maxResults = options.maxResults || 20;
+  const maxOutputSize = options.maxOutputSize || 5e3;
+  const allowedSearchDir = options.allowedDir || tmpdir();
+  const timeoutMs = options.timeoutMs || 3e4;
+  const global = options.global ?? true;
+  return {
+    name: "plugin-search",
+    configureServer: (server) => {
+      server.tool(
+        "search-tool-result",
+        `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
+Only search within the allowed directory: ${allowedSearchDir}`,
+        jsonSchema({
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: "Text to search for. Can be a plain string or a regular expression. For regexes, don't include delimiters (e.g. use `^foo` not `/^foo/`). If you get a regex parse error, try escaping special chars or using a simpler literal search."
+            },
+            path: {
+              type: "string",
+              description: "File or folder path to limit the search (optional). Must be within the allowed directory."
+            },
+            maxResults: {
+              type: "number",
+              description: "Maximum number of matches to return (optional). Lower this to reduce output size and runtime."
+            }
+          },
+          required: ["pattern"]
+        }),
+        async (args) => {
+          const isBroad = (raw) => {
+            const t = (raw ?? "").trim();
+            if (!t) return true;
+            if (/^[*.\s]{2,}$/.test(t)) return true;
+            if (t === ".*" || t === "." || t === "^.*$") return true;
+            if (/^\^?\.\*\$?$/.test(t)) return true;
+            if (/^\\s?\*+$/.test(t)) return true;
+            return false;
+          };
+          const appendMatchSafely = (current, addition, limit) => {
+            if ((current + addition).length > limit) {
+              return { current, added: false };
+            }
+            return { current: current + addition, added: true };
+          };
+          try {
+            const requestedPath = args.path || allowedSearchDir;
+            const limit = args.maxResults || maxResults;
+            if (args.path) {
+              const resolvedRequested = resolve(args.path);
+              const resolvedAllowed = resolve(allowedSearchDir);
+              const relativePath = relative(resolvedAllowed, resolvedRequested);
+              if (relativePath && relativePath.startsWith("..")) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `\u274C Path "${args.path}" not allowed. Must be within: ${allowedSearchDir}`
+                    }
+                  ],
+                  isError: true
+                };
+              }
+            }
+            const searchPath = requestedPath;
+            const rawPattern = args.pattern ?? "";
+            if (isBroad(rawPattern)) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `\u274C Search pattern too broad: "${rawPattern}"
+Provide a more specific pattern (e.g. include a filename fragment, a keyword, or limit with the "path" parameter). Avoid patterns that only contain wildcards like "*" or ".*".`
+                  }
+                ],
+                isError: true
+              };
+            }
+            let timeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+              timeoutId = setTimeout(() => {
+                reject(new Error(`Search timeout after ${timeoutMs}ms`));
+              }, timeoutMs);
+            });
+            console.log(`Searching for "${args.pattern}" in ${searchPath}`);
+            const searchPromise = new Promise((resolve2, reject) => {
+              try {
+                const result2 = rg.search(args.pattern, [searchPath]);
+                resolve2(result2);
+              } catch (error) {
+                reject(error);
+              }
+            });
+            const result = await Promise.race([
+              searchPromise,
+              timeoutPromise
+            ]);
+            if (timeoutId) clearTimeout(timeoutId);
+            if (!result.success || !result.matches?.length) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `No matches found for: "${args.pattern}"
+
+Try:
+- **Simpler pattern** or \`*\`
+- Check if files exist in: ${searchPath}
+- Use specific file path`
+                  }
+                ]
+              };
+            }
+            const matches = result.matches.slice(0, limit);
+            let output = `Found ${result.matches.length} matches (showing up to ${matches.length}):
+
+`;
+            let matchesIncluded = 0;
+            for (const match of matches) {
+              const baseMatchText = `**${match.path}:${match.lineNumber}**
+`;
+              const fullMatchText = `${baseMatchText}\`\`\`
+${match.line}
+\`\`\`
+
+`;
+              const res = appendMatchSafely(
+                output,
+                fullMatchText,
+                maxOutputSize
+              );
+              if (!res.added) {
+                if (matchesIncluded === 0) {
+                  const remainingSpace = maxOutputSize - output.length - 100;
+                  if (remainingSpace > 50) {
+                    const truncatedLine = match.line.slice(0, remainingSpace);
+                    output += `${baseMatchText}\`\`\`
+${truncatedLine}...
+\`\`\`
+
+`;
+                    output += `\u26A0\uFE0F Content truncated
+`;
+                    matchesIncluded++;
+                  } else {
+                    output += `\u26A0\uFE0F Content too large, use specific file path
+`;
+                  }
+                }
+                break;
+              }
+              output = res.current;
+              matchesIncluded++;
+            }
+            if (matchesIncluded < matches.length) {
+              output += `
+\u26A0\uFE0F Showing ${matchesIncluded}/${matches.length} matches (size limit)
+`;
+              output += `
+For more results:
+`;
+              output += `- Use specific pattern: "${args.pattern} keyword"
+`;
+              output += `- Search specific file: {"pattern": "${args.pattern}", "path": "/file.txt"}
+`;
+              output += `- Use fewer results: {"maxResults": 5}`;
+            }
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: output
+                }
+              ]
+            };
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const isTimeout = errorMsg.includes("timeout");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Search error: ${errorMsg}
+
+${isTimeout ? `Timeout after ${timeoutMs}ms. Try simpler pattern or smaller directory.` : `Check pattern syntax or directory exists.`}`
+                }
+              ]
+            };
+          }
+        },
+        { internal: !global }
+      );
+    }
+  };
+}
+var defaultSearchPlugin = createSearchPlugin({
+  global: true,
+  maxResults: 20,
+  maxOutputSize: 5e3,
+  caseSensitive: false,
+  timeoutMs: 3e4
+});
+var createPlugin = createSearchPlugin;
+var search_tool_default = defaultSearchPlugin;
+export {
+  createPlugin,
+  createSearchPlugin,
+  search_tool_default as default
+};

package/types/mod.d.ts

@@ -0,0 +1,54 @@
+/** MCPC Core - Build agentic MCP servers by composing existing MCP tools.
+ *
+ * Create powerful AI agents by combining tools from the MCP ecosystem.
+ * Write a simple description, select your tools, and get a working MCP server.
+ *
+ * ```ts
+ * import { type ComposeDefinition, mcpc } from "@mcpc/core";
+ * import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+ *
+ * // Define MCP server dependencies
+ * const deps: ComposeDefinition['deps'] = {
+ *   mcpServers: {
+ *     "desktop-commander": {
+ *       command: "npx",
+ *       args: ["-y", "@wonderwhy-er/desktop-commander@latest"],
+ *       transportType: "stdio",
+ *     }
+ *   }
+ * }
+ *
+ * // Write agent description with tool references
+ * const description = `
+ * I am a coding assistant that can read files and run terminal commands.
+ *
+ * Available tools:
+ * <tool name="desktop-commander.exec" />
+ * <tool name="desktop-commander.readFile" />
+ * <tool name="desktop-commander.writeFile" />
+ * `
+ *
+ * // Create and start the server
+ * const server = await mcpc(
+ *   [{ name: "coding-agent", version: "1.0.0" }],
+ *   [{ name: 'coding-agent', description, deps }]
+ * )
+ *
+ * const transport = new StdioServerTransport()
+ * await server.connect(transport)
+ * ```
+ *
+ * ## Documentation
+ *
+ * - [Getting Started](https://github.com/mcpc-tech/mcpc/tree/main/docs/quickstart/installation.md)
+ * - [Complete Tutorial](https://github.com/mcpc-tech/mcpc/tree/main/docs/quickstart/create-your-first-agentic-mcp.md)
+ * - [Examples](https://github.com/mcpc-tech/mcpc/tree/main/docs/examples/)
+ * - [FAQ](https://github.com/mcpc-tech/mcpc/tree/main/docs/faq.md)
+ *
+ * @module
+ */ export * from "./src/compose.js";
+export * from "./src/utils/common/env.js";
+export * from "./src/utils/common/json.js";
+export * from "./src/utils/common/mcp.js";
+export * from "./src/set-up-mcp-compose.js";
+//# sourceMappingURL=mod.d.ts.map

package/types/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sources":["../mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDC,GAED,iCAAiC;AAEjC,0CAA0C;AAC1C,2CAA2C;AAC3C,0CAA0C;AAE1C,4CAA4C"}

package/types/plugins.d.ts

@@ -0,0 +1,43 @@
+/**
+ * MCPC Core Plugins
+ *
+ * Collection of built-in and utility plugins for MCPC servers.
+ *
+ * @example
+ * ```ts
+ * import { createSearchPlugin, createLargeResultPlugin } from "@mcpc/core/plugins";
+ *
+ * const server = await mcpc([...], [...]);
+ *
+ * // Add search functionality
+ * await server.addPlugin(createSearchPlugin({
+ *   maxResults: 50,
+ *   searchDir: "./workspace"
+ * }));
+ *
+ * // Add large result handling
+ * await server.addPlugin(createLargeResultPlugin({
+ *   maxSize: 10000
+ * }));
+ * ```
+ *
+ * @example Using default plugin instances
+ * ```ts
+ * // Import individual plugins with default configurations
+ * import searchPlugin from "@mcpc/core/plugins/search";
+ * import largeResultPlugin from "@mcpc/core/plugins/large-result";
+ *
+ * const server = await mcpc([...], [...]);
+ *
+ * // Use plugins with default settings
+ * await server.addPlugin(searchPlugin);
+ * await server.addPlugin(largeResultPlugin);
+ * ```
+ *
+ * @module
+ */ export { createSearchPlugin } from "./src/plugins/search-tool.js";
+export { createLargeResultPlugin } from "./src/plugins/large-result.js";
+export { default as defaultSearchPlugin } from "./src/plugins/search-tool.js";
+export { default as defaultLargeResultPlugin } from "./src/plugins/large-result.js";
+export type { SearchOptions } from "./src/plugins/search-tool.js";
+//# sourceMappingURL=plugins.d.ts.map

package/types/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sources":["../plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCC,GAGD,SAAS,kBAAkB,uCAAuC;AAClE,SAAS,uBAAuB,wCAAwC;AAGxE,SAAS,WAAW,mBAAmB,uCAAuC;AAC9E,SAAS,WAAW,wBAAwB,wCAAwC;AAGpF,cAAc,aAAa,uCAAuC"}

package/types/src/compose.d.ts

@@ -0,0 +1,119 @@
+import { type Implementation } from "@modelcontextprotocol/sdk/types.js";
+import { type Schema } from "ai";
+import type { McpSettingsSchema } from "./service/tools.js";
+import { Server, type ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
+import type z from "zod";
+import type { ComposeDefinition } from "./set-up-mcp-compose.js";
+import type { JSONSchema, ToolCallback } from "./types.js";
+import type { ToolConfig, ToolPlugin } from "./plugin-types.js";
+export declare class ComposableMCPServer extends Server {
+  private tools: any;
+  private toolRegistry: any;
+  private toolConfigs: any;
+  private globalPlugins: any;
+  toolNameMapping: Map<string, string>;
+  constructor(_serverInfo: Implementation, options: ServerOptions);
+  /**
+   * Initialize built-in plugins - called during setup
+   */ initBuiltInPlugins(): Promise<void>;
+  private applyPluginTransforms: any;
+  private resolveToolName: any;
+  tool<T>(name: string, description: string, paramsSchema: Schema<T>, cb: (args: T, extra?: unknown) => unknown, options?: {
+    internal?: boolean;
+    plugins?: ToolPlugin[];
+  }): void;
+  /**
+   * Register a tool override with description, hide, args transformation, and/or custom handler
+   */ /**
+   * Get tool callback from registry
+   */ getToolCallback(name: string): ToolCallback | undefined;
+  /**
+   * Find tool configuration (simplified - dot/underscore mapping now handled by plugin)
+   */ findToolConfig(toolId: string): ToolConfig | undefined;
+  /**
+   * Call any registered tool directly, whether it's public or internal
+   */ callTool(name: string, args: unknown): Promise<unknown>;
+  /**
+   * Get all internal tool names
+   */ getInternalToolNames(): string[];
+  /**
+   * Get all public tool names
+   */ getPublicToolNames(): string[];
+  /**
+   * Get all external (non-global, non-internal, non-hidden) tool names
+   */ getExternalToolNames(): string[];
+  /**
+   * Get all hidden tool names
+   */ getHiddenToolNames(): string[];
+  /**
+   * Get internal tool schema by name
+   */ getInternalToolSchema(name: string): {
+    description: string;
+    schema: JSONSchema;
+  } | undefined;
+  /**
+   * Check if a tool exists (visible or internal)
+   */ hasToolNamed(name: string): boolean;
+  /**
+   * Configure tool behavior (simplified replacement for middleware)
+   * @example
+   * ```typescript
+   * // Override description
+   * server.configTool('myTool', {
+   *   callback: originalCallback,
+   *   description: 'Enhanced tool description'
+   * });
+   *
+   * // Hide tool from agentic execution
+   * server.configTool('myTool', {
+   *   callback: originalCallback,
+   *   description: 'Hidden tool',
+   *   visibility: { hide: true }
+   * });
+   *
+   * // Make tool globally available
+   * server.configTool('myTool', {
+   *   callback: originalCallback,
+   *   description: 'Global tool',
+   *   visibility: { global: true }
+   * });
+   * ```
+   */ configTool(toolName: string, config: ToolConfig): void;
+  /**
+   * Get tool configuration
+   */ getToolConfig(toolName: string): ToolConfig | undefined;
+  /**
+   * Remove tool configuration
+   */ removeToolConfig(toolName: string): boolean;
+  /**
+   * Register a tool plugin
+   * @example
+   * ```typescript
+   * // Global plugin for all tools
+   * server.addPlugin({
+   *   name: 'logger',
+   *   transformTool: (tool, context) => {
+   *     const originalExecute = tool.execute;
+   *     tool.execute = async (args, extra) => {
+   *       console.log(`Calling ${tool.name} with:`, args);
+   *       const result = await originalExecute(args, extra);
+   *       console.log(`Result:`, result);
+   *       return result;
+   *     };
+   *     return tool;
+   *   }
+   * });
+   * ```
+   */ addPlugin(plugin: ToolPlugin): Promise<void>;
+  /**
+   * Load and register a plugin from a file path with optional parameters
+   *
+   * Supports parameter passing via query string syntax:
+   * loadPluginFromPath("path/to/plugin.ts?param1=value1&param2=value2")
+   */ loadPluginFromPath(pluginPath: string): Promise<void>;
+  private applyTransformToolHooks: any;
+  private processToolsWithPlugins: any;
+  private triggerComposeEndHooks: any;
+  compose(name: string | null, description: string, depsConfig?: z.infer<typeof McpSettingsSchema>, options?: ComposeDefinition["options"]): Promise<void>;
+}
+//# sourceMappingURL=compose.d.ts.map

package/types/src/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sources":["../../src/compose.ts"],"names":[],"mappings":"AAAA,SAGE,KAAK,cAAc,6CAGmC;AACxD,SAAqB,KAAK,MAAM,aAAwB;AACxD,cAAc,iBAAiB,6BAA6B;AAC5D,SACE,MAAM,EACN,KAAK,aAAa,oDAC2C;AAC/D,YAAY,aAAyB;AAGrC,cAAc,iBAAiB,kCAAkC;AAEjE,cAAc,UAAU,EAAE,YAAY,qBAAqB;AAO3D,cAGE,UAAU,EACV,UAAU,4BACe;AAK3B,OAAO,cAAM,4BAA4B;EACvC,QAAQ,WAAmB;EAC3B,QAAQ,kBAOM;EACd,QAAQ,iBAAiD;EACzD,QAAQ,mBAAiC;EACzC,iBAAiB,IAAI,MAAM,EAAE,MAAM,EAAc;EAEjD,YAAY,aAAa,cAAc,EAAE,SAAS,aAAa;EAI/D;;GAEC,GACD,AAAM,sBAAsB,QAAQ,IAAI;UAYhC;UAcA;EAwBR,KAAK,GACH,MAAM,MAAM,EACZ,aAAa,MAAM,EACnB,cAAc,OAAO,EAAE,EACvB,KAAK,MAAM,GAAG,QAAQ,OAAO,KAAK,OAAO,EACzC;IAAW,WAAW,OAAO;IAAE,UAAU;GAAmB;EAuD9D;;GAEC,GACD;;GAEC,GACD,gBAAgB,MAAM,MAAM,GAAG,eAAe,SAAS;EAIvD;;GAEC,GACD,eAAe,QAAQ,MAAM,GAAG,aAAa,SAAS;EActD;;GAEC,GACD,AAAM,SAAS,MAAM,MAAM,EAAE,MAAM,OAAO,GAAG,QAAQ,OAAO;EAoB5D;;GAEC,GACD,wBAAwB,MAAM;EAM9B;;GAEC,GACD,sBAAsB,MAAM;EAM5B;;GAEC,GACD,wBAAwB,MAAM;EAW9B;;GAEC,GACD,sBAAsB,MAAM;EAM5B;;GAEC,GACD,sBACE,MAAM,MAAM;IACT,aAAa,MAAM;IAAE,QAAQ;MAAe,SAAS;EAY1D;;GAEC,GACD,aAAa,MAAM,MAAM,GAAG,OAAO;EAQnC;;;;;;;;;;;;;;;;;;;;;;;;GAwBC,GACD,WAAW,UAAU,MAAM,EAAE,QAAQ,UAAU,GAAG,IAAI;EAItD;;GAEC,GACD,cAAc,UAAU,MAAM,GAAG,aAAa,SAAS;EAIvD;;GAEC,GACD,iBAAiB,UAAU,MAAM,GAAG,OAAO;EAI3C;;;;;;;;;;;;;;;;;;;GAmBC,GACD,AAAM,UAAU,QAAQ,UAAU,GAAG,QAAQ,IAAI;EASjD;;;;;GAKC,GACD,AAAM,mBAAmB,YAAY,MAAM,GAAG,QAAQ,IAAI;UAQ5C;UAyCA;UAuDA;EAcR,QACJ,MAAM,MAAM,GAAG,IAAI,EACnB,aAAa,MAAM,EACnB,aAAY,EAAE,aAAa,kBAAuC,EAClE,UAAS,kBAAkB,UAAgC;AA2R/D"}

package/types/src/plugin-types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Plugin system types for MCP server composition
+ * Inspired by Vite's plugin system but adapted for MCP composition
+ */ import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { ToolCallback } from "./types.js";
+import type { ComposableMCPServer } from "./compose.js";
+export interface ComposedTool extends Tool {
+  execute: ToolCallback;
+}
+export interface ToolPlugin {
+  /** Plugin name for identification */ name: string;
+  /** Plugin execution order - 'pre' (before core), 'post' (after core), or default */ enforce?: "pre" | "post";
+  /** Apply plugin conditionally based on mode */ apply?: "agentic" | "workflow" | ((mode: string) => boolean);
+  /** Called when plugin is added to server - for initial setup */ configureServer?: (server: ComposableMCPServer) => void | Promise<void>;
+  /** Called before composition starts - for validation and config */ composeStart?: (context: ComposeStartContext) => void | Promise<void>;
+  /** Called for each tool during composition - main transformation hook */ transformTool?: (tool: ComposedTool, context: TransformContext) => ComposedTool | void | Promise<ComposedTool | void>;
+  /** Called after all tools are composed but before registration */ finalizeComposition?: (tools: Record<string, ComposedTool>, context: FinalizeContext) => void | Promise<void>;
+  /** Called after composition is complete - for logging and cleanup */ composeEnd?: (result: ComposeEndContext) => void | Promise<void>;
+}
+/** Context for composeStart hook */ export interface ComposeStartContext {
+  serverName: string;
+  description: string;
+  mode: "agentic" | "agentic_workflow";
+  server: any;
+}
+/** Context for transformTool hook */ export interface TransformContext {
+  toolName: string;
+  server: any;
+  mode: "agentic" | "agentic_workflow";
+}
+/** Context for finalizeComposition hook */ export interface FinalizeContext {
+  serverName: string;
+  mode: "agentic" | "agentic_workflow";
+  server: any;
+}
+/** Context for composeEnd hook */ export interface ComposeEndContext {
+  toolName: string | null;
+  pluginNames: string[];
+  mode: "agentic" | "agentic_workflow";
+  server: any;
+}
+export interface ToolConfig {
+  /** Override the tool's description */ description?: string;
+  /** Tool visibility and access settings */ visibility?: {
+    /** Hide the tool from composed tools context */ hide?: boolean;
+    /** Register the tool as a global tool in the server's public tool list */ global?: boolean;
+    /** Internal tool - not visible in public list but accessible via callTool */ internal?: boolean;
+  };
+}
+//# sourceMappingURL=plugin-types.d.ts.map

package/types/src/plugin-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-types.d.ts","sources":["../../src/plugin-types.ts"],"names":[],"mappings":"AAAA;;;CAGC,GAED,cAAc,IAAI,6CAAyD;AAC3E,cAAc,YAAY,qBAAqB;AAC/C,cAAc,mBAAmB,uBAAuB;AAExD,iBAAiB,qBAAqB;EACpC,SAAS;;AAKX,iBAAiB;EACf,mCAAmC,GACnC,MAAM,MAAM;EAEZ,kFAAkF,GAClF,UAAU,QAAQ;EAElB,6CAA6C,GAC7C,QAAQ,YAAY,eAAe,MAAM,MAAM,KAAK,OAAO;EAI3D,8DAA8D,GAC9D,mBAAmB,QAAQ,wBAAwB,IAAI,GAAG,QAAQ,IAAI;EAEtE,iEAAiE,GACjE,gBAAgB,SAAS,wBAAwB,IAAI,GAAG,QAAQ,IAAI;EAEpE,uEAAuE,GACvE,iBACE,MAAM,cACN,SAAS,qBACN,eAAe,IAAI,GAAG,QAAQ,eAAe,IAAI;EAEtD,gEAAgE,GAChE,uBACE,OAAO,OAAO,MAAM,EAAE,eACtB,SAAS,oBACN,IAAI,GAAG,QAAQ,IAAI;EAExB,mEAAmE,GACnE,cAAc,QAAQ,sBAAsB,IAAI,GAAG,QAAQ,IAAI;;AAajE,kCAAkC,GAClC,iBAAiB;EACf,YAAY,MAAM;EAClB,aAAa,MAAM;EACnB,MAAM,YAAY;EAClB,QAAQ,GAAG;;AAGb,mCAAmC,GACnC,iBAAiB;EACf,UAAU,MAAM;EAChB,QAAQ,GAAG;EACX,MAAM,YAAY;;AAGpB,yCAAyC,GACzC,iBAAiB;EACf,YAAY,MAAM;EAClB,MAAM,YAAY;EAClB,QAAQ,GAAG;;AAGb,gCAAgC,GAChC,iBAAiB;EACf,UAAU,MAAM,GAAG,IAAI;EACvB,aAAa,MAAM;EACnB,MAAM,YAAY;EAClB,QAAQ,GAAG;;AAeb,iBAAiB;EACf,oCAAoC,GACpC,cAAc,MAAM;EACpB,wCAAwC,GACxC;IACE,8CAA8C,GAC9C,OAAO,OAAO;IACd,wEAAwE,GACxE,SAAS,OAAO;IAChB,2EAA2E,GAC3E,WAAW,OAAO"}

package/types/src/set-up-mcp-compose.d.ts

@@ -0,0 +1,68 @@
+import { ComposableMCPServer } from "../mod.js";
+import type { MCPCStep } from "./utils/state.js";
+import type { MCPSetting } from "./service/tools.js";
+import type { SamplingConfig } from "./types.js";
+import type { ToolPlugin } from "./plugin-types.js";
+import type { ToolRefXml } from "./types.js";
+export interface ComposeDefinition {
+  /**
+   * Name of the composed agentic tool
+   * Set to null to skip creating the composed tool (composition-only mode).
+   */ name: string | null;
+  /**
+   * Description of the composed agent's purpose and capabilities.
+   */ description?: string;
+  deps?: MCPSetting;
+  /**
+   * Global plugins to load and apply to all tools
+   * Can be plugin objects or file paths to plugin files
+   * @example
+   * ```typescript
+   * plugins: [
+   *   './plugins/logger.js',
+   *   './plugins/cache.js',
+   *   { name: 'inline', apply: (tool) => tool }
+   * ]
+   * ```
+   */ plugins?: (ToolPlugin | string)[];
+  options?: {
+    /**
+     * Execution mode for the agent
+     * - "agentic": Fully autonomous agent mode without any workflow structure
+     * - "agentic_workflow": Agent workflow mode that can either generate steps at runtime or use predefined steps
+     * @default "agentic"
+     */ mode?: "agentic" | "agentic_workflow";
+    /**
+     * Enable MCP sampling-based autonomous execution capability
+     * When enabled, adds sampling tools that can execute tasks autonomously
+     * @default false
+     */ sampling?: boolean | SamplingConfig;
+    /**
+     * Optional predefined workflow steps for agentic_workflow mode
+     * - If provided: Uses these predefined steps in agentic_workflow mode
+     * - If empty/undefined: Generates workflow steps dynamically at runtime in agentic_workflow mode
+     * - Ignored when mode is "agentic"
+     */ steps?: MCPCStep[];
+    /**
+     * Actions that must be included at least once in any workflow
+     * Validation will fail if these actions are not present in the workflow steps
+     * - Only applies to agentic_workflow mode
+     * - Ignored when mode is "agentic"
+     */ ensureStepActions?: string[];
+    /**
+     * Default references for the dependent mcps
+     *
+     * @example
+     * <tool name="example-tool" hide="true" global="false"/>
+     */ /**
+     * References to dependent tools using a compact XML-like string.
+     * Only the `name` attribute is required; other attributes are optional.
+     */ refs?: Array<ToolRefXml>;
+  };
+}
+export interface ComposibleMCPConfig {
+  [key: string]: ComposeDefinition[];
+}
+export declare function parseMcpcConfigs(conf?: ComposeDefinition[]): ComposeDefinition[];
+export declare function mcpc(serverConf: ConstructorParameters<typeof ComposableMCPServer>, composeConf?: ComposeDefinition[], setupCallback?: (server: ComposableMCPServer) => void | Promise<void>): Promise<InstanceType<typeof ComposableMCPServer>>;
+//# sourceMappingURL=set-up-mcp-compose.d.ts.map

package/types/src/set-up-mcp-compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-up-mcp-compose.d.ts","sources":["../../src/set-up-mcp-compose.ts"],"names":[],"mappings":"AAAA,SAAS,mBAAmB,oBAAoB;AAEhD,cAAc,QAAQ,2BAA2B;AACjD,cAAc,UAAU,6BAA6B;AACrD,cAAc,cAAc,qBAAqB;AACjD,cAAc,UAAU,4BAA4B;AACpD,cAAc,UAAU,qBAAqB;AAE7C,iBAAiB;EACf;;;GAGC,GACD,MAAM,MAAM,GAAG,IAAI;EACnB;;GAEC,GACD,cAAc,MAAM;EACpB,OAAO;EAEP;;;;;;;;;;;GAWC,GACD,WAAW,aAAa,MAAM;EAE9B;IACE;;;;;KAKC,GACD,OAAO,YAAY;IAEnB;;;;KAIC,GACD,WAAW,OAAO,GAAG;IAErB;;;;;KAKC,GACD,QAAQ;IAER;;;;;KAKC,GACD,oBAAoB,MAAM;IAE1B;;;;;KAKC,GACD;;;KAGC,GACD,OAAO,MAAM;;;AAMjB,iBAAiB;GACd,KAAK,MAAM,GAAG;;AAGjB,OAAO,iBAAS,iBACd,OAAO,mBAAmB,GACzB;AAuBH,OAAO,iBAAe,KACpB,YAAY,6BAA6B,oBAAoB,EAC7D,cAAc,mBAAmB,EACjC,iBAAiB,QAAQ,wBAAwB,IAAI,GAAG,QAAQ,IAAI,CAAC,GACpE,QAAQ,oBAAoB"}

package/types/src/types.d.ts

@@ -0,0 +1,18 @@
+export type JSONSchema = Record<string, unknown>;
+export type ToolCallback = (args: unknown, extra?: unknown) => unknown;
+export interface SamplingConfig {
+  maxIterations?: number;
+}
+/**
+ * XML-like tool reference string where only `name` is required.
+ * Examples accepted:
+ * - `<tool name="foo"/>`
+ * - `<tool name="foo" description="desc"/>`
+ * - `<tool name="foo" hide/>`
+ * - `<tool name="foo" global/>`
+ * - `<tool name="foo" description="desc" hide global/>`
+ */ export type ToolDesc = "" | ` description="${string}"`;
+export type ToolFlags = "" | " hide" | " global" | " hide global" | " global hide";
+export type ToolEnd = "/>" | " />";
+export type ToolRefXml = `<tool name="${string}"${ToolDesc}${ToolFlags}${ToolEnd}` | `<tool name="${string}"${ToolFlags}${ToolDesc}${ToolEnd}`;
+//# sourceMappingURL=types.d.ts.map

package/types/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,aAAa,OAAO,MAAM,EAAE,OAAO;AAE/C,YAAY,gBAAgB,MAAM,OAAO,EAAE,QAAQ,OAAO,KAAK,OAAO;AAEtE,iBAAiB;EACf,gBAAgB,MAAM;;AAiDxB;;;;;;;;CAQC,GACD,YAAY,WAAW,MAAM,cAAc,EAAE,MAAM,CAAC,CAAC;AACrD,YAAY,YACR,KACA,UACA,YACA,iBACA;AACJ,YAAY,UAAU,OAAO;AAE7B,YAAY,cACP,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,WAAW,YAAY,aAC/C,YAAY,EAAE,MAAM,CAAC,CAAC,EAAE,YAAY,WAAW"}