fourmis-agents-sdk 0.3.0 → 0.4.0

package/dist/skills/skills.js

@@ -0,0 +1,324 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/skills/frontmatter.ts
+import { parse } from "yaml";
+function normalizeNewlines(value) {
+  return value.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function extractFrontmatter(content) {
+  const normalized = normalizeNewlines(content);
+  if (!normalized.startsWith("---")) {
+    return { yamlString: null, body: normalized };
+  }
+  const endIndex = normalized.indexOf(`
+---`, 3);
+  if (endIndex === -1) {
+    return { yamlString: null, body: normalized };
+  }
+  return {
+    yamlString: normalized.slice(4, endIndex),
+    body: normalized.slice(endIndex + 4).trim()
+  };
+}
+function parseFrontmatter(content) {
+  const { yamlString, body } = extractFrontmatter(content);
+  if (!yamlString) {
+    return { frontmatter: {}, body };
+  }
+  const parsed = parse(yamlString);
+  return { frontmatter: parsed ?? {}, body };
+}
+function stripFrontmatter(content) {
+  return parseFrontmatter(content).body;
+}
+
+// src/skills/skills.ts
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, resolve } from "path";
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var MAX_COMPATIBILITY_LENGTH = 500;
+var CONFIG_DIR_NAME = ".claude";
+function shouldIgnore(name) {
+  return name.startsWith(".") || name === "node_modules";
+}
+function validateName(name, parentDirName) {
+  const errors = [];
+  if (name !== parentDirName) {
+    errors.push(`name "${name}" does not match parent directory "${parentDirName}"`);
+  }
+  if (name.length > MAX_NAME_LENGTH) {
+    errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    errors.push(`name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)`);
+  }
+  if (name.startsWith("-") || name.endsWith("-")) {
+    errors.push(`name must not start or end with a hyphen`);
+  }
+  if (name.includes("--")) {
+    errors.push(`name must not contain consecutive hyphens`);
+  }
+  return errors;
+}
+function validateDescription(description) {
+  const errors = [];
+  if (!description || description.trim() === "") {
+    errors.push("description is required");
+  } else if (description.length > MAX_DESCRIPTION_LENGTH) {
+    errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+  }
+  return errors;
+}
+function validateCompatibility(compatibility) {
+  if (!compatibility)
+    return [];
+  if (compatibility.length > MAX_COMPATIBILITY_LENGTH) {
+    return [`compatibility exceeds ${MAX_COMPATIBILITY_LENGTH} characters (${compatibility.length})`];
+  }
+  return [];
+}
+function loadSkillsFromDir(options) {
+  return loadSkillsFromDirInternal(options.dir, options.source, true);
+}
+function loadSkillsFromDirInternal(dir, source, includeRootFiles) {
+  const skills = [];
+  const diagnostics = [];
+  if (!existsSync(dir)) {
+    return { skills, diagnostics };
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (shouldIgnore(entry.name)) {
+        continue;
+      }
+      const fullPath = join(dir, entry.name);
+      let isDirectory = entry.isDirectory();
+      let isFile = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        try {
+          const stats = statSync(fullPath);
+          isDirectory = stats.isDirectory();
+          isFile = stats.isFile();
+        } catch {
+          continue;
+        }
+      }
+      if (isDirectory) {
+        const subResult = loadSkillsFromDirInternal(fullPath, source, false);
+        skills.push(...subResult.skills);
+        diagnostics.push(...subResult.diagnostics);
+        continue;
+      }
+      if (!isFile)
+        continue;
+      const isRootMd = includeRootFiles && entry.name.endsWith(".md");
+      const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
+      if (!isRootMd && !isSkillMd)
+        continue;
+      const result = loadSkillFromFile(fullPath, source);
+      if (result.skill) {
+        skills.push(result.skill);
+      }
+      diagnostics.push(...result.diagnostics);
+    }
+  } catch {}
+  return { skills, diagnostics };
+}
+function loadSkillFromFile(filePath, source) {
+  const diagnostics = [];
+  try {
+    const rawContent = readFileSync(filePath, "utf-8");
+    const { frontmatter } = parseFrontmatter(rawContent);
+    const skillDir = dirname(filePath);
+    const parentDirName = basename(skillDir);
+    const descErrors = validateDescription(frontmatter.description);
+    for (const error of descErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    const name = frontmatter.name || parentDirName;
+    const nameErrors = validateName(name, parentDirName);
+    for (const error of nameErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    const compatErrors = validateCompatibility(frontmatter.compatibility);
+    for (const error of compatErrors) {
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    }
+    if (!frontmatter.description || frontmatter.description.trim() === "") {
+      return { skill: null, diagnostics };
+    }
+    const allowedToolsRaw = frontmatter["allowed-tools"];
+    const allowedTools = allowedToolsRaw ? allowedToolsRaw.split(/\s+/).filter(Boolean) : undefined;
+    return {
+      skill: {
+        name,
+        description: frontmatter.description,
+        filePath,
+        baseDir: skillDir,
+        source,
+        disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata,
+        allowedTools
+      },
+      diagnostics
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "failed to parse skill file";
+    diagnostics.push({ type: "warning", message, path: filePath });
+    return { skill: null, diagnostics };
+  }
+}
+function normalizePath(input) {
+  const trimmed = input.trim();
+  if (trimmed === "~")
+    return homedir();
+  if (trimmed.startsWith("~/"))
+    return join(homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~"))
+    return join(homedir(), trimmed.slice(1));
+  return trimmed;
+}
+function resolveSkillPath(p, cwd) {
+  const normalized = normalizePath(p);
+  return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
+}
+function loadSkills(options = {}) {
+  const { cwd = process.cwd(), skillPaths = [], includeDefaults = true } = options;
+  const skillMap = new Map;
+  const realPathSet = new Set;
+  const allDiagnostics = [];
+  const collisionDiagnostics = [];
+  function addSkills(result) {
+    allDiagnostics.push(...result.diagnostics);
+    for (const skill of result.skills) {
+      let realPath;
+      try {
+        realPath = realpathSync(skill.filePath);
+      } catch {
+        realPath = skill.filePath;
+      }
+      if (realPathSet.has(realPath))
+        continue;
+      const existing = skillMap.get(skill.name);
+      if (existing) {
+        collisionDiagnostics.push({
+          type: "collision",
+          message: `name "${skill.name}" collision`,
+          path: skill.filePath,
+          collision: {
+            resourceType: "skill",
+            name: skill.name,
+            winnerPath: existing.filePath,
+            loserPath: skill.filePath
+          }
+        });
+      } else {
+        skillMap.set(skill.name, skill);
+        realPathSet.add(realPath);
+      }
+    }
+  }
+  if (includeDefaults) {
+    const userSkillsDir = join(homedir(), CONFIG_DIR_NAME, "skills");
+    const projectSkillsDir = resolve(cwd, CONFIG_DIR_NAME, "skills");
+    addSkills(loadSkillsFromDirInternal(userSkillsDir, "user", true));
+    addSkills(loadSkillsFromDirInternal(projectSkillsDir, "project", true));
+  }
+  for (const rawPath of skillPaths) {
+    const resolvedPath = resolveSkillPath(rawPath, cwd);
+    if (!existsSync(resolvedPath)) {
+      allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
+      continue;
+    }
+    try {
+      const stats = statSync(resolvedPath);
+      if (stats.isDirectory()) {
+        addSkills(loadSkillsFromDirInternal(resolvedPath, "path", true));
+      } else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+        const result = loadSkillFromFile(resolvedPath, "path");
+        if (result.skill) {
+          addSkills({ skills: [result.skill], diagnostics: result.diagnostics });
+        } else {
+          allDiagnostics.push(...result.diagnostics);
+        }
+      } else {
+        allDiagnostics.push({ type: "warning", message: "skill path is not a markdown file", path: resolvedPath });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "failed to read skill path";
+      allDiagnostics.push({ type: "warning", message, path: resolvedPath });
+    }
+  }
+  return {
+    skills: Array.from(skillMap.values()),
+    diagnostics: [...allDiagnostics, ...collisionDiagnostics]
+  };
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatSkillsForPrompt(skills) {
+  const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+  if (visibleSkills.length === 0) {
+    return "";
+  }
+  const lines = [
+    "The following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>"
+  ];
+  for (const skill of visibleSkills) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    if (skill.allowedTools?.length) {
+      lines.push(`    <allowed-tools>${escapeXml(skill.allowedTools.join(" "))}</allowed-tools>`);
+    }
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join(`
+`);
+}
+export {
+  loadSkillsFromDir,
+  loadSkills,
+  formatSkillsForPrompt
+};

package/dist/tools/ask-user-question.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AskUserQuestion tool.
+ * In this in-process runtime, direct interactive prompting is not available.
+ */
+import type { ToolImplementation } from "./registry.js";
+export declare const AskUserQuestionTool: ToolImplementation;
+//# sourceMappingURL=ask-user-question.d.ts.map

package/dist/tools/ask-user-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask-user-question.d.ts","sourceRoot":"","sources":["../../src/tools/ask-user-question.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAc,MAAM,eAAe,CAAC;AAEpE,eAAO,MAAM,mBAAmB,EAAE,kBAuCjC,CAAC"}

package/dist/tools/ask-user-question.js

@@ -0,0 +1,63 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tools/ask-user-question.ts
+var AskUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: "Ask the user a clarifying question and wait for their response.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "Question to ask the user."
+      },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional fixed choices."
+      }
+    },
+    required: ["question"]
+  },
+  async execute(input) {
+    const { question, options } = input ?? {};
+    if (!question) {
+      return { content: "Error: question is required", isError: true };
+    }
+    const choices = Array.isArray(options) && options.length > 0 ? ` Choices: ${options.join(" | ")}` : "";
+    return {
+      content: `User interaction is not available in this runtime. Unanswered question: ${question}.${choices}`,
+      isError: true
+    };
+  }
+};
+export {
+  AskUserQuestionTool
+};

package/dist/tools/bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../src/tools/bash.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAA2B,MAAM,eAAe,CAAC;AAMjF,eAAO,MAAM,QAAQ,EAAE,kBAmFtB,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../src/tools/bash.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAA2B,MAAM,eAAe,CAAC;AAMjF,eAAO,MAAM,QAAQ,EAAE,kBAoItB,CAAC"}

package/dist/tools/bash.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -33,17 +48,58 @@ var BashTool = {
       timeout: {
         type: "number",
         description: "Timeout in milliseconds (max 600000)"
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "Run command asynchronously and return immediately."
+      },
+      dangerouslyDisableSandbox: {
+        type: "boolean",
+        description: "If true, explicitly request unsandboxed execution."
+      },
+      _simulatedSedEdit: {
+        type: "object",
+        properties: {
+          filePath: { type: "string" },
+          newContent: { type: "string" }
+        },
+        description: "Internal field for precomputed edit previews."
       }
     },
     required: ["command"]
   },
   async execute(input, ctx) {
-    const { command, timeout: timeoutMs, description } = input;
+    const {
+      command,
+      timeout: timeoutMs,
+      run_in_background,
+      description,
+      dangerouslyDisableSandbox,
+      _simulatedSedEdit
+    } = input;
     if (!command || typeof command !== "string") {
       return { content: "Error: command is required", isError: true };
     }
     const timeout = Math.min(timeoutMs ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     try {
+      if (run_in_background) {
+        const proc2 = Bun.spawn(["bash", "-c", command], {
+          cwd: ctx.cwd,
+          stdout: "ignore",
+          stderr: "ignore",
+          stdin: "ignore",
+          env: { ...process.env, ...ctx.env }
+        });
+        return {
+          content: `Background command started (pid ${proc2.pid ?? "unknown"}).`,
+          metadata: {
+            pid: proc2.pid ?? null,
+            run_in_background: true,
+            dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+            hasSimulatedSedEdit: !!_simulatedSedEdit
+          }
+        };
+      }
       const proc = Bun.spawn(["bash", "-c", command], {
         cwd: ctx.cwd,
         stdout: "pipe",
@@ -75,7 +131,11 @@ var BashTool = {
       return {
         content: output,
         isError: exitCode !== 0 ? true : undefined,
-        metadata: { exitCode }
+        metadata: {
+          exitCode,
+          dangerouslyDisableSandbox: dangerouslyDisableSandbox === true,
+          hasSimulatedSedEdit: !!_simulatedSedEdit
+        }
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

package/dist/tools/config.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Config tool.
+ * Reads/writes Claude-style settings JSON files.
+ */
+import type { ToolImplementation } from "./registry.js";
+export declare const ConfigTool: ToolImplementation;
+//# sourceMappingURL=config.d.ts.map

package/dist/tools/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/tools/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAA2B,MAAM,eAAe,CAAC;AAmCjF,eAAO,MAAM,UAAU,EAAE,kBA4ExB,CAAC"}

package/dist/tools/config.js

@@ -0,0 +1,129 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tools/config.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join, dirname } from "path";
+function scopePath(cwd, scope) {
+  if (scope === "project")
+    return join(cwd, ".claude", "settings.json");
+  return join(cwd, ".claude", "settings.local.json");
+}
+function setByPath(obj, keyPath, value) {
+  const keys = keyPath.split(".").filter(Boolean);
+  if (keys.length === 0)
+    return;
+  let current = obj;
+  for (let i = 0;i < keys.length - 1; i++) {
+    const key = keys[i];
+    const next = current[key];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function getByPath(obj, keyPath) {
+  const keys = keyPath.split(".").filter(Boolean);
+  let current = obj;
+  for (const key of keys) {
+    if (!current || typeof current !== "object" || Array.isArray(current))
+      return;
+    current = current[key];
+  }
+  return current;
+}
+var ConfigTool = {
+  name: "Config",
+  description: "Read or update .claude settings values.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["get", "set", "list"]
+      },
+      key: {
+        type: "string",
+        description: "Dot-path key (for get/set)."
+      },
+      value: {
+        description: "Value for set action."
+      },
+      scope: {
+        type: "string",
+        enum: ["local", "project"]
+      }
+    },
+    required: ["action"]
+  },
+  async execute(input, ctx) {
+    const {
+      action,
+      key,
+      value,
+      scope = "local"
+    } = input ?? {};
+    if (!action) {
+      return { content: "Error: action is required", isError: true };
+    }
+    const filePath = scopePath(ctx.cwd, scope);
+    let data = {};
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      data = JSON.parse(raw);
+    } catch {
+      data = {};
+    }
+    if (action === "list") {
+      return { content: JSON.stringify(data, null, 2) };
+    }
+    if (!key) {
+      return { content: "Error: key is required for get/set", isError: true };
+    }
+    if (action === "get") {
+      const out = getByPath(data, key);
+      return { content: out === undefined ? "undefined" : JSON.stringify(out, null, 2) };
+    }
+    setByPath(data, key, value);
+    try {
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, JSON.stringify(data, null, 2) + `
+`, "utf-8");
+      return { content: `Updated ${key} in ${filePath}` };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing config: ${message}`, isError: true };
+    }
+  }
+};
+export {
+  ConfigTool
+};

package/dist/tools/edit.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {

package/dist/tools/exit-plan-mode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ExitPlanMode tool.
+ * Signals the runtime to leave plan mode and return to default permissions.
+ */
+import type { ToolImplementation } from "./registry.js";
+export declare const ExitPlanModeTool: ToolImplementation;
+//# sourceMappingURL=exit-plan-mode.d.ts.map

package/dist/tools/exit-plan-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-plan-mode.d.ts","sourceRoot":"","sources":["../../src/tools/exit-plan-mode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAc,MAAM,eAAe,CAAC;AAEpE,eAAO,MAAM,gBAAgB,EAAE,kBAgB9B,CAAC"}