@swifty.js/swifty 0.0.30 → 0.0.32

package/dist/lib/{chunk-OQIQOU5S.js → chunk-3OFLDUAW.js}

@@ -1,6 +1,6 @@
 import {
   createChildLogger
-} from "./chunk-EY7HE52Q.js";
+} from "./chunk-3XCGUKGJ.js";
 
 // src/llm/errors.ts
 var LLMError = class extends Error {
@@ -288,6 +288,10 @@ function loadSingleFile(path) {
     const parsed2 = safeParse(z.array(MCPServerConfigSchema), raw.mcp_servers);
     if (parsed2.success) {
       mcpServers = parsed2.data;
+    } else {
+      throw new ConfigError(
+        `Invalid MCP server configuration in ${path}: ${getParseErrorMessage(parsed2.error)}`
+      );
     }
   }
   if ("hooks" in raw) {
@@ -323,6 +327,7 @@ function validateProviders(config) {
     throw new ConfigError("At least one provider MUST be configured.");
   }
   const requiredFields = ["name", "protocol", "base_url", "model"];
+  const baseUrls = /* @__PURE__ */ new Map();
   for (let i = 0; i < config.providers.length; i++) {
     const p = config.providers[i];
     const values = {
@@ -340,11 +345,123 @@ function validateProviders(config) {
         `Provider #${String(i + 1)}: invalid protocol '${p.protocol}', MUST be one of: ${Array.from(VALID_PROTOCOLS).join(", ")}`
       );
     }
+    const previous = baseUrls.get(p.base_url);
+    if (previous !== void 0) {
+      throw new ConfigError(
+        `Provider #${String(i + 1)}: duplicate base_url '${p.base_url}' (already used by provider #${String(previous + 1)}).`
+      );
+    }
+    baseUrls.set(p.base_url, i);
   }
 }
+function validateMcpServers(config) {
+  const names = /* @__PURE__ */ new Map();
+  for (let i = 0; i < config.mcp_servers.length; i++) {
+    const server = config.mcp_servers[i];
+    const position = `MCP server #${String(i + 1)}`;
+    if (!server.name.trim()) {
+      throw new ConfigError(`${position}: name must not be empty.`);
+    }
+    const previous = names.get(server.name);
+    if (previous !== void 0) {
+      throw new ConfigError(
+        `${position}: duplicate name '${server.name}' (already used by MCP server #${String(previous + 1)}).`
+      );
+    }
+    names.set(server.name, i);
+    const hasCommand = Boolean(server.command?.trim());
+    const hasUrl = Boolean(server.url?.trim());
+    if (hasCommand === hasUrl) {
+      throw new ConfigError(
+        `${position} '${server.name}': configure exactly one of command or url.`
+      );
+    }
+    if (hasCommand && server.transport && server.transport !== "stdio") {
+      throw new ConfigError(`${position} '${server.name}': command servers must use stdio.`);
+    }
+    if (hasUrl && server.transport && !["http", "sse"].includes(server.transport)) {
+      throw new ConfigError(`${position} '${server.name}': URL transport must be http or sse.`);
+    }
+  }
+}
+var PROJECT_MCP_FILENAME = ".mcp.json";
+var McpJsonEntrySchema = z.looseObject({
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  type: z.enum(["stdio", "sse", "http"]).optional(),
+  url: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional()
+});
+var McpJsonFileSchema = z.looseObject({
+  // Parse entries independently below so one bad server does not disable every
+  // valid server in the project file.
+  mcpServers: z.record(z.string(), z.unknown()).default({})
+});
+function mcpServerFromJsonEntry(name, entry) {
+  const transport = entry.type ?? (entry.command !== void 0 ? "stdio" : "http");
+  if (transport === "stdio") {
+    if (!entry.command || entry.url !== void 0) {
+      return null;
+    }
+    return { name, command: entry.command, args: entry.args, env: entry.env };
+  }
+  if (!entry.url || entry.command !== void 0) {
+    return null;
+  }
+  return { name, url: entry.url, transport, headers: entry.headers };
+}
+function loadProjectMcpServers(workDir) {
+  const path = join(workDir, PROJECT_MCP_FILENAME);
+  if (!existsSync(path)) {
+    return [];
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    log.error({ err, path }, "invalid .mcp.json");
+    return [];
+  }
+  const parsed = safeParse(McpJsonFileSchema, raw);
+  if (!parsed.success) {
+    log.error({ error: parsed.error, path }, "invalid .mcp.json");
+    return [];
+  }
+  const servers = [];
+  for (const [name, rawEntry] of Object.entries(parsed.data.mcpServers)) {
+    const parsedEntry = safeParse(McpJsonEntrySchema, rawEntry);
+    if (!name.trim() || !parsedEntry.success) {
+      log.warn(
+        { name, path, error: parsedEntry.success ? void 0 : parsedEntry.error },
+        "skipping invalid .mcp.json server entry"
+      );
+      continue;
+    }
+    const server = mcpServerFromJsonEntry(name, parsedEntry.data);
+    if (server) {
+      servers.push(server);
+    } else {
+      log.warn({ name, path }, "skipping invalid .mcp.json server entry");
+    }
+  }
+  return servers;
+}
+function withProjectMcpServers(config, workDir) {
+  const projectServers = loadProjectMcpServers(workDir);
+  if (projectServers.length === 0) {
+    return config;
+  }
+  const known = new Set(config.mcp_servers.map((s) => s.name));
+  return {
+    ...config,
+    mcp_servers: [...config.mcp_servers, ...projectServers.filter((s) => !known.has(s.name))]
+  };
+}
 function loadConfig(path, options = {}) {
   if (path) {
     const config2 = loadSingleFile(path);
+    validateMcpServers(config2);
     if (!options.allowEmptyProviders || config2.providers.length > 0) {
       validateProviders(config2);
     }
@@ -358,6 +475,7 @@ function loadConfig(path, options = {}) {
     throw new ConfigError(`No config file found, expected ${candidate}.`);
   }
   const config = loadSingleFile(candidate);
+  validateMcpServers(config);
   if (!options.allowEmptyProviders || config.providers.length > 0) {
     validateProviders(config);
   }
@@ -444,6 +562,8 @@ export {
   resolveAPIKey,
   HookConfigSchema,
   forkEnabled,
+  loadProjectMcpServers,
+  withProjectMcpServers,
   loadConfig,
   INTERRUPTED_TOOL_RESULT,
   REJECTED_TOOL_RESULT,

package/dist/lib/{chunk-EY7HE52Q.js → chunk-3XCGUKGJ.js}

@@ -228,7 +228,7 @@ function errSerializer(err) {
   return { message: safeStringify(err), value: err };
 }
 
-// src/utils/index.ts
+// src/utils/utils.ts
 var log = createChildLogger({ module: "utils" });
 function contentToText(content) {
   if (typeof content === "string") {
@@ -336,29 +336,23 @@ function boolArg(args, key, fallback) {
   }
   return fallback ?? Boolean(v);
 }
-function quickSort(arr, compare) {
-  if (arr.length <= 1) {
-    return [...arr];
-  }
-  const pivotIndex = Math.floor(arr.length / 2);
-  const pivot = arr[pivotIndex];
-  if (pivot === void 0) {
-    return [...arr];
-  }
-  const left = [];
-  const right = [];
-  const equal = [];
-  for (const item of arr) {
-    const result = compare(item, pivot);
-    if (result < 0) {
-      left.push(item);
-    } else if (result > 0) {
-      right.push(item);
-    } else {
-      equal.push(item);
-    }
+function formatToolArgs(args) {
+  if (args.command) {
+    return truncate(strArg(args, "command"), 80);
+  }
+  if (args.file_path) {
+    return truncate(strArg(args, "file_path"), 80);
+  }
+  if (args.pattern) {
+    return truncate(strArg(args, "pattern"), 80);
   }
-  return [...quickSort(left, compare), ...equal, ...quickSort(right, compare)];
+  if (args.description) {
+    return truncate(strArg(args, "description"), 80);
+  }
+  return "";
+}
+function truncate(value, max) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
 }
 
 export {
@@ -380,5 +374,5 @@ export {
   strList,
   strArg,
   boolArg,
-  quickSort
+  formatToolArgs
 };

package/dist/lib/{chunk-7QPDFSQE.js → chunk-4BPKIIQD.js}

@@ -1,8 +1,3 @@
-import {
-  MCP_CALL_TOOL_NAME,
-  TOOL_SEARCH_TOOL_NAME
-} from "./chunk-GHF2PSEW.js";
-
 // src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
@@ -26,26 +21,44 @@ var ToolRegistry = class {
   register(tool) {
     this.tools.set(tool.name, tool);
   }
+  /**
+   * Removes a tool and forgets its discovery state, so a re-registered tool
+   * with the same name starts deferred again. Used by /mcp reload to drop
+   * tools of servers that disappeared from the config.
+   */
+  unregister(name) {
+    this.tools.delete(name);
+    this.discovered.delete(name);
+  }
   get(name) {
     return this.tools.get(name);
   }
   listTools() {
     return [...this.tools.values()];
   }
-  getAllSchemas(protocol = "anthropic") {
-    const isOpenAI = protocol === "openai" || protocol === "openai-compat";
+  getAllSchemas(protocol, filter) {
+    const resolvedProtocol = protocol ?? "anthropic";
+    const isOpenAI = resolvedProtocol === "openai" || resolvedProtocol === "openai-compat";
     const native = this.mcpLoadingMode === "native" && !isOpenAI;
     const schemas = [];
     for (const tool of this.tools.values()) {
-      if (tool.name === TOOL_SEARCH_TOOL_NAME && !this.exposeToolSearch || tool.name === MCP_CALL_TOOL_NAME && !this.exposeMcpCall) {
+      if (filter && !filter(tool.name)) {
+        continue;
+      }
+      if (tool.name === "ToolSearch" && !this.exposeToolSearch || tool.name === "McpCall" && !this.exposeMcpCall) {
         continue;
       }
       const deferred = Boolean(tool.deferred) && !this.discovered.has(tool.name);
       if (deferred && !native) {
         continue;
       }
+      const providerSchema = protocol ? tool.providerSchema?.(resolvedProtocol) : void 0;
+      if (providerSchema) {
+        schemas.push(providerSchema);
+        continue;
+      }
       const s = tool.schema();
-      if (protocol === "openai") {
+      if (resolvedProtocol === "openai") {
         schemas.push({
           strict: s.strict ?? false,
           type: "function",
@@ -53,7 +66,7 @@ var ToolRegistry = class {
           description: s.description,
           parameters: s.input_schema
         });
-      } else if (protocol === "openai-compat") {
+      } else if (resolvedProtocol === "openai-compat") {
         schemas.push({
           type: "function",
           function: {
@@ -120,11 +133,13 @@ var ToolRegistry = class {
 };
 
 // src/subagent/tool-filter.ts
+var MAIN_AGENT_ONLY_TOOLS = /* @__PURE__ */ new Set(["ComputerUse"]);
 var SUBAGENT_DISALLOWED_TOOLS = /* @__PURE__ */ new Set([
   "ExitPlanMode",
   "Agent",
   // Prevents recursive spawning of subagents
   "AskUserQuestion",
+  ...MAIN_AGENT_ONLY_TOOLS,
   "TaskStop"
 ]);
 var TEAMMATE_DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["TeamCreate", "TeamDelete"]);
@@ -193,6 +208,9 @@ function cloneRegistryForFork(registry) {
   const forked = new ToolRegistry();
   forked.mcpLoadingMode = registry.mcpLoadingMode;
   for (const tool of registry.listTools()) {
+    if (MAIN_AGENT_ONLY_TOOLS.has(tool.name)) {
+      continue;
+    }
     if (tool.name === "Agent" && "querySource" in tool) {
       const clone = Object.create(
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
@@ -210,6 +228,7 @@ function cloneRegistryForFork(registry) {
 
 export {
   ToolRegistry,
+  MAIN_AGENT_ONLY_TOOLS,
   SUBAGENT_DISALLOWED_TOOLS,
   TEAMMATE_DISALLOWED_TOOLS,
   CUSTOM_AGENT_DISALLOWED_TOOLS,

package/dist/lib/{chunk-KG4MJGKQ.js → chunk-BCBD34D2.js}

@@ -3,10 +3,7 @@ import {
   asRecord,
   createChildLogger,
   strArg
-} from "./chunk-EY7HE52Q.js";
-import {
-  MCP_CALL_TOOL_NAME
-} from "./chunk-GHF2PSEW.js";
+} from "./chunk-3XCGUKGJ.js";
 
 // src/mcp/tool-wrapper.ts
 var log = createChildLogger({ module: "mcp" });
@@ -148,7 +145,7 @@ var McpCallTool = class {
     this.registry = registry;
   }
   registry;
-  name = MCP_CALL_TOOL_NAME;
+  name = "McpCall";
   description = "Invoke a tool on a connected MCP server. Call ToolSearch first to load the tool's schema, then pass its arguments here exactly as that schema requires, using the same JSON types.";
   category = "command";
   // This tool must stay in tools[] itself, otherwise the model has no entry point

package/dist/lib/{chunk-IYPTOY3Y.js → chunk-FODSMOWP.js}

@@ -1,6 +1,10 @@
 import {
   normalizeToolResultContentBlock
-} from "./chunk-PIL7M52F.js";
+} from "./chunk-XT67KGWE.js";
+import {
+  MCP_TOOL_PREFIX,
+  isMcpToolLike
+} from "./chunk-BCBD34D2.js";
 import {
   AuthenticationError,
   ContextTooLongError,
@@ -17,11 +21,7 @@ import {
   thinkingBudgetForLevel,
   toAnthropicThinkingEffort,
   toReasoningEffort
-} from "./chunk-OQIQOU5S.js";
-import {
-  MCP_TOOL_PREFIX,
-  isMcpToolLike
-} from "./chunk-KG4MJGKQ.js";
+} from "./chunk-3OFLDUAW.js";
 import {
   asErrorString,
   asRecord,
@@ -30,7 +30,7 @@ import {
   createChildLogger,
   isRecord,
   strArg
-} from "./chunk-EY7HE52Q.js";
+} from "./chunk-3XCGUKGJ.js";
 
 // src/llm/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -112,7 +112,23 @@ function markToolsForCache(tools) {
   }
 }
 function needsToolSearchBeta(toolSchemas) {
-  return toolSchemas.some((s) => s.defer_loading);
+  return toolSchemas.some((schema) => "defer_loading" in schema && schema.defer_loading === true);
+}
+var COMPUTER_USE_BETA = "computer-use-2025-11-24";
+function toAnthropicToolSchema(schema) {
+  if ("type" in schema && schema.type === "computer_20251124") {
+    return { ...schema };
+  }
+  if ("input_schema" in schema) {
+    const tool = schema;
+    const { cache_control: cacheControl, ...rest } = tool;
+    return {
+      ...rest,
+      type: "custom",
+      ...tool.defer_loading !== true && cacheControl ? { cache_control: cacheControl } : {}
+    };
+  }
+  throw new Error("Anthropic received a tool schema serialized for another protocol.");
 }
 var log = createChildLogger({ module: "llm" });
 var MODEL_FETCH_TIMEOUT_MS = 3e3;
@@ -196,7 +212,7 @@ function buildAnthropicMessages(messages) {
             type: "tool_use",
             // tool use **request**
             id: tu.toolUseId,
-            name: tu.toolName,
+            name: tu.toolName === "ComputerUse" ? "computer" : tu.toolName,
             input: tu.arguments
           });
         }
@@ -256,6 +272,7 @@ function buildAnthropicMessages(messages) {
   return result;
 }
 var AnthropicClient = class {
+  protocol = "anthropic";
   client;
   model;
   /** Effective logical level for budget or explicitly configured adaptive mode. */
@@ -301,23 +318,10 @@ var AnthropicClient = class {
   async *stream(conversation, toolSchemas, abortSignal) {
     const messages = buildAnthropicMessages(ensureToolPairing(conversation.getMessages()));
     const sendToolSearchBeta = needsToolSearchBeta(toolSchemas);
-    const antToolSchemas = toolSchemas.map((s) => {
-      const tool = {
-        name: s.name,
-        description: s.description,
-        // Preserve constraints and definitions, not just properties/required.
-        input_schema: s.input_schema
-      };
-      if (s.strict !== void 0) {
-        tool.strict = s.strict;
-      }
-      if (s.defer_loading === true) {
-        tool.defer_loading = true;
-      } else if (s.cache_control) {
-        tool.cache_control = s.cache_control;
-      }
-      return tool;
-    });
+    const antToolSchemas = toolSchemas.map(toAnthropicToolSchema);
+    const sendComputerUseBeta = antToolSchemas.some(
+      (schema) => "type" in schema && schema.type === "computer_20251124"
+    );
     markToolsForCache(antToolSchemas);
     markLastUserTailForCache(messages);
     const params = {
@@ -335,7 +339,10 @@ var AnthropicClient = class {
         }
       ],
       messages,
-      ...antToolSchemas.length > 0 ? { tools: antToolSchemas } : {}
+      ...antToolSchemas.length > 0 ? (
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        { tools: antToolSchemas }
+      ) : {}
     };
     const level = this.getThinkingLevel();
     if (this.config.reasoning !== false) {
@@ -369,11 +376,13 @@ var AnthropicClient = class {
     let thinkingSignature = "";
     let inThinking = false;
     try {
+      const betas = [
+        ...sendToolSearchBeta ? [NATIVE_TOOL_USE_BETA] : [],
+        ...sendComputerUseBeta ? [COMPUTER_USE_BETA] : []
+      ];
       const response = this.client.messages.stream(params, {
         ...abortSignal ? { signal: abortSignal } : {},
-        // If any tool uses defer_loading this beta header is required, otherwise the server does not recognize the field.
-        // Only the official endpoint reaches this code path (see mcp/strategy).
-        ...sendToolSearchBeta ? { headers: { "anthropic-beta": NATIVE_TOOL_USE_BETA } } : {}
+        ...betas.length > 0 ? { headers: { "anthropic-beta": betas.join(",") } } : {}
       });
       let currentToolName = "";
       let currentToolId = "";
@@ -388,7 +397,7 @@ var AnthropicClient = class {
               thinkingSignature = "";
             } else if (block.type === "tool_use") {
               currentToolId = block.id;
-              currentToolName = block.name;
+              currentToolName = block.name === "computer" ? "ComputerUse" : block.name;
               jsonAccumulate = "";
               yield {
                 type: "tool_call_start",