@cursor/bdk 0.2.3 → 0.2.4

package/src/internal/install-cursor-skills.ts

@@ -1,604 +0,0 @@
-/**
- * Offer to install the package's coding-agent skills into the user's
- * personal Cursor skills dir under `~/.cursor/skills/bdk/<skill>/`.
- *
- * Cursor walks `~/.cursor/skills` recursively, so the `bdk/` folder is
- * only organizational — identity comes from the leaf folder that holds
- * SKILL.md. Installed copies get `alwaysApply: true` so Cursor injects the
- * skill body as a global rule instead of leaving it as an on-demand catalog
- * entry. Skipped for `--json` / non-TTY hosts.
- *
- * Consumer installs (`npm install` / `npx` of `@cursor/bdk`) also copy
- * these skills from a postinstall hook. That path never prompts and never
- * fails the package install. The monorepo source checkout is not a consumer
- * install, so `pnpm install` in everysphere does not overwrite `~/.cursor`.
- */
-
-import { access, chmod, cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { CLI_COMMAND_NAME, packageRootDir } from "./distribution.js";
-import { parseFrontmatter } from "./frontmatter.js";
-import { stdoutPalette } from "./terminal-style.js";
-
-/** Category folder under ~/.cursor/skills (Cursor discovers nested skills). */
-export const CURSOR_SKILLS_NAMESPACE = "bdk";
-
-/**
- * Earlier install folders. Deleted on install so stale skill ids stop
- * being discovered next to the current copies.
- */
-const LEGACY_CURSOR_SKILLS_NAMESPACES = ["agentsdk", "agentkit"] as const;
-
-/** How long the `init` offer waits for an answer before skipping the install. */
-export const SKILL_PROMPT_TIMEOUT_MS = 45_000;
-
-/**
- * Override the resolved `~/.cursor/skills` directory (not the user home).
- * Used by the postinstall hook in tests and publish smoke.
- */
-export const CURSOR_JULY_SKILLS_HOME_ENV = "CURSOR_JULY_SKILLS_HOME";
-
-/** Set to `1` to skip the postinstall skill copy. */
-export const CURSOR_JULY_SKIP_SKILL_INSTALL_ENV = "CURSOR_JULY_SKIP_SKILL_INSTALL";
-
-export interface PackageSkill {
-  /** Frontmatter `name` (e.g. bdk-create-agent). */
-  name: string;
-  /** Leaf install directory under bdk/ (e.g. create-agent). */
-  leafDir: string;
-  /** Absolute path to the source skill directory in the package. */
-  sourceDir: string;
-  /** Exact package version that supplied this skill. */
-  packageVersion: string;
-}
-
-export function cursorSkillsHome(home?: string): string {
-  if (home !== undefined) {
-    return join(home.trim() === "" ? homedir() : home, ".cursor", "skills");
-  }
-  const override = process.env[CURSOR_JULY_SKILLS_HOME_ENV]?.trim();
-  if (override !== undefined && override !== "") {
-    return override;
-  }
-  return join(homedir(), ".cursor", "skills");
-}
-
-/**
- * True when this package root is an installed copy under `node_modules`
- * (npm, pnpm, yarn, npx, global), not the everysphere source checkout.
- */
-export function isConsumerPackageInstall(packageRoot: string): boolean {
-  // Segment check only — split on both separators so a Windows path still
-  // matches when this runs (or is tested) on POSIX. Do not rewrite the path.
-  return packageRoot.split(/[\\/]/).includes("node_modules");
-}
-
-/** `~/.cursor/skills/bdk` — where package skills are installed. */
-export function bdkCursorSkillsDir(skillsHome: string = cursorSkillsHome()): string {
-  return join(skillsHome, CURSOR_SKILLS_NAMESPACE);
-}
-
-function legacyCursorSkillsDirs(skillsHome: string): string[] {
-  return LEGACY_CURSOR_SKILLS_NAMESPACES.map(name => join(skillsHome, name));
-}
-
-/** Absolute install path for one skill: `…/bdk/<leafDir>`. */
-export function skillInstallPath(
-  skill: Pick<PackageSkill, "leafDir">,
-  skillsHome: string = cursorSkillsHome(),
-): string {
-  return join(bdkCursorSkillsDir(skillsHome), skill.leafDir);
-}
-
-/**
- * Skills shipped next to the running package. Uses the frontmatter `name`
- * when present, otherwise `bdk-<dir>`.
- */
-export async function listShippedPackageSkills(
-  packageRoot: string = packageRootDir(),
-): Promise<PackageSkill[]> {
-  const skillsRoot = join(packageRoot, "skills");
-  let entries: Array<{ name: string; isDirectory: () => boolean }>;
-  try {
-    entries = await readdir(skillsRoot, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const packageVersion = await readPackageVersion(packageRoot);
-
-  const skills: PackageSkill[] = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const sourceDir = join(skillsRoot, entry.name);
-    const skillMd = join(sourceDir, "SKILL.md");
-    try {
-      await access(skillMd);
-    } catch {
-      continue;
-    }
-    const raw = await readFile(skillMd, "utf8");
-    const name = parseFrontmatter(raw).data.name || `${CURSOR_SKILLS_NAMESPACE}-${entry.name}`;
-    skills.push({ name, leafDir: entry.name, sourceDir, packageVersion });
-  }
-  skills.sort((a, b) => a.leafDir.localeCompare(b.leafDir));
-  return skills;
-}
-
-const PACKAGE_VERSION_PLACEHOLDER = "__CURSOR_JULY_VERSION__";
-
-async function readPackageVersion(packageRoot: string): Promise<string> {
-  const raw = await readFile(join(packageRoot, "package.json"), "utf8");
-  const manifest = JSON.parse(raw) as { version?: unknown };
-  if (typeof manifest.version !== "string" || manifest.version.trim() === "") {
-    throw new Error("The @cursor/bdk package must declare a version.");
-  }
-  return manifest.version;
-}
-
-/**
- * Skills that do not yet have a SKILL.md under ~/.cursor/skills/bdk/.
- * Install still overwrites every shipped skill when the user confirms — this
- * helper is for messaging (fresh install vs update).
- */
-export async function findMissingCursorSkills(options?: {
-  packageRoot?: string;
-  skillsHome?: string;
-}): Promise<PackageSkill[]> {
-  const shipped = await listShippedPackageSkills(options?.packageRoot);
-  const home = options?.skillsHome ?? cursorSkillsHome();
-  const missing: PackageSkill[] = [];
-  for (const skill of shipped) {
-    try {
-      await access(join(skillInstallPath(skill, home), "SKILL.md"));
-    } catch {
-      missing.push(skill);
-    }
-  }
-  return missing;
-}
-
-export interface SkillInstallResult {
-  /** Leaf dirs written. */
-  installed: string[];
-  /** Leaf dirs deleted because the package no longer ships them. */
-  removed: string[];
-  /** Leftover namespace dirs deleted (`…/agentsdk`, `…/agentkit`). */
-  removedLegacyDirs: string[];
-}
-
-/**
- * Copy each skill directory into `skillsHome/bdk/<leafDir>/`.
- * Always overwrites so a package upgrade refreshes local Cursor skills.
- * Strips monorepo-only frontmatter, sets `alwaysApply: true` so Cursor
- * loads the body into context, and removes leaf dirs no longer shipped.
- * Also deletes leftover `skillsHome/agentsdk/` and `skillsHome/agentkit/`.
- */
-export async function installCursorSkills(
-  skills: readonly PackageSkill[],
-  skillsHome: string = cursorSkillsHome(),
-): Promise<SkillInstallResult> {
-  const namespaceDir = bdkCursorSkillsDir(skillsHome);
-  await mkdir(namespaceDir, { recursive: true });
-
-  const removed = await orphanLeaves(namespaceDir, skills);
-  for (const leaf of removed) {
-    await rm(join(namespaceDir, leaf), { recursive: true, force: true });
-  }
-
-  const installed: string[] = [];
-  for (const skill of skills) {
-    const target = skillInstallPath(skill, skillsHome);
-    await cp(skill.sourceDir, target, { recursive: true, force: true });
-    // cp() preserves source modes, and installs can come from read-only
-    // stores (Bazel runfiles, pnpm's content-addressed store, nix). Make the
-    // copies writable so the SKILL.md rewrite below and the overwrite on the
-    // next upgrade both work.
-    await makeTreeWritable(target);
-    const skillMdPath = join(target, "SKILL.md");
-    const raw = await readFile(skillMdPath, "utf8");
-    const adjusted = prepareSkillMarkdownForCursorInstall(raw, skill.packageVersion);
-    if (adjusted !== raw) {
-      await writeFile(skillMdPath, adjusted, "utf8");
-    }
-    installed.push(skill.leafDir);
-  }
-  const removedLegacyDirs = await removeLegacyCursorSkillsNamespaces(skillsHome);
-  return { installed, removed, removedLegacyDirs };
-}
-
-async function makeTreeWritable(root: string): Promise<void> {
-  await addOwnerWrite(root);
-  const entries = await readdir(root, { withFileTypes: true });
-  for (const entry of entries) {
-    const child = join(root, entry.name);
-    if (entry.isDirectory()) {
-      await makeTreeWritable(child);
-    } else {
-      await addOwnerWrite(child);
-    }
-  }
-}
-
-/** Add owner-write, preserving every other mode bit (e.g. exec on scripts). */
-async function addOwnerWrite(path: string): Promise<void> {
-  const mode = (await stat(path)).mode & 0o7777;
-  if ((mode & 0o200) === 0) {
-    await chmod(path, mode | 0o200);
-  }
-}
-
-/** Installed leaf dirs the package no longer ships. Installing deletes these. */
-async function orphanLeaves(
-  namespaceDir: string,
-  skills: readonly PackageSkill[],
-): Promise<string[]> {
-  const shipped = new Set(skills.map(skill => skill.leafDir));
-  let entries: Array<{ name: string; isDirectory: () => boolean }>;
-  try {
-    entries = await readdir(namespaceDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries
-    .filter(entry => entry.isDirectory() && !shipped.has(entry.name))
-    .map(entry => entry.name);
-}
-
-/** Drop leftover earlier install folders so stale skill ids are not discovered. */
-async function removeLegacyCursorSkillsNamespaces(skillsHome: string): Promise<string[]> {
-  const present = await existingLegacyCursorSkillsDirs(skillsHome);
-  for (const dir of present) {
-    await rm(dir, { recursive: true, force: true });
-  }
-  return present;
-}
-
-async function existingLegacyCursorSkillsDirs(skillsHome: string): Promise<string[]> {
-  const present: string[] = [];
-  for (const dir of legacyCursorSkillsDirs(skillsHome)) {
-    try {
-      await stat(dir);
-      present.push(dir);
-    } catch {
-      continue;
-    }
-  }
-  return present;
-}
-
-/**
- * Drop monorepo `paths` globs, set `alwaysApply: true` so Cursor injects the
- * body as a global rule, bind package commands to the installing version, and
- * fix package doc links for ~/.cursor installs.
- */
-export function prepareSkillMarkdownForCursorInstall(
-  content: string,
-  packageVersion?: string,
-): string {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
-  if (match === null) {
-    return content;
-  }
-  const frontmatter = withAlwaysApply(stripPathsFromFrontmatter(match[1] ?? ""));
-  const body = content.slice(match[0].length);
-  const adjustedBody = body.replace(
-    /\[`docs\/([^`]+)`\]\(\.\.\/\.\.\/docs\/[^)]+\)/g,
-    "docs/$1 in the @cursor/bdk package",
-  );
-  if (
-    adjustedBody.includes(PACKAGE_VERSION_PLACEHOLDER) &&
-    (packageVersion === undefined || packageVersion.trim() === "")
-  ) {
-    throw new Error("Cannot install a BDK skill without a package version.");
-  }
-  const versionBoundBody =
-    packageVersion === undefined
-      ? adjustedBody
-      : adjustedBody.replaceAll(PACKAGE_VERSION_PLACEHOLDER, packageVersion);
-  return `---\n${frontmatter.trimEnd()}\n---${versionBoundBody}`;
-}
-
-function stripPathsFromFrontmatter(frontmatter: string): string {
-  const lines = frontmatter.split(/\r?\n/);
-  const out: string[] = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i] ?? "";
-    if (line.trimStart().startsWith("paths:")) {
-      i++;
-      while (i < lines.length && /^[ \t]*-/.test(lines[i] ?? "")) {
-        i++;
-      }
-      i--;
-      continue;
-    }
-    out.push(line);
-  }
-  return out.join("\n");
-}
-
-/** Cursor loads `alwaysApply: true` skills as global rules, not catalog rows. */
-function withAlwaysApply(frontmatter: string): string {
-  const without = frontmatter
-    .split(/\r?\n/)
-    .filter(line => !/^\s*alwaysApply\s*:/.test(line))
-    .join("\n")
-    .replace(/\n+$/, "");
-  if (without === "") {
-    return "alwaysApply: true";
-  }
-  return `${without}\nalwaysApply: true`;
-}
-
-export interface SkillInstallPlan {
-  shipped: PackageSkill[];
-  /** Resolved `~/.cursor/skills`, to install into. */
-  skillsHome: string;
-  /** Install target: `<skillsHome>/bdk`. */
-  directory: string;
-  /** Leaf dirs the package ships. */
-  leaves: string[];
-  /** Nothing installed yet, so this is a fresh install rather than a refresh. */
-  firstInstall: boolean;
-  /** Installed leaf dirs the package dropped; installing deletes them. */
-  orphans: string[];
-  /** Leftover namespace dirs that still exist. Installing deletes them. */
-  legacyDirs: string[];
-}
-
-/** What an install would do, for the offer and for `install-skills`. */
-export async function planSkillInstall(options?: {
-  packageRoot?: string;
-  skillsHome?: string;
-}): Promise<SkillInstallPlan> {
-  const skillsHome = options?.skillsHome ?? cursorSkillsHome();
-  const directory = bdkCursorSkillsDir(skillsHome);
-  const shipped = await listShippedPackageSkills(options?.packageRoot);
-  const present = await Promise.all(
-    shipped.map(async skill => {
-      try {
-        await access(join(skillInstallPath(skill, skillsHome), "SKILL.md"));
-        return true;
-      } catch {
-        return false;
-      }
-    }),
-  );
-  return {
-    shipped,
-    skillsHome,
-    directory,
-    leaves: shipped.map(skill => skill.leafDir),
-    firstInstall: present.every(isPresent => !isPresent),
-    orphans: await orphanLeaves(directory, shipped),
-    legacyDirs: await existingLegacyCursorSkillsDirs(skillsHome),
-  };
-}
-
-/** `Installed 9 BDK skills`, what it dropped, and where it went. */
-export function formatSkillInstall(plan: SkillInstallPlan, result: SkillInstallResult): string {
-  const noun = result.installed.length === 1 ? "skill" : "skills";
-  const verb = plan.firstInstall ? "Installed" : "Updated";
-  const lines = [`${verb} ${result.installed.length} BDK ${noun}`];
-  if (result.removed.length > 0) {
-    lines.push(`  removed:  ${result.removed.join(", ")}`);
-  }
-  for (const dir of result.removedLegacyDirs) {
-    lines.push(`  removed:  ${dir}`);
-  }
-  lines.push(`  location: ${plan.directory}`);
-  return `${lines.join("\n")}\n`;
-}
-
-export type PackageInstallSkillSyncResult =
-  | { status: "installed"; installed: string[]; removed: string[] }
-  | {
-      status: "skipped";
-      reason: "opt-out" | "not-consumer" | "no-skills" | "error";
-    };
-
-export interface SyncCursorSkillsOnPackageInstallOptions {
-  packageRoot?: string;
-  skillsHome?: string;
-  env?: NodeJS.ProcessEnv;
-  /** Override the node_modules consumer check. */
-  consumer?: boolean;
-  out?: (text: string) => void;
-}
-
-/**
- * Copy shipped coding-agent skills into ~/.cursor/skills/bdk during a
- * consumer `npm install` / `npx`. Never throws: a failed copy must not fail
- * the package install. No-op in the monorepo source tree and when
- * `CURSOR_JULY_SKIP_SKILL_INSTALL=1`.
- */
-export async function syncCursorSkillsOnPackageInstall(
-  options: SyncCursorSkillsOnPackageInstallOptions = {},
-): Promise<PackageInstallSkillSyncResult> {
-  try {
-    const env = options.env ?? process.env;
-    if (env[CURSOR_JULY_SKIP_SKILL_INSTALL_ENV] === "1") {
-      return { status: "skipped", reason: "opt-out" };
-    }
-
-    const packageRoot = options.packageRoot ?? packageRootDir();
-    const consumer = options.consumer ?? isConsumerPackageInstall(packageRoot);
-    if (!consumer) {
-      return { status: "skipped", reason: "not-consumer" };
-    }
-
-    const plan = await planSkillInstall({
-      packageRoot,
-      skillsHome: options.skillsHome,
-    });
-    if (plan.shipped.length === 0) {
-      return { status: "skipped", reason: "no-skills" };
-    }
-
-    const result = await installCursorSkills(plan.shipped, plan.skillsHome);
-    const out = options.out ?? (text => process.stderr.write(text));
-    out(formatSkillInstall(plan, result));
-    return {
-      status: "installed",
-      installed: result.installed,
-      removed: result.removed,
-    };
-  } catch {
-    return { status: "skipped", reason: "error" };
-  }
-}
-
-export interface OfferInstallCursorSkillsOptions {
-  /** Skip when false (non-TTY / `--json`). */
-  interactive?: boolean;
-  packageRoot?: string;
-  skillsHome?: string;
-  /** Injected yes/no for tests. `undefined` means the prompt went unanswered. */
-  confirm?: (question: string) => Promise<boolean | undefined>;
-  out?: (text: string) => void;
-}
-
-/**
- * On a TTY, offer to install/update every shipped package skill into
- * ~/.cursor/skills/bdk (always overwriting). No-op when non-interactive
- * or the package ships no skills. An unanswered prompt skips the install
- * rather than blocking the caller — see `SKILL_PROMPT_TIMEOUT_MS`.
- */
-export async function offerInstallCursorSkills(
-  options: OfferInstallCursorSkillsOptions = {},
-): Promise<{ installed: string[]; skipped: boolean }> {
-  const out = options.out ?? (text => process.stdout.write(text));
-  const interactive =
-    options.interactive ?? (process.stdin.isTTY === true && process.stdout.isTTY === true);
-  if (!interactive) {
-    return { installed: [], skipped: true };
-  }
-
-  const plan = await planSkillInstall({
-    packageRoot: options.packageRoot,
-    skillsHome: options.skillsHome,
-  });
-  if (plan.shipped.length === 0) {
-    return { installed: [], skipped: true };
-  }
-
-  const noun = plan.shipped.length === 1 ? "skill" : "skills";
-  const verb = plan.firstInstall ? "Install" : "Update";
-  const c = stdoutPalette();
-  out(`${verb} ${plan.shipped.length} BDK ${noun} in ${plan.directory}?\n`);
-  out(c.dim(`  ${plan.leaves.join(", ")}\n`));
-  if (!plan.firstInstall) {
-    out(c.dim("  (overwrites existing copies with the package version)\n"));
-  }
-  if (plan.orphans.length > 0) {
-    out(c.dim(`  (deletes ${plan.orphans.join(", ")})\n`));
-  }
-  for (const dir of plan.legacyDirs) {
-    out(c.dim(`  (deletes leftover ${dir})\n`));
-  }
-
-  const confirm =
-    options.confirm ??
-    (q =>
-      promptYesNo(q, {
-        defaultYes: true,
-        out,
-        timeoutMs: SKILL_PROMPT_TIMEOUT_MS,
-      }));
-  const accepted = await confirm(`${verb} now?`);
-
-  if (accepted !== true) {
-    // `undefined` is the prompt timing out or stdin closing; both mean nobody
-    // said yes, so do not claim a duration neither case is guaranteed to have.
-    const why =
-      accepted === undefined ? "No answer — skipped the skill install." : "Skipped skill install.";
-    out(c.dim(`${why}\nInstall later: ${CLI_COMMAND_NAME} install-skills (${plan.directory})\n\n`));
-    return { installed: [], skipped: true };
-  }
-
-  const result = await installCursorSkills(plan.shipped, plan.skillsHome);
-  out(`${formatSkillInstall(plan, result)}\n`);
-  return { installed: result.installed, skipped: false };
-}
-
-export interface PromptYesNoOptions {
-  defaultYes: boolean;
-  out: (text: string) => void;
-  /** Give up after this long; `0` (or omitted) waits forever. */
-  timeoutMs?: number;
-  /** Answer source; defaults to `process.stdin`. */
-  input?: NodeJS.ReadableStream;
-}
-
-/**
- * Ask a yes/no question. Resolves `undefined` when the answer never comes —
- * the prompt timed out, or stdin closed on an empty line.
- */
-export async function promptYesNo(
-  question: string,
-  options: PromptYesNoOptions,
-): Promise<boolean | undefined> {
-  const hint = options.defaultYes ? "Y/n" : "y/N";
-  const input = options.input ?? process.stdin;
-  options.out(`${question} [${hint}] `);
-  input.resume();
-  const line = await readOneLine(input, options.timeoutMs);
-  input.pause();
-  if (line === undefined) {
-    options.out("\n");
-    return undefined;
-  }
-  if (line.trim() === "") {
-    return options.defaultYes;
-  }
-  const answer = line.trim().toLowerCase();
-  if (answer === "y" || answer === "yes") {
-    return true;
-  }
-  if (answer === "n" || answer === "no") {
-    return false;
-  }
-  return options.defaultYes;
-}
-
-/** The line, or `undefined` when the stream ends or the clock runs out first. */
-function readOneLine(
-  stream: NodeJS.ReadableStream,
-  timeoutMs?: number,
-): Promise<string | undefined> {
-  return new Promise(resolve => {
-    let buffer = "";
-    let timer: NodeJS.Timeout | undefined;
-    const onData = (chunk: string | Buffer): void => {
-      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-      const newline = buffer.indexOf("\n");
-      if (newline === -1) {
-        return;
-      }
-      cleanup();
-      resolve(buffer.slice(0, newline).replace(/\r$/, ""));
-    };
-    // EOF and the timeout both land here. A tty holds a half-typed line until
-    // Enter, so a non-empty buffer only ever happens on piped input.
-    const giveUp = (): void => {
-      cleanup();
-      resolve(buffer === "" ? undefined : buffer.replace(/\r$/, ""));
-    };
-    const cleanup = (): void => {
-      if (timer !== undefined) {
-        clearTimeout(timer);
-      }
-      stream.off("data", onData);
-      stream.off("end", giveUp);
-    };
-    stream.on("data", onData);
-    stream.on("end", giveUp);
-    if (timeoutMs !== undefined && timeoutMs > 0) {
-      timer = setTimeout(giveUp, timeoutMs);
-      // Never keep the process alive purely to wait for an answer.
-      timer.unref();
-    }
-  });
-}

package/src/internal/is-record.ts

@@ -1,3 +0,0 @@
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/internal/json-schema.ts

@@ -1,95 +0,0 @@
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import type { JsonSchemaObject } from "../types.js";
-
-const ANY_OBJECT_SCHEMA: JsonSchemaObject = {
-  type: "object",
-  properties: {},
-  additionalProperties: true,
-};
-
-export function isZodSchema(value: unknown): value is z.ZodTypeAny {
-  if (value instanceof z.ZodType) {
-    return true;
-  }
-  // Structural check for zod instances that come from a different module
-  // copy in the authoring project's node_modules. Zod 4 keeps `_zod`
-  // (and often `_def`).
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof (value as { safeParse?: unknown }).safeParse === "function" &&
-    ("_def" in value || "_zod" in value)
-  );
-}
-
-/** Convert an authored input schema into the JSON Schema shown to the model. */
-export function toolInputJsonSchema(
-  inputSchema: z.ZodTypeAny | JsonSchemaObject | undefined,
-): JsonSchemaObject {
-  if (inputSchema === undefined) {
-    return ANY_OBJECT_SCHEMA;
-  }
-  return authoredSchemaToJsonSchema(inputSchema);
-}
-
-/**
- * Convert an authored output schema into the JSON Schema advertised on the
- * tool. Unlike {@link toolInputJsonSchema} there is no fallback: an
- * undeclared output schema stays undeclared (the MCP field is optional), and
- * outputs are never validated against it.
- */
-export function toolOutputJsonSchema(
-  outputSchema: z.ZodTypeAny | JsonSchemaObject | undefined,
-): JsonSchemaObject | undefined {
-  if (outputSchema === undefined) {
-    return undefined;
-  }
-  return authoredSchemaToJsonSchema(outputSchema);
-}
-
-function authoredSchemaToJsonSchema(schema: z.ZodTypeAny | JsonSchemaObject): JsonSchemaObject {
-  if (!isZodSchema(schema)) {
-    return schema;
-  }
-  const converted = convertZodSchema(schema);
-  delete converted.$schema;
-  return converted;
-}
-
-function convertZodSchema(schema: z.ZodTypeAny): Record<string, unknown> {
-  const native = (schema as { toJSONSchema?: () => unknown }).toJSONSchema;
-  if (typeof native === "function") {
-    return native.call(schema) as Record<string, unknown>;
-  }
-  return zodToJsonSchema(schema, {
-    $refStrategy: "none",
-    target: "jsonSchema7",
-  }) as Record<string, unknown>;
-}
-
-export type ToolInputValidation = { ok: true; value: unknown } | { ok: false; message: string };
-
-/**
- * Validate tool-call args before `execute` runs. Zod schemas validate (and
- * transform); plain JSON schemas pass through unvalidated.
- */
-export function validateToolInput(
-  inputSchema: z.ZodTypeAny | JsonSchemaObject | undefined,
-  args: unknown,
-): ToolInputValidation {
-  if (inputSchema === undefined || !isZodSchema(inputSchema)) {
-    return { ok: true, value: args };
-  }
-  const parsed = (inputSchema as z.ZodTypeAny).safeParse(args);
-  if (parsed.success) {
-    return { ok: true, value: parsed.data };
-  }
-  const issues = parsed.error.issues
-    .map(issue => {
-      const path = issue.path.join(".");
-      return path === "" ? issue.message : `${path}: ${issue.message}`;
-    })
-    .join("; ");
-  return { ok: false, message: issues || "invalid input" };
-}