stitchkit 0.90.3 → 0.90.5

package/dist/cli.js

@@ -1,33 +1,424 @@
 import {
+  CliArgumentError,
   DEFAULT_EXIT_CODES,
   createCli,
   defineCliCommand,
   emitResult,
+  extractCliGlobalOptions,
+  fetchGuarded,
   parseCliArgs,
-  pollUntilDone
-} from "./index-1923shw9.js";
+  pollUntilDone,
+  readCapped,
+  renderCliView,
+  routeCliArgv
+} from "./index-fqg5mfk7.js";
 import"./index-sbdmyz75.js";
-import"./index-wb15909q.js";
-import"./index-2hrfpw2c.js";
-import"./index-44ht2790.js";
+import"./index-zsdgd1tz.js";
+import"./index-1bnkzq95.js";
+import"./index-8pjqv3zh.js";
 import"./index-vsbzgd7b.js";
 import"./index-f9mb610r.js";
 import"./index-2hryh65w.js";
 import"./index-kazec06k.js";
 import"./index-6k1937bx.js";
-import"./index-scs3f1eg.js";
 import"./index-zcgf3gqf.js";
-import"./index-7zbps32p.js";
-import"./index-kzfs85xp.js";
-import"./index-kc6h6hg0.js";
-import"./index-r159gjwy.js";
+import {
+  coerceJsonArgs
+} from "./index-7zbps32p.js";
+import"./index-8z9we758.js";
+import"./index-fenaekmk.js";
 import"./index-cby4ar3v.js";
+import {
+  AppError
+} from "./index-scs3f1eg.js";
+import {
+  safeJsonParse
+} from "./index-kzfs85xp.js";
 import"./index-77fekveh.js";
+// src/tools/cli-installer.ts
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function renderCliInstaller(config) {
+  const binary = config.binaryName ?? config.manifest.name;
+  const installDir = config.installDir ?? "$HOME/.local/bin";
+  const assets = config.asset ? [config.asset] : config.manifest.assets;
+  if (assets.length === 0) {
+    throw new Error("[stitchkit] a build manifest with no assets installs nothing");
+  }
+  const selection = assets.length === 1 && assets[0] !== undefined ? singleTarget(assets[0]) : unameDispatch(assets);
+  return `#!/bin/sh
+# ${binary} ${config.manifest.version} (${config.manifest.commit})
+# Generated from the build manifest — it parses no JSON and needs no jq.
+set -eu
+
+binary=${shellQuote(binary)}
+dir="\${INSTALL_DIR:-${installDir}}"
+
+${selection}
+
+fetch() {
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsSL "$1" -o "$2"
+  elif command -v wget >/dev/null 2>&1; then
+    wget -q "$1" -O "$2"
+  else
+    echo "need curl or wget" >&2
+    exit 1
+  fi
+}
+
+digest() {
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$1" | cut -d' ' -f1
+  elif command -v shasum >/dev/null 2>&1; then
+    shasum -a 256 "$1" | cut -d' ' -f1
+  elif command -v openssl >/dev/null 2>&1; then
+    openssl dgst -sha256 "$1" | awk '{print $NF}'
+  else
+    echo "need sha256sum, shasum or openssl" >&2
+    exit 1
+  fi
+}
+
+tmp="$(mktemp -d)"
+trap 'rm -rf "$tmp"' EXIT
+
+fetch "$url" "$tmp/download"
+if [ "$compression" = "gzip" ]; then
+  gzip -dc "$tmp/download" > "$tmp/binary"
+else
+  mv "$tmp/download" "$tmp/binary"
+fi
+
+actual="$(digest "$tmp/binary")"
+if [ "$actual" != "$sha256" ]; then
+  echo "checksum mismatch: expected $sha256, got $actual" >&2
+  exit 1
+fi
+
+actual_size="$(wc -c < "$tmp/binary" | tr -d ' ')"
+if [ "$actual_size" != "$size" ]; then
+  echo "size mismatch: expected $size bytes, got $actual_size" >&2
+  exit 1
+fi
+
+mkdir -p "$dir"
+chmod 755 "$tmp/binary"
+# A rename, never a write over the file in place: anything else can leave a
+# half-written executable where a working one used to be.
+mv "$tmp/binary" "$dir/$binary"
+
+echo "installed $binary ${config.manifest.version} to $dir/$binary"
+case ":$PATH:" in
+  *":$dir:"*) ;;
+  *) echo "note: $dir is not on your PATH" >&2 ;;
+esac
+`;
+}
+function singleTarget(asset) {
+  return [
+    `url=${shellQuote(asset.url)}`,
+    `sha256=${shellQuote(asset.sha256)}`,
+    `size=${shellQuote(String(asset.size))}`,
+    `compression=${shellQuote(asset.compression)}`
+  ].join(`
+`);
+}
+function unameDispatch(assets) {
+  const cases = assets.map((asset) => `  ${asset.platform}/${asset.arch})
+    url=${shellQuote(asset.url)}
+    sha256=${shellQuote(asset.sha256)}
+    size=${shellQuote(String(asset.size))}
+    compression=${shellQuote(asset.compression)}
+    ;;`).join(`
+`);
+  const published = assets.map((asset) => `${asset.platform}/${asset.arch}`).join(", ");
+  return `case "$(uname -s)" in
+  Darwin) platform=darwin ;;
+  Linux) platform=linux ;;
+  *) platform="$(uname -s)" ;;
+esac
+case "$(uname -m)" in
+  x86_64|amd64) arch=x64 ;;
+  aarch64|arm64) arch=arm64 ;;
+  *) arch="$(uname -m)" ;;
+esac
+
+case "$platform/$arch" in
+${cases}
+  *)
+    echo "no published build for $platform/$arch — published: ${published}" >&2
+    exit 1
+    ;;
+esac`;
+}
+// src/tools/cli-manifest.ts
+import { z } from "zod";
+var CliBuildTargetSchema = z.object({
+  platform: z.string().min(1),
+  arch: z.string().min(1)
+});
+var CliBuildAssetSchema = CliBuildTargetSchema.extend({
+  url: z.url(),
+  compression: z.enum(["gzip", "none"]).default("none"),
+  size: z.int().positive(),
+  sha256: z.string().regex(/^[0-9a-f]{64}$/, "sha256 must be 64 lowercase hex characters")
+});
+var CliBuildManifestSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  commit: z.string().min(1),
+  builtAt: z.iso.datetime(),
+  assets: z.array(CliBuildAssetSchema)
+});
+var CliBuildStampSchema = z.object({
+  version: z.string().min(1),
+  commit: z.string().min(1),
+  builtAt: z.iso.datetime()
+});
+function formatCliBuildStamp(stamp, name) {
+  const prefix = name ? `${name} ` : "";
+  return `${prefix}${stamp.version} (${stamp.commit.slice(0, 12)}, built ${stamp.builtAt})`;
+}
+function currentCliBuildTarget() {
+  return { platform: process.platform, arch: process.arch };
+}
+function selectCliBuildAsset(manifest, target = currentCliBuildTarget()) {
+  return manifest.assets.find((asset) => asset.platform === target.platform && asset.arch === target.arch);
+}
+function assertCliPublishable(previous, next) {
+  if (!previous)
+    return;
+  if (previous.version !== next.version)
+    return;
+  if (previous.commit === next.commit)
+    return;
+  throw new Error(`[stitchkit] ${next.name} ${next.version} was already published from commit ${previous.commit}; ` + `refusing to republish it from ${next.commit} — bump the version instead`);
+}
+// src/tools/cli-profile.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { join } from "node:path";
+var PROFILE_SUFFIX = ".json";
+var FILE_MODE = 384;
+var DIRECTORY_MODE = 448;
+
+class CliProfileError extends AppError {
+  constructor(message, code = "NOT_FOUND") {
+    super(code, message, code === "NOT_FOUND" ? 404 : code === "FORBIDDEN" ? 403 : 400);
+    this.name = "CliProfileError";
+  }
+}
+function assertProfileName(name) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) {
+    throw new CliProfileError(`"${name}" is not a usable profile name — letters, digits, dot, dash and underscore`, "BAD_REQUEST");
+  }
+}
+function createCliProfileStore(config) {
+  const announce = config.announce ?? ((line) => process.stderr.write(`${line}
+`));
+  const pathFor = (name) => {
+    assertProfileName(name);
+    return join(config.directory, `${name}${PROFILE_SUFFIX}`);
+  };
+  const list = () => {
+    if (!existsSync(config.directory))
+      return [];
+    return readdirSync(config.directory).filter((entry) => entry.endsWith(PROFILE_SUFFIX)).map((entry) => entry.slice(0, -PROFILE_SUFFIX.length)).sort();
+  };
+  const read = (name) => {
+    const path = pathFor(name);
+    if (!existsSync(path)) {
+      throw new CliProfileError(missingMessage(name, path, config));
+    }
+    const mode = statSync(path).mode & 63;
+    if (mode !== 0) {
+      throw new CliProfileError(`profile "${name}" is readable by other users — run: chmod 600 ${path}`, "FORBIDDEN");
+    }
+    const parsed = safeJsonParse(readFileSync(path, "utf8"));
+    const result = config.schema.safeParse(parsed);
+    if (!result.success) {
+      const issue = result.error.issues[0];
+      const field = issue?.path.join(".");
+      throw new CliProfileError(`profile "${name}" (${path}) is not usable: ${field ? `${field}: ` : ""}${issue?.message ?? "invalid"}`, "BAD_REQUEST");
+    }
+    return result.data;
+  };
+  return {
+    directory: config.directory,
+    pathFor,
+    list,
+    read,
+    write(name, value) {
+      const path = pathFor(name);
+      mkdirSync(config.directory, { recursive: true, mode: DIRECTORY_MODE });
+      writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, { mode: FILE_MODE });
+      chmodSync(path, FILE_MODE);
+      return path;
+    },
+    resolve(name) {
+      if (name !== undefined) {
+        const path = pathFor(name);
+        return { name, path, value: read(name), substituted: false };
+      }
+      const configured = list();
+      const only = configured[0];
+      if (configured.length === 1 && only !== undefined) {
+        const path = pathFor(only);
+        announce(`[${only}] using the only configured profile (${path})`);
+        return { name: only, path, value: read(only), substituted: true };
+      }
+      if (configured.length === 0) {
+        const example = join(config.directory, `<name>${PROFILE_SUFFIX}`);
+        throw new CliProfileError(`no profile is configured in ${config.directory}${config.createHint ? ` — ${config.createHint("<name>", example)}` : ""}`);
+      }
+      throw new CliProfileError(`several profiles are configured (${configured.join(", ")}) — name one`, "BAD_REQUEST");
+    }
+  };
+}
+function missingMessage(name, path, config) {
+  const hint = config.createHint ? ` — ${config.createHint(name, path)}` : "";
+  return `profile "${name}" is not configured; expected ${path}${hint}`;
+}
+// src/tools/cli-update.ts
+import { createHash } from "node:crypto";
+import { chmodSync as chmodSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename, dirname, join as join2 } from "node:path";
+import { gunzipSync } from "node:zlib";
+var DEFAULT_CHECK_TIMEOUT_MS = 2000;
+var DEFAULT_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+var DEFAULT_DOWNLOAD_TIMEOUT_MS = 120000;
+var MANIFEST_MAX_BYTES = 256 * 1024;
+var DEFAULT_MAX_ASSET_BYTES = 256 * 1024 * 1024;
+function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(value.trim());
+  if (!match)
+    return;
+  const numbers = [match[1], match[2], match[3]].map((part) => Number(part));
+  if (numbers.some((part) => !Number.isFinite(part)))
+    return;
+  return { numbers, prerelease: match[4] };
+}
+function compareCliVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b)
+    return;
+  for (let index = 0;index < 3; index++) {
+    const difference = (a.numbers[index] ?? 0) - (b.numbers[index] ?? 0);
+    if (difference !== 0)
+      return difference < 0 ? -1 : 1;
+  }
+  if (a.prerelease === b.prerelease)
+    return 0;
+  if (a.prerelease === undefined)
+    return 1;
+  if (b.prerelease === undefined)
+    return -1;
+  return a.prerelease < b.prerelease ? -1 : 1;
+}
+async function checkCliUpdate(config) {
+  const now = config.now ?? Date.now();
+  const interval = config.intervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
+  if (config.lastCheckedAt !== undefined && now - config.lastCheckedAt < interval) {
+    return { status: "skipped", nextCheckAt: config.lastCheckedAt + interval };
+  }
+  try {
+    const response = await fetchGuarded(new URL(config.manifestUrl), config.allowPrivateHosts ?? false, {
+      timeoutMs: config.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS,
+      bodyTimeoutMs: config.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS
+    });
+    if (!response.ok)
+      return { status: "unknown", reason: `manifest responded ${response.status}` };
+    const body = await readCapped(response, MANIFEST_MAX_BYTES);
+    if (!body)
+      return { status: "unknown", reason: "manifest is larger than expected" };
+    const parsed = CliBuildManifestSchema.safeParse(JSON.parse(body.toString("utf8")));
+    if (!parsed.success)
+      return { status: "unknown", reason: "manifest did not validate" };
+    const manifest = parsed.data;
+    const order = compareCliVersions(config.currentVersion, manifest.version);
+    if (order === undefined) {
+      return {
+        status: "unknown",
+        reason: `cannot compare ${config.currentVersion} with ${manifest.version}`
+      };
+    }
+    if (order >= 0)
+      return { status: "current", version: manifest.version };
+    const asset = selectCliBuildAsset(manifest, config.target ?? currentCliBuildTarget());
+    return {
+      status: "outdated",
+      version: manifest.version,
+      manifest,
+      ...asset && { asset }
+    };
+  } catch (error) {
+    return {
+      status: "unknown",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function applyCliUpdate(config) {
+  const target = config.targetPath ?? process.execPath;
+  const response = await fetchGuarded(new URL(config.asset.url), config.allowPrivateHosts ?? false, {
+    timeoutMs: config.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS,
+    bodyTimeoutMs: config.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS
+  });
+  if (!response.ok) {
+    throw new Error(`[stitchkit] update download responded ${response.status}`);
+  }
+  const transferred = await readCapped(response, config.maxBytes ?? DEFAULT_MAX_ASSET_BYTES);
+  if (!transferred)
+    throw new Error("[stitchkit] update download exceeded the size ceiling");
+  const bytes = config.asset.compression === "gzip" ? gunzipSync(transferred) : transferred;
+  if (bytes.length !== config.asset.size) {
+    throw new Error(`[stitchkit] update is ${bytes.length} bytes, manifest says ${config.asset.size} — refusing to install it`);
+  }
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  if (sha256 !== config.asset.sha256) {
+    throw new Error(`[stitchkit] update digest ${sha256} does not match the manifest — refusing to install it`);
+  }
+  const staged = join2(dirname(target), `.${basename(target)}.${process.pid}.${Date.now()}`);
+  writeFileSync2(staged, bytes, { mode: 493 });
+  chmodSync2(staged, 493);
+  renameSync(staged, target);
+  return { path: target, bytes: bytes.length, sha256 };
+}
 export {
+  selectCliBuildAsset,
+  routeCliArgv,
+  renderCliView,
+  renderCliInstaller,
   pollUntilDone,
   parseCliArgs,
+  formatCliBuildStamp,
+  extractCliGlobalOptions,
   emitResult,
   defineCliCommand,
+  currentCliBuildTarget,
+  createCliProfileStore,
   createCli,
-  DEFAULT_EXIT_CODES
+  compareCliVersions,
+  coerceJsonArgs,
+  checkCliUpdate,
+  assertCliPublishable,
+  applyCliUpdate,
+  DEFAULT_EXIT_CODES,
+  CliProfileError,
+  CliBuildTargetSchema,
+  CliBuildStampSchema,
+  CliBuildManifestSchema,
+  CliBuildAssetSchema,
+  CliArgumentError
 };

package/dist/{index-2hrfpw2c.js → index-1bnkzq95.js}

@@ -1,12 +1,12 @@
 import {
   executeToolMethod
-} from "./index-44ht2790.js";
+} from "./index-8pjqv3zh.js";
 import {
   assertToolExtensionCompatible,
   mergeSchemas,
   projectToolSurface,
   rebuildObject
-} from "./index-r159gjwy.js";
+} from "./index-fenaekmk.js";
 
 // src/tools/mount.ts
 import { z } from "zod";

package/dist/{index-j7q0xj6d.js → index-3yqgj323.js}

@@ -18,13 +18,13 @@ import {
   probeAgentProcessSandbox,
   refuseMissingCodingPath
 } from "./index-gte38nbm.js";
+import {
+  defineRuntimeTool
+} from "./index-8z9we758.js";
 import {
   conflict,
   forbidden
 } from "./index-scs3f1eg.js";
-import {
-  defineRuntimeTool
-} from "./index-kc6h6hg0.js";
 
 // src/agent-runtime/coding-tool-contract.ts
 import { z } from "zod";

package/dist/{index-gbqjt8jz.js → index-83fafqw8.js}

@@ -4,16 +4,16 @@ import {
 } from "./index-7rkhw9ec.js";
 import {
   collectToolSurface
-} from "./index-wb15909q.js";
+} from "./index-zsdgd1tz.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-2hrfpw2c.js";
+} from "./index-1bnkzq95.js";
 import {
   isToolExecutionControlError,
   toolCauseFromResult,
   toolResultFromError
-} from "./index-44ht2790.js";
+} from "./index-8pjqv3zh.js";
 import {
   isRecord
 } from "./index-77fekveh.js";

package/dist/{index-44ht2790.js → index-8pjqv3zh.js}

@@ -7,20 +7,20 @@ import {
   normalizeError,
   validateDeclaredOutput
 } from "./index-2hryh65w.js";
+import {
+  coerceJsonArgs
+} from "./index-7zbps32p.js";
+import {
+  objectShapeKeys
+} from "./index-fenaekmk.js";
 import {
   AppError,
   STITCH_ERROR_STATUS,
   isStitchErrorCode
 } from "./index-scs3f1eg.js";
-import {
-  coerceJsonArgs
-} from "./index-7zbps32p.js";
 import {
   isUnsafeKey
 } from "./index-kzfs85xp.js";
-import {
-  objectShapeKeys
-} from "./index-r159gjwy.js";
 import {
   isRecord
 } from "./index-77fekveh.js";

package/dist/{index-kc6h6hg0.js → index-8z9we758.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-r159gjwy.js";
+} from "./index-fenaekmk.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool(definition) {

package/dist/{index-r159gjwy.js → index-fenaekmk.js}

@@ -667,6 +667,40 @@ function assertUniqueToolName(name, taken, surface) {
 
 // src/tools/presentation.ts
 import { z as z2 } from "zod";
+
+// src/tools/json-schema-dialect.ts
+var DRAFT_07_MARKER = "draft-07";
+var DRAFT_07_KEYWORD = "definitions";
+var DEFS_KEYWORD = "$defs";
+function declaresDraft07(dialect) {
+  return typeof dialect === "string" && dialect.includes(DRAFT_07_MARKER);
+}
+function rewriteDefinitionPointers(value) {
+  if (Array.isArray(value))
+    return value.map(rewriteDefinitionPointers);
+  if (!isRecord(value))
+    return value;
+  const rewritten = {};
+  for (const [key, child] of Object.entries(value)) {
+    rewritten[key] = key === "$ref" && typeof child === "string" && child.startsWith(`#/${DRAFT_07_KEYWORD}/`) ? `#/${DEFS_KEYWORD}/${child.slice(`#/${DRAFT_07_KEYWORD}/`.length)}` : rewriteDefinitionPointers(child);
+  }
+  return rewritten;
+}
+function withDefsDialect(schema) {
+  const definitions = schema[DRAFT_07_KEYWORD];
+  if (!isRecord(definitions) || DEFS_KEYWORD in schema)
+    return schema;
+  const rewritten = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === DRAFT_07_KEYWORD)
+      continue;
+    rewritten[key] = rewriteDefinitionPointers(value);
+  }
+  rewritten[DEFS_KEYWORD] = rewriteDefinitionPointers(definitions);
+  return rewritten;
+}
+
+// src/tools/presentation.ts
 function withoutDialect(schema) {
   const result = {};
   for (const [key, value] of Object.entries(schema)) {
@@ -684,25 +718,59 @@ function hasLocalReference(value) {
     return true;
   return Object.values(value).some(hasLocalReference);
 }
-function rewriteLocalReferences(value, namespace) {
+var NAMESPACE_SEPARATOR = "__";
+var DEFINITION_KEYWORDS = ["definitions", "$defs"];
+function rewriteReference(reference, namespace, targets) {
+  if (reference === "#" || reference === "#/") {
+    targets.rootReferenced = true;
+    return `#/definitions/${namespace}`;
+  }
+  const segments = reference.slice(2).split("/");
+  const [keyword, name, ...rest] = segments;
+  if (keyword !== undefined && name !== undefined && DEFINITION_KEYWORDS.includes(keyword)) {
+    const renamed = `${namespace}${NAMESPACE_SEPARATOR}${name}`;
+    return ["#", "definitions", renamed, ...rest].join("/");
+  }
+  targets.rootReferenced = true;
+  return `#/definitions/${namespace}/${segments.join("/")}`;
+}
+function rewriteLocalReferences(value, namespace, targets) {
   if (Array.isArray(value)) {
-    return value.map((child) => rewriteLocalReferences(child, namespace));
+    return value.map((child) => rewriteLocalReferences(child, namespace, targets));
   }
   if (!isRecord(value))
     return value;
   const rewritten = {};
   for (const [key, child] of Object.entries(value)) {
-    rewritten[key] = key === "$ref" && typeof child === "string" && child.startsWith("#") ? `#/definitions/${namespace}${child.slice(1)}` : rewriteLocalReferences(child, namespace);
+    rewritten[key] = key === "$ref" && typeof child === "string" && child.startsWith("#") ? rewriteReference(child, namespace, targets) : rewriteLocalReferences(child, namespace, targets);
   }
   return rewritten;
 }
 function namespaceLocalReferences(schema, namespace) {
   if (!schema || !hasLocalReference(schema))
     return schema;
-  const rewritten = rewriteLocalReferences(schema, namespace);
+  const targets = { rootReferenced: false };
+  const rewritten = rewriteLocalReferences(schema, namespace, targets);
   if (!isRecord(rewritten))
     return schema;
-  return { ...rewritten, definitions: { [namespace]: rewritten } };
+  const definitions = {};
+  const body = {};
+  for (const [key, value] of Object.entries(rewritten)) {
+    if (DEFINITION_KEYWORDS.includes(key)) {
+      if (isRecord(value)) {
+        for (const [name, definition] of Object.entries(value)) {
+          definitions[`${namespace}${NAMESPACE_SEPARATOR}${name}`] = definition;
+        }
+      }
+      continue;
+    }
+    body[key] = value;
+  }
+  if (targets.rootReferenced)
+    definitions[namespace] = withoutDialect(body);
+  if (Object.keys(definitions).length === 0)
+    return body;
+  return { ...body, definitions };
 }
 function objectProperties(schema) {
   return schema.type === "object" && isRecord(schema.properties) ? schema.properties : null;
@@ -710,11 +778,29 @@ function objectProperties(schema) {
 function requiredKeys2(schema) {
   return Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === "string") : [];
 }
+function hoistDefinitions(schema) {
+  const branches = Array.isArray(schema.allOf) ? schema.allOf : [];
+  const definitions = {};
+  const lifted = branches.map((branch) => {
+    if (!isRecord(branch) || !isRecord(branch.definitions))
+      return branch;
+    Object.assign(definitions, branch.definitions);
+    const rest = {};
+    for (const [key, value] of Object.entries(branch)) {
+      if (key !== "definitions")
+        rest[key] = value;
+    }
+    return rest;
+  });
+  if (Object.keys(definitions).length === 0)
+    return schema;
+  return { ...schema, allOf: lifted, definitions };
+}
 function mergeObjectSchemas(left, right, rightOwnsUnknownKeys) {
   const leftProperties = objectProperties(left);
   const rightProperties = objectProperties(right);
   if (!leftProperties || !rightProperties)
-    return { allOf: [left, right] };
+    return hoistDefinitions({ allOf: [left, right] });
   const conflicts = Object.keys(leftProperties).filter((key) => (key in rightProperties));
   if (conflicts.length > 0) {
     throw new Error(`Schema merge conflict: ${conflicts.join(", ")} appear in both params and input`);
@@ -777,7 +863,7 @@ function isObjectPresentationSchema(schema) {
   return schema.type === "object" && isRecord(schema.properties);
 }
 function presentationMetadata(schema) {
-  return withoutDialect(schema);
+  return withDefsDialect(withoutDialect(schema));
 }
 
 // src/tools/internal/surface-projector.ts
@@ -1027,4 +1113,4 @@ function prepareProjectedMcpTools(tools, config = {}) {
   return prepared;
 }
 
-export { objectShapeKeys, rebuildObject, mergeSchemas, validateMcpRoundPolicy, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };
+export { objectShapeKeys, rebuildObject, mergeSchemas, validateMcpRoundPolicy, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, declaresDraft07, withDefsDialect, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };