stitchkit 0.55.0 → 0.56.0

package/dist/index-6y759j86.js

@@ -0,0 +1,1031 @@
+import {
+  toJsonSchema
+} from "./index-cby4ar3v.js";
+import {
+  isRecord
+} from "./index-7eq9va6e.js";
+
+// src/tools/portable-formats.ts
+var PORTABLE_JSON_SCHEMA_FORMATS = new Set([
+  "date",
+  "time",
+  "date-time",
+  "duration",
+  "uri",
+  "uri-reference",
+  "uri-template",
+  "email",
+  "hostname",
+  "ipv4",
+  "ipv6",
+  "regex",
+  "uuid",
+  "json-pointer",
+  "relative-json-pointer"
+]);
+function propertyPath(prefix, property) {
+  return prefix ? `${prefix}.${property}` : property;
+}
+function keywordPath(prefix, keyword) {
+  if (prefix && keyword.startsWith("["))
+    return `${prefix}${keyword}`;
+  return prefix ? `${prefix}.${keyword}` : keyword;
+}
+function findNonPortableFormats(schema, allowFormats = []) {
+  const allowed = new Set([...PORTABLE_JSON_SCHEMA_FORMATS, ...allowFormats]);
+  const found = [];
+  const pending = [{ value: schema, path: "" }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || !isRecord(current.value))
+      continue;
+    const format = current.value.format;
+    if (typeof format === "string" && !allowed.has(format)) {
+      found.push({ path: current.path || "(root)", format });
+    }
+    const properties = current.value.properties;
+    if (isRecord(properties)) {
+      for (const [key, value] of Object.entries(properties)) {
+        pending.push({ value, path: propertyPath(current.path, key) });
+      }
+    }
+    for (const mapKey of ["$defs", "definitions", "patternProperties", "dependentSchemas"]) {
+      const entries = current.value[mapKey];
+      if (!isRecord(entries))
+        continue;
+      for (const [key, value] of Object.entries(entries)) {
+        pending.push({ value, path: keywordPath(current.path, `${mapKey}.${key}`) });
+      }
+    }
+    const directChildren = [
+      ["items", "[]"],
+      ["contains", "contains"],
+      ["additionalProperties", "*"],
+      ["unevaluatedProperties", "*"],
+      ["propertyNames", "propertyNames"],
+      ["not", "not"],
+      ["if", "if"],
+      ["then", "then"],
+      ["else", "else"]
+    ];
+    for (const [keyword, segment] of directChildren) {
+      const child = current.value[keyword];
+      if (isRecord(child)) {
+        pending.push({ value: child, path: keywordPath(current.path, segment) });
+      }
+      if (Array.isArray(child)) {
+        child.forEach((value, index) => {
+          pending.push({ value, path: keywordPath(current.path, `${segment}[${index}]`) });
+        });
+      }
+    }
+    for (const keyword of ["prefixItems", "allOf", "anyOf", "oneOf"]) {
+      const branches = current.value[keyword];
+      if (!Array.isArray(branches))
+        continue;
+      branches.forEach((value, index) => {
+        pending.push({ value, path: keywordPath(current.path, `${keyword}[${index}]`) });
+      });
+    }
+  }
+  return found.sort((left, right) => left.path.localeCompare(right.path) || left.format.localeCompare(right.format));
+}
+
+// src/tools/flatten-join.ts
+var ANNOTATION_KEYS = new Set(["$schema", "default", "description", "examples", "title"]);
+var TYPE_KEYWORDS = {
+  array: [
+    "contains",
+    "items",
+    "maxContains",
+    "maxItems",
+    "minContains",
+    "minItems",
+    "prefixItems",
+    "uniqueItems"
+  ],
+  integer: ["exclusiveMaximum", "exclusiveMinimum", "maximum", "minimum", "multipleOf"],
+  number: ["exclusiveMaximum", "exclusiveMinimum", "maximum", "minimum", "multipleOf"],
+  object: [
+    "additionalProperties",
+    "dependentRequired",
+    "dependentSchemas",
+    "maxProperties",
+    "minProperties",
+    "patternProperties",
+    "properties",
+    "propertyNames",
+    "required"
+  ],
+  string: [
+    "contentEncoding",
+    "contentMediaType",
+    "format",
+    "maxLength",
+    "minLength",
+    "pattern"
+  ]
+};
+function nullableProjection(schema) {
+  if (!Array.isArray(schema.anyOf) || schema.anyOf.length !== 2)
+    return schema;
+  const branches = schema.anyOf.filter(isRecord);
+  if (branches.length !== 2)
+    return schema;
+  const nullBranch = branches.find((branch) => branch.type === "null");
+  const value = branches.find((branch) => typeof branch.type === "string" && branch.type !== "null");
+  if (!nullBranch || !value || Object.keys(nullBranch).some((key) => key !== "type")) {
+    return schema;
+  }
+  const type = value.type;
+  if (typeof type !== "string")
+    return schema;
+  const projected = { type: [type, "null"] };
+  for (const key of [...ANNOTATION_KEYS, ...TYPE_KEYWORDS[type] ?? []]) {
+    if (value[key] !== undefined)
+      projected[key] = value[key];
+    else if (schema[key] !== undefined)
+      projected[key] = schema[key];
+  }
+  if (value.const !== undefined)
+    projected.enum = [value.const, null];
+  else if (Array.isArray(value.enum))
+    projected.enum = [...value.enum, null];
+  return projected;
+}
+function withoutAnnotations(schema) {
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (!ANNOTATION_KEYS.has(key))
+      result[key] = value;
+  }
+  return result;
+}
+function stableJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  if (!isRecord(value))
+    return JSON.stringify(value) ?? "undefined";
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+}
+function stringValues(schema) {
+  if (typeof schema.const === "string")
+    return [schema.const];
+  if (!Array.isArray(schema.enum))
+    return null;
+  const values = schema.enum.filter((value) => typeof value === "string");
+  return values.length === schema.enum.length ? values : null;
+}
+var JSON_SCHEMA_TYPE_ORDER = [
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null"
+];
+function jsonSchemaType(value) {
+  switch (value) {
+    case "array":
+    case "boolean":
+    case "integer":
+    case "null":
+    case "number":
+    case "object":
+    case "string":
+      return value;
+    default:
+      return null;
+  }
+}
+function valueType(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  if (isRecord(value))
+    return "object";
+  if (typeof value === "string")
+    return "string";
+  if (typeof value === "number")
+    return "number";
+  if (typeof value === "boolean")
+    return "boolean";
+  return null;
+}
+function normalizeTypes(types) {
+  const normalized = new Set(types);
+  if (normalized.has("number"))
+    normalized.delete("integer");
+  return JSON_SCHEMA_TYPE_ORDER.filter((type) => normalized.has(type));
+}
+function combinedBranchTypes(schema) {
+  for (const keyword of ["oneOf", "anyOf"]) {
+    const value = schema[keyword];
+    if (!Array.isArray(value) || value.length === 0)
+      continue;
+    const collected = [];
+    for (const branch of value) {
+      if (!isRecord(branch))
+        return null;
+      const types = typeNames(branch);
+      if (!types)
+        return null;
+      collected.push(...types);
+    }
+    return normalizeTypes(collected);
+  }
+  return null;
+}
+function typeNames(schema) {
+  const direct = jsonSchemaType(schema.type);
+  if (direct)
+    return [direct];
+  if (Array.isArray(schema.type)) {
+    const values = [];
+    for (const value of schema.type) {
+      const type = jsonSchemaType(value);
+      if (!type)
+        return null;
+      values.push(type);
+    }
+    return values.length > 0 ? normalizeTypes(values) : null;
+  }
+  if (schema.const !== undefined) {
+    const type = valueType(schema.const);
+    return type ? [type] : null;
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const values = [];
+    for (const value of schema.enum) {
+      const type = valueType(value);
+      if (!type)
+        return null;
+      values.push(type);
+    }
+    return normalizeTypes(values);
+  }
+  return combinedBranchTypes(schema);
+}
+function typeSchema(type, nullable) {
+  const schema = { type: nullable ? [type, "null"] : type };
+  if (type === "array")
+    schema.items = {};
+  if (type === "object")
+    schema.additionalProperties = {};
+  return schema;
+}
+function commonBaseType(schemas) {
+  const names = schemas.map(typeNames);
+  if (names.some((value) => value === null))
+    return {};
+  let nullable = false;
+  const bases = new Set;
+  for (const branch of names) {
+    if (!branch)
+      return {};
+    for (const name of branch) {
+      if (name === "null")
+        nullable = true;
+      else
+        bases.add(name);
+    }
+  }
+  if (bases.size === 0)
+    return nullable ? { type: "null" } : {};
+  if (bases.size === 1) {
+    const [only] = bases;
+    return only ? typeSchema(only, nullable) : {};
+  }
+  if ([...bases].every((name) => name === "integer" || name === "number")) {
+    return typeSchema("number", nullable);
+  }
+  const types = normalizeTypes(nullable ? [...bases, "null"] : bases);
+  return types.length > 0 ? { type: types } : {};
+}
+function mergePropertySchemas(properties) {
+  const schemas = properties.map((property) => nullableProjection(property.schema));
+  const structural = schemas.map(withoutAnnotations);
+  const [first] = structural;
+  let merged;
+  if (first && structural.every((schema) => stableJson(schema) === stableJson(first))) {
+    merged = structuredClone(first);
+  } else {
+    const values = schemas.map(stringValues);
+    const allStrings = values.every((value) => value !== null);
+    merged = allStrings ? { type: "string", enum: [...new Set(values.flatMap((value) => value ?? []))] } : commonBaseType(schemas);
+  }
+  const descriptions = [
+    ...new Set(schemas.map((schema) => schema.description).filter((value) => typeof value === "string"))
+  ];
+  if (descriptions.length === 1)
+    merged.description = descriptions[0];
+  return merged;
+}
+
+// src/tools/flatten.ts
+function rebuild(value) {
+  if (Array.isArray(value))
+    return value.map(rebuild);
+  if (!isRecord(value))
+    return value;
+  const node = {};
+  for (const [key, child] of Object.entries(value))
+    node[key] = rebuild(child);
+  return flattenNode(node);
+}
+function stringValues2(schema) {
+  if (typeof schema.const === "string")
+    return [schema.const];
+  if (!Array.isArray(schema.enum))
+    return null;
+  const values = schema.enum.filter((value) => typeof value === "string");
+  return values.length === schema.enum.length ? values : null;
+}
+function objectVariants(node) {
+  if (!Array.isArray(node.oneOf) || node.oneOf.length < 2)
+    return null;
+  const variants = node.oneOf.filter(isRecord);
+  if (variants.length !== node.oneOf.length)
+    return null;
+  if (variants.some((variant) => variant.type !== "object" || !isRecord(variant.properties))) {
+    return null;
+  }
+  return variants;
+}
+function findDiscriminator(variants) {
+  const [first] = variants;
+  if (!first || !isRecord(first.properties))
+    return null;
+  for (const key of Object.keys(first.properties).sort()) {
+    const values = [];
+    const seen = new Set;
+    let valid = true;
+    for (const variant of variants) {
+      if (!requiredKeys(variant).has(key)) {
+        valid = false;
+        break;
+      }
+      const properties = variant.properties;
+      const field = isRecord(properties) ? properties[key] : undefined;
+      const branchValues = isRecord(field) ? stringValues2(field) : null;
+      if (!branchValues || branchValues.length === 0) {
+        valid = false;
+        break;
+      }
+      for (const value of branchValues) {
+        if (seen.has(value)) {
+          valid = false;
+          break;
+        }
+        seen.add(value);
+      }
+      if (!valid)
+        break;
+      values.push(branchValues);
+    }
+    if (valid)
+      return { key, values };
+  }
+  return null;
+}
+function requiredKeys(variant) {
+  if (!Array.isArray(variant.required))
+    return new Set;
+  return new Set(variant.required.filter((key) => typeof key === "string"));
+}
+function appendHint(schema, hint) {
+  const description = typeof schema.description === "string" ? schema.description : undefined;
+  return { ...schema, description: description ? `${description} ${hint}` : hint };
+}
+function flattenNode(node) {
+  const variants = objectVariants(node);
+  if (!variants)
+    return node;
+  const discriminator = findDiscriminator(variants);
+  if (!discriminator)
+    return node;
+  const perKey = new Map;
+  for (let index = 0;index < variants.length; index++) {
+    const variant = variants[index];
+    if (!variant)
+      continue;
+    const labels = discriminator.values[index] ?? [];
+    const required2 = requiredKeys(variant);
+    if (!isRecord(variant.properties))
+      continue;
+    for (const [key, rawSchema] of Object.entries(variant.properties)) {
+      if (key === discriminator.key || !isRecord(rawSchema))
+        continue;
+      const entries = perKey.get(key) ?? [];
+      entries.push({ schema: rawSchema, labels, required: required2.has(key) });
+      perKey.set(key, entries);
+    }
+  }
+  const discriminatorProperties = [];
+  for (let index = 0;index < variants.length; index++) {
+    const variant = variants[index];
+    if (!variant || !isRecord(variant.properties))
+      continue;
+    const schema = variant.properties[discriminator.key];
+    if (!isRecord(schema))
+      continue;
+    discriminatorProperties.push({
+      schema,
+      labels: discriminator.values[index] ?? [],
+      required: true
+    });
+  }
+  const properties = {
+    [discriminator.key]: mergePropertySchemas(discriminatorProperties)
+  };
+  const required = [discriminator.key];
+  for (const [key, entries] of perKey) {
+    let merged = mergePropertySchemas(entries);
+    const requiredEverywhere = entries.length === variants.length && entries.every((entry) => entry.required);
+    if (requiredEverywhere) {
+      required.push(key);
+    } else {
+      const requiredLabels = entries.filter((entry) => entry.required).flatMap((entry) => entry.labels);
+      const presentLabels = entries.flatMap((entry) => entry.labels);
+      const labels = requiredLabels.length > 0 ? requiredLabels : presentLabels;
+      const verb = requiredLabels.length > 0 ? "Required" : "Available";
+      merged = appendHint(merged, `${verb} if ${discriminator.key} = ${[...new Set(labels)].join(" | ")}`);
+    }
+    properties[key] = merged;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key !== "oneOf" && key !== "anyOf" && key !== "properties" && key !== "required") {
+      result[key] = value;
+    }
+  }
+  result.type = "object";
+  result.properties = properties;
+  result.required = required;
+  result.additionalProperties = variants.every((variant) => variant.additionalProperties === false) ? false : {};
+  return result;
+}
+function flattenToolJsonSchema(schema) {
+  const result = rebuild(schema);
+  return isRecord(result) ? result : {};
+}
+function freezeToolJsonSchema(schema) {
+  for (const value of Object.values(schema))
+    freezeJsonValue(value);
+  return Object.freeze(schema);
+}
+function freezeJsonValue(value) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      freezeJsonValue(item);
+    Object.freeze(value);
+  } else if (isRecord(value)) {
+    freezeToolJsonSchema(value);
+  }
+}
+
+// src/tools/untyped-properties.ts
+var TYPE_KEYWORDS2 = ["type", "enum", "const", "anyOf", "oneOf", "allOf", "$ref", "not"];
+function saysWhatItIs(schema) {
+  return TYPE_KEYWORDS2.some((keyword) => schema[keyword] !== undefined);
+}
+function findUntypedProperties(schema, prefix = "") {
+  if (!isRecord(schema))
+    return [];
+  const found = [];
+  const properties = schema.properties;
+  if (isRecord(properties)) {
+    for (const [key, value] of Object.entries(properties)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (isRecord(value)) {
+        if (!saysWhatItIs(value)) {
+          const description = value.description;
+          found.push({
+            path,
+            ...typeof description === "string" && { description }
+          });
+        }
+        found.push(...findUntypedProperties(value, path));
+      }
+    }
+  }
+  for (const key of ["items", "additionalProperties"]) {
+    const child = schema[key];
+    if (isRecord(child))
+      found.push(...findUntypedProperties(child, prefix));
+    if (Array.isArray(child)) {
+      for (const entry of child) {
+        if (isRecord(entry))
+          found.push(...findUntypedProperties(entry, prefix));
+      }
+    }
+  }
+  for (const key of ["prefixItems"]) {
+    const child = schema[key];
+    if (Array.isArray(child)) {
+      for (const entry of child) {
+        if (isRecord(entry))
+          found.push(...findUntypedProperties(entry, prefix));
+      }
+    }
+  }
+  const patterned = schema.patternProperties;
+  if (isRecord(patterned)) {
+    for (const value of Object.values(patterned)) {
+      if (isRecord(value))
+        found.push(...findUntypedProperties(value, prefix));
+    }
+  }
+  for (const key of ["$defs", "definitions"]) {
+    const container = schema[key];
+    if (!isRecord(container))
+      continue;
+    for (const definition of Object.values(container)) {
+      if (isRecord(definition))
+        found.push(...findUntypedProperties(definition, prefix));
+    }
+  }
+  for (const key of ["allOf", "anyOf", "oneOf"]) {
+    const branches = schema[key];
+    if (Array.isArray(branches)) {
+      for (const branch of branches)
+        found.push(...findUntypedProperties(branch, prefix));
+    }
+  }
+  return found;
+}
+
+// src/tools/schema.ts
+import { z } from "zod";
+function objectShapeKeys(schema) {
+  return schema instanceof z.ZodObject ? Object.keys(schema.shape) : [];
+}
+function keyPolicyOf(schema) {
+  return schema.def.catchall;
+}
+function rebuildObject(source, shape) {
+  return withKeyPolicy(z.object(shape), keyPolicyOf(source));
+}
+function withKeyPolicy(object, policy) {
+  if (policy === undefined)
+    return object;
+  return object.catchall(representable(policy));
+}
+function representable(policy) {
+  if (policy instanceof z.ZodNever || policy instanceof z.ZodUnknown)
+    return policy;
+  if (!(policy instanceof z.ZodType))
+    return z.unknown();
+  try {
+    toJsonSchema(policy, "input");
+    return policy;
+  } catch {
+    return z.unknown();
+  }
+}
+function mergeSchemas(paramsSchema, inputSchema) {
+  if (paramsSchema && !(paramsSchema instanceof z.ZodObject)) {
+    throw new Error("Tool params schema must be a z.object()");
+  }
+  const paramsObject = paramsSchema instanceof z.ZodObject ? paramsSchema : undefined;
+  if (!inputSchema) {
+    return paramsObject ?? z.object({});
+  }
+  if (inputSchema instanceof z.ZodObject) {
+    if (paramsObject) {
+      const conflicts = Object.keys(paramsObject.shape).filter((key) => (key in inputSchema.shape));
+      if (conflicts.length > 0) {
+        throw new Error(`Schema merge conflict: ${conflicts.join(", ")} appear in both params and input`);
+      }
+    }
+    return rebuildObject(inputSchema, {
+      ...paramsObject?.shape ?? {},
+      ...inputSchema.shape
+    });
+  }
+  return paramsObject ? z.intersection(paramsObject, inputSchema) : inputSchema;
+}
+
+// src/tools/names.ts
+var SINGULAR_EXCEPTIONS = new Set([
+  "analytics",
+  "status",
+  "stats",
+  "settings",
+  "media",
+  "progress",
+  "news"
+]);
+var TOOL_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+function normalizeService(value) {
+  return value.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function normalizeMethod(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function singularize(name) {
+  if (SINGULAR_EXCEPTIONS.has(name))
+    return name;
+  if (name.endsWith("ies"))
+    return `${name.slice(0, -3)}y`;
+  if (name.endsWith("s") && !name.endsWith("ss"))
+    return name.slice(0, -1);
+  return name;
+}
+function singularizeTail(name) {
+  const cut = name.lastIndexOf("_");
+  if (cut === -1)
+    return singularize(name);
+  return `${name.slice(0, cut + 1)}${singularize(name.slice(cut + 1))}`;
+}
+function hasUsableChars(value) {
+  return /[a-zA-Z0-9]/.test(value);
+}
+function assertToolName(name, serviceName, key) {
+  const where = `service "${serviceName}", method "${key}"`;
+  if (!TOOL_NAME_RE.test(name)) {
+    const why = name.length > 64 ? `is ${name.length} characters (max 64) — set an explicit \`toolName\`` : "must match [a-zA-Z0-9_-]";
+    throw new Error(`Tool name "${name}" (${where}) ${why}`);
+  }
+}
+function toToolName(serviceName, methodName) {
+  const normalized = normalizeService(serviceName);
+  const singular = singularizeTail(normalized);
+  const method = normalizeMethod(methodName);
+  if (method === "list")
+    return `list_${normalized}`;
+  if (method === "get")
+    return `get_${singular}`;
+  if (method === "create")
+    return `create_${singular}`;
+  if (method === "update")
+    return `update_${singular}`;
+  if (method === "delete")
+    return `delete_${singular}`;
+  const snake = method.replace(/([A-Z])/g, "_$1").toLowerCase();
+  return `${snake}_${singular}`.replace(/^_/, "");
+}
+function assertUniqueToolName(name, taken, surface) {
+  if (taken) {
+    throw new Error(`Duplicate ${surface} "${name}" across mounted operations`);
+  }
+}
+
+// src/tools/presentation.ts
+import { z as z2 } from "zod";
+function withoutDialect(schema) {
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key !== "$schema")
+      result[key] = value;
+  }
+  return result;
+}
+function hasLocalReference(value) {
+  if (Array.isArray(value))
+    return value.some(hasLocalReference);
+  if (!isRecord(value))
+    return false;
+  if (typeof value.$ref === "string" && value.$ref.startsWith("#"))
+    return true;
+  return Object.values(value).some(hasLocalReference);
+}
+function rewriteLocalReferences(value, namespace) {
+  if (Array.isArray(value)) {
+    return value.map((child) => rewriteLocalReferences(child, namespace));
+  }
+  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);
+  }
+  return rewritten;
+}
+function namespaceLocalReferences(schema, namespace) {
+  if (!schema || !hasLocalReference(schema))
+    return schema;
+  const rewritten = rewriteLocalReferences(schema, namespace);
+  if (!isRecord(rewritten))
+    return schema;
+  return { ...rewritten, definitions: { [namespace]: rewritten } };
+}
+function objectProperties(schema) {
+  return schema.type === "object" && isRecord(schema.properties) ? schema.properties : null;
+}
+function requiredKeys2(schema) {
+  return Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === "string") : [];
+}
+function mergeObjectSchemas(left, right, rightOwnsUnknownKeys) {
+  const leftProperties = objectProperties(left);
+  const rightProperties = objectProperties(right);
+  if (!leftProperties || !rightProperties)
+    return { 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`);
+  }
+  const merged = {
+    type: "object",
+    properties: { ...leftProperties, ...rightProperties },
+    required: [...new Set([...requiredKeys2(left), ...requiredKeys2(right)])]
+  };
+  const leftDefinitions = isRecord(left.definitions) ? left.definitions : {};
+  const rightDefinitions = isRecord(right.definitions) ? right.definitions : {};
+  const definitions = { ...leftDefinitions, ...rightDefinitions };
+  if (Object.keys(definitions).length > 0)
+    merged.definitions = definitions;
+  const unknownKeys = rightOwnsUnknownKeys ? right.additionalProperties : left.additionalProperties;
+  if (unknownKeys !== undefined)
+    merged.additionalProperties = unknownKeys;
+  return merged;
+}
+function schemaFromZod(schema, unrepresentable, flatten) {
+  if (!schema)
+    return;
+  const json = toJsonSchema(schema, "input", unrepresentable, "draft-07");
+  return flatten ? flattenToolJsonSchema(json) : json;
+}
+function buildToolPresentationSchema(config) {
+  const unrepresentable = config.unrepresentable ?? "any";
+  const flatten = config.flattenUnionInput ?? false;
+  const params = namespaceLocalReferences(schemaFromZod(config.paramsSchema, unrepresentable, flatten), "params");
+  const input = namespaceLocalReferences(schemaFromZod(config.inputSchema, unrepresentable, flatten), "input");
+  let presentation;
+  if (params && input) {
+    presentation = mergeObjectSchemas(withoutDialect(params), withoutDialect(input), true);
+  } else if (input) {
+    presentation = input;
+  } else if (params) {
+    presentation = params;
+  } else {
+    presentation = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      properties: {}
+    };
+  }
+  if (config.extendSchema) {
+    const extra = namespaceLocalReferences(schemaFromZod(z2.object(config.extendSchema), unrepresentable, flatten), "extend");
+    if (extra) {
+      presentation = mergeObjectSchemas(withoutDialect(extra), withoutDialect(presentation), true);
+    }
+  }
+  if (presentation.$schema === undefined) {
+    presentation = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      ...presentation
+    };
+  }
+  return freezeToolJsonSchema(presentation);
+}
+function isObjectPresentationSchema(schema) {
+  return schema.type === "object" && isRecord(schema.properties);
+}
+function presentationMetadata(schema) {
+  return withoutDialect(schema);
+}
+
+// src/tools/internal/surface-projector.ts
+import { z as z3 } from "zod";
+
+// src/tools/mcp-round-policy.ts
+function validateMcpRoundPolicy(tool, policy, runtime) {
+  if (!runtime?.stateConfigured) {
+    throw new Error(`[stitchkit] MCP tool "${tool.name}" declares inputRequired but no multiRound.state key is configured`);
+  }
+  const { maxRounds } = runtime;
+  if (!Number.isInteger(maxRounds) || maxRounds < 1) {
+    throw new Error("[stitchkit] multiRound.serving.maxRounds must be a positive integer");
+  }
+  if (policy.inputRequired.length === 0) {
+    throw new Error(`[stitchkit] MCP tool "${tool.name}" must declare at least one input round`);
+  }
+  if (policy.inputRequired.length > maxRounds) {
+    throw new Error(`[stitchkit] MCP tool "${tool.name}" declares ${policy.inputRequired.length} input rounds, exceeding maxRounds ${maxRounds}`);
+  }
+  const keys = new Set;
+  for (const request of policy.inputRequired) {
+    if (keys.has(request.key)) {
+      throw new Error(`[stitchkit] MCP tool "${tool.name}" declares duplicate input key "${request.key}"`);
+    }
+    keys.add(request.key);
+  }
+}
+
+// src/tools/internal/surface-projector.ts
+function assertToolExtensionCompatible(base, extra) {
+  if (!(base instanceof z3.ZodObject))
+    return;
+  const conflicts = Object.keys(extra).filter((key) => (key in base.shape));
+  if (conflicts.length > 0) {
+    throw new Error(`Tool extend conflict: ${conflicts.join(", ")} already declared by the contract`);
+  }
+}
+function projectRuntimeTool(definition, assertName = true) {
+  if (assertName) {
+    assertProjectedName(definition.name, definition.identity.serviceName, definition.identity.action, "MCP", false);
+  }
+  return {
+    kind: "runtime",
+    source: definition,
+    serviceName: definition.identity.serviceName,
+    action: definition.identity.action,
+    name: definition.name,
+    presentationSchema: buildToolPresentationSchema({
+      inputSchema: definition.input,
+      unrepresentable: "any"
+    }),
+    shouldExtend: false,
+    ...definition.mcp !== undefined && { mcp: definition.mcp }
+  };
+}
+function projectedRuntimeToolSupports(definition, transport) {
+  if (definition.transports?.length === 0) {
+    throw new Error(`Runtime tool "${definition.name}" must expose at least one transport`);
+  }
+  return definition.transports ? definition.transports.includes(transport) : transport !== "CLI";
+}
+function duplicateLabel(transport) {
+  if (transport === "MCP")
+    return "MCP tool name";
+  if (transport === "AGENT")
+    return "agent tool name";
+  return "CLI command";
+}
+function assertProjectedName(name, serviceName, action, transport, derived) {
+  if (transport === "CLI")
+    return;
+  if (derived && !hasUsableChars(serviceName)) {
+    throw new Error(`Service prefix "${serviceName}" (method "${action}") has no characters usable in a tool name — set an explicit \`toolName\` or rename the prefix`);
+  }
+  assertToolName(name, serviceName, action);
+}
+function projectToolSurface(surface, transport, config = {}) {
+  const projected = [];
+  const names = new Set;
+  const append = (tool) => {
+    if (config.assertUniqueNames ?? true) {
+      assertUniqueToolName(tool.name, names.has(tool.name), duplicateLabel(transport));
+    }
+    names.add(tool.name);
+    projected.push(tool);
+  };
+  for (const service of surface.services ?? []) {
+    for (const [methodName, method] of Object.entries(service.methods)) {
+      if (transport === "CLI") {
+        if (!method.expose?.includes("CLI"))
+          continue;
+      } else if (method.expose && !method.expose.includes(transport)) {
+        continue;
+      }
+      if (method.multipart || method.rawBody || method.responseMeta || method.rawResponse) {
+        continue;
+      }
+      const name = method.toolName ?? toToolName(service.name, methodName);
+      if (config.assertNames ?? true) {
+        assertProjectedName(name, service.name, methodName, transport, !method.toolName);
+      }
+      const shouldExtend = transport !== "CLI" && config.extend !== undefined && (!config.extend.filter || config.extend.filter(service, method));
+      if (shouldExtend && config.extend) {
+        assertToolExtensionCompatible(mergeSchemas(method.paramsSchema, method.inputSchema), config.extend.schema);
+      }
+      append({
+        kind: "contract",
+        source: method,
+        serviceName: method.serviceName,
+        action: method.key,
+        name,
+        presentationSchema: buildToolPresentationSchema({
+          paramsSchema: method.paramsSchema,
+          inputSchema: method.inputSchema,
+          extendSchema: shouldExtend ? config.extend?.schema : undefined,
+          flattenUnionInput: config.flattenUnionInput,
+          unrepresentable: "any"
+        }),
+        shouldExtend,
+        ...method.mcp !== undefined && { mcp: method.mcp }
+      });
+    }
+  }
+  for (const definition of surface.runtimeTools ?? []) {
+    if (!projectedRuntimeToolSupports(definition, transport))
+      continue;
+    if (config.assertNames ?? true) {
+      assertProjectedName(definition.name, definition.identity.serviceName, definition.identity.action, transport, false);
+    }
+    append(projectRuntimeTool(definition, false));
+  }
+  return projected;
+}
+function mcpProjectionCandidate(tool) {
+  if (tool.kind === "contract") {
+    return {
+      tool,
+      name: tool.name,
+      ...tool.source.paramsSchema !== undefined && {
+        paramsSchema: tool.source.paramsSchema
+      },
+      ...tool.source.inputSchema !== undefined && {
+        inputSchema: tool.source.inputSchema
+      },
+      ...tool.source.outputSchema !== undefined && {
+        outputSchema: tool.source.outputSchema
+      },
+      shouldExtend: tool.shouldExtend,
+      ...tool.mcp !== undefined && { mcp: tool.mcp }
+    };
+  }
+  return {
+    tool,
+    name: tool.name,
+    inputSchema: tool.source.input,
+    ...tool.source.output !== undefined && { outputSchema: tool.source.output },
+    shouldExtend: false,
+    ...tool.mcp !== undefined && { mcp: tool.mcp }
+  };
+}
+function reportIncompatible(message, policy, logger, failures) {
+  if (policy === "throw")
+    failures.push(message);
+  else if (policy === "warn") {
+    if (logger)
+      logger.warn(`[stitchkit] ${message}`);
+    else
+      console.warn(`[stitchkit] ${message}`);
+  }
+}
+function prepareProjectedMcpTools(tools, config = {}) {
+  const policy = config.schemaValidation?.policy ?? "throw";
+  const failures = [];
+  const prepared = [];
+  const names = new Set;
+  for (const tool of tools) {
+    assertUniqueToolName(tool.name, names.has(tool.name), "MCP tool name");
+    names.add(tool.name);
+    if (tool.mcp)
+      validateMcpRoundPolicy(tool, tool.mcp, config.multiRound);
+    let inputSchema;
+    try {
+      inputSchema = buildToolPresentationSchema({
+        paramsSchema: tool.paramsSchema,
+        inputSchema: tool.inputSchema,
+        extendSchema: tool.shouldExtend && config.extend ? config.extend.schema : undefined,
+        flattenUnionInput: config.flattenUnionInput,
+        unrepresentable: "throw"
+      });
+    } catch (error) {
+      reportIncompatible(`MCP tool "${tool.name}" — input schema is not JSON Schema-compatible: ${error instanceof Error ? error.message : String(error)}`, policy, config.logger, failures);
+      continue;
+    }
+    if (!isObjectPresentationSchema(inputSchema)) {
+      reportIncompatible(`MCP tool "${tool.name}" — input must be an object schema; a union, discriminated union or scalar cannot be an MCP tool input (flatten it in the contract, or drop MCP from \`expose\`)`, policy, config.logger, failures);
+      continue;
+    }
+    if (config.schemaValidation?.requireTypedProperties) {
+      const allowed = new Set(config.schemaValidation.allowUntyped ?? []);
+      for (const untyped of findUntypedProperties(inputSchema)) {
+        const path = `${tool.name}.${untyped.path}`;
+        if (allowed.has(path))
+          continue;
+        const clue = untyped.description ? ` (only a description: "${untyped.description}")` : "";
+        reportIncompatible(`MCP tool "${tool.name}" — input property "${untyped.path}" carries no type, enum or $ref${clue}. A model is given no way to know what to send. Use \`z.json()\` for an arbitrary JSON value; use \`allowUntyped\` only when the presentation value is genuinely not representable as JSON Schema.`, policy === "skip" ? "warn" : policy, config.logger, failures);
+      }
+    }
+    if (config.schemaValidation?.requirePortableFormats) {
+      for (const finding of findNonPortableFormats(inputSchema, config.schemaValidation.allowFormats)) {
+        reportIncompatible(`MCP tool "${tool.name}" — input property "${finding.path}" uses non-portable JSON Schema format "${finding.format}". Use a portable pattern/schema, or list the format in \`allowFormats\` only when every MCP client supports it.`, policy === "skip" ? "warn" : policy, config.logger, failures);
+      }
+    }
+    const outputSchema = tool.outputSchema;
+    let compatibleOutput;
+    if (outputSchema) {
+      try {
+        const output = toJsonSchema(outputSchema, "output");
+        compatibleOutput = outputSchema;
+        if (config.schemaValidation?.requirePortableFormats) {
+          for (const finding of findNonPortableFormats(output, config.schemaValidation.allowFormats)) {
+            reportIncompatible(`MCP tool "${tool.name}" — output property "${finding.path}" uses non-portable JSON Schema format "${finding.format}". Use a portable pattern/schema, or list the format in \`allowFormats\` only when every MCP client supports it.`, policy === "skip" ? "warn" : policy, config.logger, failures);
+          }
+        }
+      } catch (error) {
+        reportIncompatible(`MCP tool "${tool.name}" — output schema is not JSON Schema-compatible: ${error instanceof Error ? error.message : String(error)}`, policy, config.logger, failures);
+      }
+    }
+    prepared.push({
+      tool: tool.tool,
+      inputSchema,
+      ...compatibleOutput !== undefined && { outputSchema: compatibleOutput }
+    });
+  }
+  if (failures.length > 0) {
+    throw new Error(`[stitchkit] ${failures.length} problem(s) with MCP tool schemas:
+ - ${failures.join(`
+ - `)}`);
+  }
+  return prepared;
+}
+
+export { objectShapeKeys, rebuildObject, mergeSchemas, validateMcpRoundPolicy, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };