@yukino.js/yukino 0.0.1

package/dist/lib/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/lib/chunk-O7ELJUEK.js

@@ -0,0 +1,262 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/subagent/tool-filter.ts
+var tool_filter_exports = {};
+__export(tool_filter_exports, {
+  ASYNC_AGENT_ALLOWED_TOOLS: () => ASYNC_AGENT_ALLOWED_TOOLS,
+  CUSTOM_AGENT_DISALLOWED_TOOLS: () => CUSTOM_AGENT_DISALLOWED_TOOLS,
+  FORK_QUERY_SOURCE: () => FORK_QUERY_SOURCE,
+  MAIN_AGENT_ONLY_TOOLS: () => MAIN_AGENT_ONLY_TOOLS,
+  SUBAGENT_DISALLOWED_TOOLS: () => SUBAGENT_DISALLOWED_TOOLS,
+  TEAMMATE_DISALLOWED_TOOLS: () => TEAMMATE_DISALLOWED_TOOLS,
+  cloneRegistryForFork: () => cloneRegistryForFork,
+  filterToolsForAgent: () => filterToolsForAgent
+});
+
+// src/tools/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ToolRegistry: () => ToolRegistry
+});
+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);
+  }
+  /**
+   * 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, 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 (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 s = tool.schema();
+      if (resolvedProtocol === "openai") {
+        schemas.push({
+          strict: s.strict ?? false,
+          type: "function",
+          name: s.name,
+          description: s.description,
+          parameters: s.input_schema
+        });
+      } else if (resolvedProtocol === "openai-compat") {
+        schemas.push({
+          type: "function",
+          function: {
+            name: s.name,
+            description: s.description,
+            parameters: s.input_schema,
+            strict: s.strict ?? false
+          }
+        });
+      } else {
+        schemas.push({ ...s, type: "custom", ...deferred ? { defer_loading: true } : {} });
+      }
+    }
+    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 MAIN_AGENT_ONLY_TOOLS = /* @__PURE__ */ new Set([
+  "ComputerUse",
+  "AskUserQuestion",
+  "ExitPlanMode"
+]);
+var SUBAGENT_DISALLOWED_TOOLS = /* @__PURE__ */ new Set([
+  ...MAIN_AGENT_ONLY_TOOLS,
+  "Agent",
+  // Prevents recursive spawning of subagents
+  "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();
+  filtered.mcpLoadingMode = registry.mcpLoadingMode;
+  for (const tool of registry.listTools()) {
+    const name = tool.name;
+    if (isMCPTool(name)) {
+      if (!disallowed.has(name) && (!hasWhitelist || allowed.has(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();
+  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
+        Object.getPrototypeOf(tool),
+        Object.getOwnPropertyDescriptors(tool)
+      );
+      clone.querySource = FORK_QUERY_SOURCE;
+      forked.register(clone);
+    } else {
+      forked.register(tool);
+    }
+  }
+  return forked;
+}
+
+export {
+  ToolRegistry,
+  registry_exports,
+  MAIN_AGENT_ONLY_TOOLS,
+  SUBAGENT_DISALLOWED_TOOLS,
+  TEAMMATE_DISALLOWED_TOOLS,
+  CUSTOM_AGENT_DISALLOWED_TOOLS,
+  ASYNC_AGENT_ALLOWED_TOOLS,
+  filterToolsForAgent,
+  FORK_QUERY_SOURCE,
+  cloneRegistryForFork,
+  tool_filter_exports
+};