@agentskit/mcp 0.2.17 → 0.3.0

package/dist/bin.cjs

@@ -1,67 +1,198 @@
 #!/usr/bin/env node
 'use strict';
 
-var tools = require('@agentskit/tools');
 var adapters = require('@agentskit/adapters');
 var catalog = require('@agentskit/adapters/catalog');
-var mcp = require('@agentskit/tools/mcp');
+var tools = require('@agentskit/tools');
+var core = require('@agentskit/core');
 var runtime = require('@agentskit/runtime');
+var mcp = require('@agentskit/tools/mcp');
+
+var encoder = new TextEncoder();
+var TOOL_NAME = /^[A-Za-z0-9_.-]+$/;
+var invalid = (message) => new core.ConfigError({ code: core.ErrorCodes.AK_CONFIG_INVALID, message });
+var assertNonEmptyString = (input, field, maxBytes) => {
+  if (typeof input !== "string" || input.trim().length === 0) {
+    throw invalid(`${field} must be a non-empty string`);
+  }
+  if (encoder.encode(input).byteLength > maxBytes) {
+    throw invalid(`${field} must not exceed ${maxBytes} bytes`);
+  }
+  return input.trim();
+};
+var assertToolName = (input, field = "tool name") => {
+  const value = assertNonEmptyString(input, field, 128);
+  if (!TOOL_NAME.test(value)) {
+    throw invalid(`${field} may contain only ASCII letters, digits, underscore, hyphen, and dot`);
+  }
+  return value;
+};
+var assertPositiveInteger = (input, field, maximum) => {
+  if (!Number.isSafeInteger(input) || input < 1 || input > maximum) {
+    throw invalid(`${field} must be a safe integer between 1 and ${maximum}`);
+  }
+  return input;
+};
+var isRecord = (input) => {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return false;
+  try {
+    const prototype = Object.getPrototypeOf(input);
+    return prototype === Object.prototype || prototype === null;
+  } catch {
+    return false;
+  }
+};
 
+// src/agent-tool.ts
 function createAgentTool(config) {
+  const id = assertToolName(config?.id, "agent tool id");
+  const description = assertNonEmptyString(config?.description, "agent tool description", 4096);
+  const systemPrompt = assertNonEmptyString(config?.systemPrompt, "agent tool systemPrompt", 65536);
+  if (!isRecord(config?.adapter) || typeof config.adapter.createSource !== "function") {
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "agent tool adapter must implement createSource"
+    });
+  }
+  const maxSteps = assertPositiveInteger(config.maxSteps ?? 8, "agent tool maxSteps", 100);
+  const maxTaskBytes = assertPositiveInteger(config.maxTaskBytes ?? 65536, "agent tool maxTaskBytes", 1048576);
   const skill = {
-    name: config.id,
-    description: config.description,
-    systemPrompt: config.systemPrompt
+    name: id,
+    description,
+    systemPrompt
   };
-  return {
-    name: config.id,
-    description: config.description,
+  const tool = {
+    name: id,
+    description,
     schema: {
       type: "object",
       properties: { task: { type: "string", description: "The task or input for the agent." } },
-      required: ["task"]
+      required: ["task"],
+      additionalProperties: false
     },
     execute: async (args) => {
-      const runtime$1 = runtime.createRuntime({ adapter: config.adapter, maxSteps: config.maxSteps ?? 8 });
-      const result = await runtime$1.run(String(args.task ?? ""), { skill });
+      if (typeof args.task !== "string" || args.task.trim().length === 0) {
+        throw new core.ToolError({
+          code: core.ErrorCodes.AK_TOOL_INVALID_INPUT,
+          message: "agent tool task must be a non-empty string"
+        });
+      }
+      if (new TextEncoder().encode(args.task).byteLength > maxTaskBytes) {
+        throw new core.ToolError({
+          code: core.ErrorCodes.AK_TOOL_INVALID_INPUT,
+          message: `agent tool task must not exceed ${maxTaskBytes} bytes`
+        });
+      }
+      const runtime$1 = runtime.createRuntime({ adapter: config.adapter, maxSteps });
+      const result = await runtime$1.run(args.task, { skill });
       return { content: result.content, steps: result.steps };
     }
   };
+  return Object.freeze(tool);
 }
 
 // src/registry-fetch.ts
 var HOSTED = "https://registry.agentskit.io/r";
 var RAW = "https://raw.githubusercontent.com/AgentsKit-io/agentskit-registry/main";
-async function fetchAgentSkill(id, fetchImpl = globalThis.fetch) {
-  const tryUrl = async (url) => {
-    try {
-      const res = await fetchImpl(url);
-      return res.ok ? await res.json() : null;
-    } catch {
+var REGISTRY_ID = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+var isRecord2 = (input) => input !== null && typeof input === "object" && !Array.isArray(input);
+var boundedString = (input, maximum) => {
+  if (typeof input !== "string" || input.trim().length === 0) return null;
+  return new TextEncoder().encode(input).byteLength <= maximum ? input.trim() : null;
+};
+var readBounded = async (response, maximum) => {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maximum) return null;
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let text = "";
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    bytes += chunk.value.byteLength;
+    if (bytes > maximum) {
+      await reader.cancel().catch(() => void 0);
       return null;
     }
+    text += decoder.decode(chunk.value, { stream: true });
+  }
+  return text + decoder.decode();
+};
+var requestText = async (url, fetchImpl, options) => {
+  if (options.signal?.aborted) return null;
+  const controller = new AbortController();
+  let resolveAbort;
+  const aborted = new Promise((resolve) => {
+    resolveAbort = resolve;
+  });
+  const abort = () => {
+    controller.abort();
+    resolveAbort?.(null);
   };
-  const hosted = await tryUrl(`${HOSTED}/${id}.json`);
-  if (hosted?.skill?.systemPrompt) {
-    return { id, description: hosted.description ?? id, systemPrompt: hosted.skill.systemPrompt };
+  options.signal?.addEventListener("abort", abort, { once: true });
+  let timer;
+  try {
+    const request = (async () => {
+      const response = await fetchImpl(url, { signal: controller.signal });
+      if (!response.ok) return null;
+      return readBounded(response, options.maxResponseBytes);
+    })().catch(() => null);
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        resolve(null);
+      }, options.timeoutMs);
+    });
+    return await Promise.race([request, timeout, aborted]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
   }
-  const meta = await tryUrl(`${RAW}/registry/${id}/meta.json`);
-  if (!meta) return null;
-  let src = null;
+};
+var requestJson = async (url, fetchImpl, options) => {
+  const text = await requestText(url, fetchImpl, options);
+  if (text === null) return null;
   try {
-    const res = await fetchImpl(`${RAW}/registry/${id}/agent.ts`);
-    src = res.ok ? await res.text() : null;
+    return JSON.parse(text);
   } catch {
-    src = null;
+    return null;
   }
-  if (!src) return null;
-  const m = src.match(/systemPrompt:\s*`((?:\\.|[^`\\])*)`/);
-  if (!m) return null;
-  return {
+};
+async function fetchAgentSkill(id, fetchImpl = globalThis.fetch, options = {}) {
+  if (!REGISTRY_ID.test(id) || typeof fetchImpl !== "function") return null;
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const maxResponseBytes = options.maxResponseBytes ?? 131072;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 12e4 || !Number.isSafeInteger(maxResponseBytes) || maxResponseBytes < 1 || maxResponseBytes > 1048576) return null;
+  const bounds = { maxResponseBytes, signal: options.signal, timeoutMs };
+  const hosted = await requestJson(`${HOSTED}/${id}.json`, fetchImpl, bounds);
+  if (isRecord2(hosted)) {
+    if (hosted.skill === null) return null;
+    if (isRecord2(hosted.skill)) {
+      const systemPrompt2 = boundedString(hosted.skill.systemPrompt, 65536);
+      if (systemPrompt2) {
+        const description = boundedString(hosted.description, 4096) ?? id;
+        return Object.freeze({ description, id, systemPrompt: systemPrompt2 });
+      }
+    }
+  }
+  const meta = await requestJson(`${RAW}/registry/${id}/meta.json`, fetchImpl, bounds);
+  if (!isRecord2(meta)) return null;
+  const source = await requestText(`${RAW}/registry/${id}/agent.ts`, fetchImpl, bounds);
+  if (!source) return null;
+  const match = source.match(/systemPrompt:\s*`((?:\\.|[^`\\])*)`/);
+  if (!match) return null;
+  const systemPrompt = boundedString(
+    match[1].replace(/\\`/g, "`").replace(/\\\$\{/g, "${"),
+    65536
+  );
+  if (!systemPrompt) return null;
+  return Object.freeze({
     id,
-    description: meta.description ?? id,
-    systemPrompt: m[1].replace(/\\`/g, "`").replace(/\\\$\{/g, "${")
-  };
+    description: boundedString(meta.description, 4096) ?? id,
+    systemPrompt
+  });
 }
 
 // src/index.ts
@@ -76,131 +207,266 @@ function processStdio() {
   };
 }
 function createAgentsKitMcpServer(options) {
+  if (!isRecord(options) || !Array.isArray(options.tools)) {
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "MCP server options must include a tools array"
+    });
+  }
+  const names = /* @__PURE__ */ new Set();
+  const tools = options.tools.map((tool, index) => {
+    if (!isRecord(tool)) {
+      throw new core.ConfigError({
+        code: core.ErrorCodes.AK_CONFIG_INVALID,
+        message: `tools[${index}] must be a tool definition`
+      });
+    }
+    const name = assertToolName(tool.name, `tools[${index}].name`);
+    if (names.has(name)) {
+      throw new core.ConfigError({
+        code: core.ErrorCodes.AK_CONFIG_INVALID,
+        message: `tool names must be unique; duplicate "${name}"`
+      });
+    }
+    names.add(name);
+    return Object.freeze({ ...tool, name });
+  });
+  const serverInfo = options.serverInfo === void 0 ? { name: "agentskit-mcp", version: "1.0.0" } : {
+    name: assertNonEmptyString(options.serverInfo?.name, "serverInfo.name", 128),
+    version: assertNonEmptyString(options.serverInfo?.version, "serverInfo.version", 64)
+  };
+  if (options.transport !== void 0 && (!isRecord(options.transport) || typeof options.transport.send !== "function" || typeof options.transport.onMessage !== "function")) {
+    throw new core.ConfigError({
+      code: core.ErrorCodes.AK_CONFIG_INVALID,
+      message: "transport must implement send and onMessage"
+    });
+  }
+  const onEvent = options.onEvent === void 0 ? void 0 : (event) => {
+    try {
+      const delivered = options.onEvent(Object.freeze({ ...event }));
+      if (delivered !== null && (typeof delivered === "object" || typeof delivered === "function")) {
+        const then = delivered.then;
+        if (typeof then === "function") void Promise.resolve(delivered).catch(() => void 0);
+      }
+    } catch {
+    }
+  };
   const transport = options.transport ?? mcp.createStdioTransport(processStdio());
   return mcp.createMcpServer({
     transport,
-    tools: options.tools,
-    serverInfo: options.serverInfo ?? { name: "agentskit-mcp", version: "0.1.0" },
-    onEvent: options.onEvent
+    tools,
+    serverInfo,
+    onEvent
   });
 }
 
-// src/bin.ts
-var warn = (msg) => process.stderr.write(`agentskit-mcp: ${msg}
-`);
-var flag = (name) => {
-  const i = process.argv.indexOf(name);
-  return i >= 0 ? process.argv[i + 1] : void 0;
-};
-var has = (name) => process.argv.includes(name);
-function buildTools() {
-  if (!has("--tools")) return [tools.fetchUrl(), tools.webSearch()];
-  const requested = (flag("--tools") ?? "").split(",").map((s) => s.trim());
-  const tools$1 = [];
-  if (requested.includes("fetch")) tools$1.push(tools.fetchUrl());
-  if (requested.includes("search")) tools$1.push(tools.webSearch());
-  if (requested.includes("filesystem")) {
-    const root = flag("--fs-root");
-    if (root) tools$1.push(...tools.filesystem({ basePath: root }));
-    else warn('skipping "filesystem": pass --fs-root <dir>');
-  }
-  if (requested.includes("sqlite")) {
-    const file = flag("--sqlite");
-    if (file) tools$1.push(tools.sqliteQueryTool({ path: file }));
-    else warn('skipping "sqlite": pass --sqlite <file>');
-  }
-  if (requested.includes("shell")) {
-    if (has("--allow-shell")) tools$1.push(tools.shell());
-    else warn('skipping "shell": pass --allow-shell (runs commands)');
+// src/cli.ts
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--agents",
+  "--api-key",
+  "--base-url",
+  "--fs-root",
+  "--max-steps",
+  "--model",
+  "--provider",
+  "--sqlite",
+  "--tools"
+]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--allow-shell", "--help"]);
+var TOOL_IDS = /* @__PURE__ */ new Set(["fetch", "filesystem", "search", "shell", "sqlite"]);
+var csv = (input) => [...new Set(input.split(",").map((value) => value.trim()).filter(Boolean))];
+var parseMcpCliArgs = (argv) => {
+  const values = /* @__PURE__ */ new Map();
+  const booleans = /* @__PURE__ */ new Set();
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (BOOLEAN_FLAGS.has(argument)) {
+      if (booleans.has(argument)) return { message: `duplicate flag: ${argument}`, status: "rejected" };
+      booleans.add(argument);
+      continue;
+    }
+    if (!VALUE_FLAGS.has(argument)) return { message: `unknown argument: ${argument}`, status: "rejected" };
+    if (values.has(argument)) return { message: `duplicate flag: ${argument}`, status: "rejected" };
+    const value = argv[index + 1];
+    if (value === void 0 || value.startsWith("--")) {
+      return { message: `missing value for ${argument}`, status: "rejected" };
+    }
+    values.set(argument, value);
+    index += 1;
   }
-  return tools$1;
-}
+  const tools = values.has("--tools") ? csv(values.get("--tools")) : ["fetch", "search"];
+  const unknownTool = tools.find((tool) => !TOOL_IDS.has(tool));
+  if (unknownTool) return { message: `unknown tool: ${unknownTool}`, status: "rejected" };
+  const agents = values.has("--agents") ? csv(values.get("--agents")) : [];
+  const maxStepsText = values.get("--max-steps") ?? "8";
+  const maxSteps = Number(maxStepsText);
+  if (!Number.isSafeInteger(maxSteps) || maxSteps < 1 || maxSteps > 100) {
+    return { message: "--max-steps must be a safe integer between 1 and 100", status: "rejected" };
+  }
+  return {
+    options: {
+      agents,
+      allowShell: booleans.has("--allow-shell"),
+      apiKey: values.get("--api-key"),
+      baseUrl: values.get("--base-url"),
+      fsRoot: values.get("--fs-root"),
+      help: booleans.has("--help"),
+      maxSteps,
+      model: values.get("--model"),
+      provider: (values.get("--provider") ?? "openai").toLowerCase(),
+      sqlite: values.get("--sqlite"),
+      tools
+    },
+    status: "parsed"
+  };
+};
 var KEYED = {
-  openai: adapters.openai,
   anthropic: adapters.anthropic,
-  gemini: adapters.gemini,
+  cerebras: adapters.cerebras,
+  cohere: adapters.cohere,
   deepseek: adapters.deepseek,
+  fireworks: adapters.fireworks,
+  gemini: adapters.gemini,
   grok: adapters.grok,
   groq: adapters.groq,
+  huggingface: adapters.huggingface,
+  kimi: adapters.kimi,
+  llamacpp: adapters.llamacpp,
+  lmstudio: adapters.lmstudio,
   mistral: adapters.mistral,
-  cohere: adapters.cohere,
-  together: adapters.together,
-  fireworks: adapters.fireworks,
+  openai: adapters.openai,
   openrouter: adapters.openrouter,
-  cerebras: adapters.cerebras,
-  kimi: adapters.kimi,
-  huggingface: adapters.huggingface,
   qwen: adapters.qwen,
-  lmstudio: adapters.lmstudio,
-  vllm: adapters.vllm,
-  llamacpp: adapters.llamacpp
+  together: adapters.together,
+  vllm: adapters.vllm
 };
 var LOCAL = { ollama: adapters.ollama };
-var LOCAL_COMPAT = /* @__PURE__ */ new Set(["lmstudio", "vllm", "llamacpp"]);
+var LOCAL_COMPAT = /* @__PURE__ */ new Set(["llamacpp", "lmstudio", "vllm"]);
 var DEFAULT_MODEL = {
-  openai: "gpt-4o",
   anthropic: "claude-sonnet-4-6",
-  gemini: "gemini-2.0-flash",
   deepseek: "deepseek-chat",
+  gemini: "gemini-2.0-flash",
   grok: "grok-2",
   groq: "llama-3.3-70b-versatile",
   mistral: "mistral-large-latest",
-  ollama: "llama3"
+  ollama: "llama3",
+  openai: "gpt-4o"
+};
+var MCP_CLI_HELP = [
+  "Usage: agentskit-mcp [options]",
+  "--tools <fetch,search,filesystem,shell,sqlite>",
+  "--agents <registry-ids> --provider <provider> --model <model>",
+  "--fs-root <dir> --sqlite <file> --allow-shell"
+].join("\n");
+var buildPrimitiveTools = (options, warn2) => {
+  const tools$1 = [];
+  if (options.tools.includes("fetch")) tools$1.push(tools.fetchUrl());
+  if (options.tools.includes("search")) tools$1.push(tools.webSearch());
+  if (options.tools.includes("filesystem")) {
+    if (options.fsRoot) tools$1.push(...tools.filesystem({ basePath: options.fsRoot }));
+    else warn2('skipping "filesystem": pass --fs-root <dir>');
+  }
+  if (options.tools.includes("sqlite")) {
+    if (options.sqlite) tools$1.push(tools.sqliteQueryTool({ path: options.sqlite }));
+    else warn2('skipping "sqlite": pass --sqlite <file>');
+  }
+  if (options.tools.includes("shell")) {
+    if (options.allowShell) tools$1.push(tools.shell());
+    else warn2('skipping "shell": pass --allow-shell (runs commands)');
+  }
+  return tools$1;
 };
-function resolveAdapter() {
-  const provider = flag("--provider") ?? "openai";
-  const model = flag("--model") ?? DEFAULT_MODEL[provider];
+var resolveAdapter = (options, env, warn2) => {
+  const model = options.model ?? DEFAULT_MODEL[options.provider];
   if (!model) {
-    warn(`--agents needs a model for "${provider}": pass --model`);
+    warn2(`--agents needs a model for "${options.provider}": pass --model`);
     return null;
   }
-  const baseUrl = flag("--base-url");
-  if (LOCAL[provider]) return LOCAL[provider]({ model, baseUrl });
-  const apiKey = flag("--api-key") ?? process.env[`${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`] ?? (LOCAL_COMPAT.has(provider) ? "local" : void 0);
+  const local = LOCAL[options.provider];
+  if (local) return local({ baseUrl: options.baseUrl, model });
+  const envName = `${options.provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+  const apiKey = options.apiKey ?? env[envName] ?? (LOCAL_COMPAT.has(options.provider) ? "local" : void 0);
   if (!apiKey) {
-    warn(`--agents needs a key for "${provider}": pass --api-key or set ${provider.toUpperCase()}_API_KEY`);
+    warn2(`--agents needs a key for "${options.provider}": pass --api-key or set ${envName}`);
     return null;
   }
-  if (KEYED[provider]) return KEYED[provider]({ apiKey, model });
+  const keyed = KEYED[options.provider];
+  if (keyed) return keyed({ apiKey, baseUrl: options.baseUrl, model });
   try {
-    return catalog.dispatchFromCatalog({ provider, model, apiKey, baseUrl });
+    return catalog.dispatchFromCatalog({ apiKey, baseUrl: options.baseUrl, model, provider: options.provider });
   } catch {
-    warn(`unknown provider "${provider}". Known: ${[...Object.keys(KEYED), ...Object.keys(LOCAL)].join(", ")}, or any catalog OpenAI-compatible provider.`);
+    warn2(`unknown or incompatible provider "${options.provider}"`);
     return null;
   }
-}
-async function buildAgentTools() {
-  const ids = (flag("--agents") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-  if (ids.length === 0) return [];
-  const adapter = resolveAdapter();
-  if (!adapter) return [];
-  const tools = [];
-  for (const id of ids) {
-    const skill = await fetchAgentSkill(id);
-    if (!skill) {
-      warn(`skipping agent "${id}": not found or not runnable (tool-composing agent)`);
-      continue;
+};
+var runMcpCli = async (argv, dependencies = {}) => {
+  const warn2 = dependencies.warn ?? (() => void 0);
+  const parsed = parseMcpCliArgs(argv);
+  if (parsed.status === "rejected") {
+    warn2(parsed.message);
+    return { exitCode: 1, status: "rejected" };
+  }
+  if (parsed.options.help) {
+    warn2(MCP_CLI_HELP);
+    return { exitCode: 0, status: "help" };
+  }
+  const tools = buildPrimitiveTools(parsed.options, warn2);
+  if (parsed.options.agents.length > 0) {
+    const adapter = resolveAdapter(parsed.options, dependencies.env ?? process.env, warn2);
+    if (adapter) {
+      const fetchSkill = dependencies.fetchSkill ?? fetchAgentSkill;
+      for (const id of parsed.options.agents) {
+        const skill = await fetchSkill(id).catch(() => null);
+        if (!skill) {
+          warn2(`skipping agent "${id}": not found or not runnable`);
+          continue;
+        }
+        tools.push(createAgentTool({ ...skill, adapter, maxSteps: parsed.options.maxSteps }));
+      }
     }
-    tools.push(
-      createAgentTool({ id: skill.id, description: skill.description, systemPrompt: skill.systemPrompt, adapter })
-    );
   }
-  return tools;
-}
-async function main() {
-  const tools = [...buildTools(), ...await buildAgentTools()];
   if (tools.length === 0) {
-    warn("no tools or agents enabled \u2014 nothing to serve. See --tools / --agents.");
-    process.exit(1);
+    warn2("no tools or agents enabled \u2014 nothing to serve");
+    return { exitCode: 1, status: "rejected" };
   }
-  createAgentsKitMcpServer({
-    tools,
-    onEvent: (e) => {
-      if (e.type === "error") warn(`tool error (${e.tool}): ${e.error}`);
-    }
+  const seen = /* @__PURE__ */ new Set();
+  const duplicate = tools.find((tool) => {
+    if (seen.has(tool.name)) return true;
+    seen.add(tool.name);
+    return false;
   });
-  warn(`serving ${tools.length} item(s) over stdio (${tools.map((t) => t.name).join(", ")})`);
-}
-void main();
+  if (duplicate) {
+    warn2(`duplicate tool name: ${duplicate.name}`);
+    return { exitCode: 1, status: "rejected" };
+  }
+  const createServer = dependencies.createServer ?? createAgentsKitMcpServer;
+  let server;
+  try {
+    server = createServer({
+      tools,
+      onEvent: (event) => {
+        if (event.type === "error") warn2(`tool error (${event.tool ?? "unknown"}): ${event.error ?? "unknown"}`);
+      }
+    });
+  } catch {
+    warn2("failed to start MCP server");
+    return { exitCode: 1, status: "rejected" };
+  }
+  const toolNames = tools.map((tool) => tool.name);
+  warn2(`serving ${toolNames.length} item(s) over stdio (${toolNames.join(", ")})`);
+  return { exitCode: 0, server, status: "started", toolNames };
+};
+
+// src/bin.ts
+var warn = (message) => {
+  process.stderr.write(`agentskit-mcp: ${message}
+`);
+};
+void runMcpCli(process.argv.slice(2), { warn }).then((result) => {
+  process.exitCode = result.exitCode;
+}).catch(() => {
+  warn("unexpected startup failure");
+  process.exitCode = 1;
+});
 //# sourceMappingURL=bin.cjs.map
 //# sourceMappingURL=bin.cjs.map