@swifty.js/swifty 0.0.21 → 0.0.22

package/dist/lib/chunk-HK2Z6WP4.js

@@ -0,0 +1,223 @@
+import {
+  MCP_CALL_TOOL_NAME,
+  TOOL_SEARCH_TOOL_NAME
+} from "./chunk-GHF2PSEW.js";
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  discovered = /* @__PURE__ */ new Set();
+  /**
+   * How MCP tools are loaded, written by mcp/strategy after connecting to the
+   * server. ToolSearch relies on it to decide what to return, and the client
+   * relies on it to decide whether to send defer_loading. It stays eager when
+   * there is no MCP, which behaves the same as no deferral.
+   */
+  mcpLoadingMode = "eager";
+  /**
+   * Whether to expose the search and dispatch tools to the model is computed once
+   * by applyMode in mcp/strategy at session start. It is not recomputed each turn
+   * based on "are there still deferred tools": tools may be disabled at runtime,
+   * and recomputing would drop one from tools[] mid-session — that's an array
+   * change, which breaks the cache prefix just the same.
+   */
+  exposeToolSearch = false;
+  exposeMcpCall = false;
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  listTools() {
+    return [...this.tools.values()];
+  }
+  getAllSchemas(protocol = "anthropic") {
+    const isOpenAI = protocol === "openai" || protocol === "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) {
+        continue;
+      }
+      const deferred = Boolean(tool.deferred) && !this.discovered.has(tool.name);
+      if (deferred && !native) {
+        continue;
+      }
+      const s = tool.schema();
+      if (isOpenAI) {
+        schemas.push({
+          strict: false,
+          // Whether to enforce strict parameter validation. Default true.
+          type: "function",
+          name: s.name,
+          description: s.description,
+          parameters: s.input_schema,
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          function: {
+            name: s.name,
+            description: s.description,
+            parameters: s.input_schema
+          }
+        });
+      } else {
+        schemas.push(
+          deferred ? {
+            ...s,
+            type: "custom",
+            defer_loading: true
+          } : {
+            ...s,
+            type: "custom"
+          }
+        );
+      }
+    }
+    return schemas;
+  }
+  /**
+   * Names of deferred tools not yet discovered, in lexicographic order.
+   *
+   * Sorting is not cosmetic: callers compare this list to detect pool changes;
+   * unstable ordering would produce different text for the same set of tools
+   * and break the comparison.
+   */
+  getDeferredToolNames() {
+    const names = [];
+    for (const tool of this.tools.values()) {
+      if (tool.deferred && !this.discovered.has(tool.name)) {
+        names.push(tool.name);
+      }
+    }
+    return names.sort();
+  }
+  getDeferredTools() {
+    return [...this.tools.values()].filter((t) => t.deferred && !this.discovered.has(t.name));
+  }
+  searchDeferred(query, maxResults = 5) {
+    const lower = query.toLowerCase();
+    const matches = [];
+    for (const tool of this.tools.values()) {
+      if (!tool.deferred || this.discovered.has(tool.name)) {
+        continue;
+      }
+      if (tool.name.toLowerCase().includes(lower) || tool.description.toLowerCase().includes(lower)) {
+        matches.push(tool);
+        if (matches.length >= maxResults) {
+          break;
+        }
+      }
+    }
+    return matches;
+  }
+  findDeferredByNames(names) {
+    const lowerMap = /* @__PURE__ */ new Map();
+    for (const [name, tool] of this.tools) {
+      lowerMap.set(name.toLowerCase(), tool);
+    }
+    return names.map((n) => lowerMap.get(n.toLowerCase())).filter((t) => t?.deferred ?? false);
+  }
+  markDiscovered(name) {
+    this.discovered.add(name);
+  }
+  isDiscovered(name) {
+    return this.discovered.has(name);
+  }
+};
+
+// src/subagent/tool-filter.ts
+var SUBAGENT_DISALLOWED_TOOLS = /* @__PURE__ */ new Set([
+  "ExitPlanMode",
+  "Agent",
+  // Prevents recursive spawning of subagents
+  "AskUserQuestion",
+  "TaskStop"
+]);
+var TEAMMATE_DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["TeamCreate", "TeamDelete"]);
+var CUSTOM_AGENT_DISALLOWED_TOOLS = /* @__PURE__ */ new Set([
+  "ExitPlanMode",
+  "Agent",
+  "AskUserQuestion",
+  "TaskStop"
+]);
+var ASYNC_AGENT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
+  "ReadFile",
+  // "WebSearch",
+  "Grep",
+  "Glob",
+  "Bash",
+  "PowerShell",
+  "EditFile",
+  "WriteFile",
+  "LoadSkill",
+  "SyntheticOutput",
+  "ToolSearch",
+  "EnterWorktree",
+  "ExitWorktree",
+  // ToolSearch only reads out schemas; actual invocation relies on McpCall.
+  // The two must be allowed together, or the subagent sees tools but cannot call them
+  "McpCall"
+]);
+function isMCPTool(name) {
+  return name.startsWith("mcp__");
+}
+function filterToolsForAgent(registry, allowedTools, disallowedTools, isAsync, isCustom = false) {
+  const disallowed = new Set(disallowedTools ?? []);
+  const allowed = new Set(allowedTools ?? []);
+  const hasWhitelist = allowed.size > 0 && !(allowed.size === 1 && allowed.has("*"));
+  const filtered = new ToolRegistry();
+  for (const tool of registry.listTools()) {
+    const name = tool.name;
+    if (isMCPTool(name)) {
+      filtered.register(tool);
+      continue;
+    }
+    if (SUBAGENT_DISALLOWED_TOOLS.has(name)) {
+      continue;
+    }
+    if (isCustom && CUSTOM_AGENT_DISALLOWED_TOOLS.has(name)) {
+      continue;
+    }
+    if (isAsync && !ASYNC_AGENT_ALLOWED_TOOLS.has(name)) {
+      continue;
+    }
+    if (disallowed.has(name)) {
+      continue;
+    }
+    if (hasWhitelist && !allowed.has(name)) {
+      continue;
+    }
+    filtered.register(tool);
+  }
+  return filtered;
+}
+var FORK_QUERY_SOURCE = "agent:builtin:fork";
+function cloneRegistryForFork(registry) {
+  const forked = new ToolRegistry();
+  for (const tool of registry.listTools()) {
+    if (tool.name === "Agent" && "querySource" in tool) {
+      const clone = Object.create(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        Object.getPrototypeOf(tool),
+        Object.getOwnPropertyDescriptors(tool)
+      );
+      clone.querySource = FORK_QUERY_SOURCE;
+      forked.register(clone);
+    } else {
+      forked.register(tool);
+    }
+  }
+  return forked;
+}
+
+export {
+  ToolRegistry,
+  SUBAGENT_DISALLOWED_TOOLS,
+  TEAMMATE_DISALLOWED_TOOLS,
+  CUSTOM_AGENT_DISALLOWED_TOOLS,
+  ASYNC_AGENT_ALLOWED_TOOLS,
+  filterToolsForAgent,
+  FORK_QUERY_SOURCE,
+  cloneRegistryForFork
+};