stitchkit 0.118.1 → 0.120.0

package/dist/{index-rhzkndr5.js → index-x4p3kw1p.js}

@@ -4,6 +4,9 @@ import {
 import {
   toJsonSchema
 } from "./index-ct75c3at.js";
+import {
+  isHttpOnlyEndpoint
+} from "./index-69t14s4a.js";
 import {
   AppError2
 } from "./index-qcn84byh.js";
@@ -14,6 +17,214 @@ import {
   isRecord
 } from "./index-9jfdm5tg.js";
 
+// src/tools/internal/tool-view.ts
+function toolSurfaceOutputSchema(operation) {
+  if (!operation.outputSchema)
+    return;
+  return operation.toolView?.output ?? operation.outputSchema;
+}
+function applyToolViewDefaults(inputArgs, defaults) {
+  if (!defaults)
+    return inputArgs;
+  const filled = { ...inputArgs };
+  for (const [key, value] of Object.entries(defaults)) {
+    if (filled[key] === undefined)
+      filled[key] = structuredClone(value);
+  }
+  return filled;
+}
+function projectToolView(options) {
+  const { view } = options;
+  let projected = options.full;
+  if (view.project) {
+    try {
+      projected = Reflect.apply(view.project, undefined, [options.full, options.call]);
+    } catch (error) {
+      const failure = new AppError2("INTERNAL_SERVER_ERROR", {
+        message: `${options.operation} toolView.project threw`,
+        status: 500
+      });
+      failure.cause = error;
+      throw failure;
+    }
+    if (isRecord(projected) && typeof projected.then === "function") {
+      Promise.resolve(projected).catch(() => {
+        return;
+      });
+      throw new AppError2("INTERNAL_SERVER_ERROR", {
+        message: `${options.operation} toolView.project returned a Promise — it must be synchronous`,
+        status: 500
+      });
+    }
+    if (projected === undefined) {
+      return {
+        ok: false,
+        message: `${options.operation} toolView.project returned undefined`
+      };
+    }
+  }
+  const checked = validateDeclaredOutput(view.output ?? options.fullSchema, projected, view.project ? options.onStripped : undefined);
+  if (!checked.ok) {
+    return { ok: false, message: `${options.operation} toolView: ${checked.message}` };
+  }
+  return checked;
+}
+
+// src/tools/schema/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/internal/surface-projector.ts
+import { z as z3 } from "zod";
+
+// src/tools/mcp/round-policy.ts
+function staticInputRounds(policy) {
+  return Array.isArray(policy.inputRequired) ? policy.inputRequired : undefined;
+}
+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");
+  }
+  const declared = staticInputRounds(policy);
+  if (!declared)
+    return;
+  if (declared.length === 0) {
+    throw new Error(`[stitchkit] MCP tool "${tool.name}" must declare at least one input round`);
+  }
+  assertRoundShape(tool, declared, maxRounds);
+}
+function validateResolvedInputRounds(tool, resolved, maxRounds) {
+  assertRoundShape(tool, resolved, maxRounds);
+}
+function assertRoundShape(tool, rounds, maxRounds) {
+  if (rounds.length > maxRounds) {
+    throw new Error(`[stitchkit] MCP tool "${tool.name}" declares ${rounds.length} input rounds, exceeding maxRounds ${maxRounds}`);
+  }
+  const keys = new Set;
+  for (const request of rounds) {
+    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/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 \`tool.name\`` : "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/schema/portable-formats.ts
 var PORTABLE_JSON_SCHEMA_FORMATS2 = new Set([
   "date",
@@ -100,53 +311,148 @@ function findNonPortableFormats2(schema, allowFormats = []) {
   return found.sort((left, right) => left.path.localeCompare(right.path) || left.format.localeCompare(right.format));
 }
 
-// src/tools/schema/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;
+// src/tools/schema/presentation.ts
+import { z as z2 } from "zod";
+
+// src/json-schema/dialect.ts
+var DRAFT_07_MARKER = "draft-07";
+var DRAFT_07_KEYWORD = "definitions";
+var DEFS_KEYWORD = "$defs";
+var SCHEMA_KEYWORDS = [
+  "items",
+  "additionalItems",
+  "additionalProperties",
+  "contains",
+  "propertyNames",
+  "not",
+  "if",
+  "then",
+  "else",
+  "unevaluatedItems",
+  "unevaluatedProperties"
+];
+var SCHEMA_LIST_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems"];
+var SCHEMA_MAP_KEYWORDS = [
+  "properties",
+  "patternProperties",
+  "dependentSchemas",
+  DRAFT_07_KEYWORD,
+  DEFS_KEYWORD
+];
+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 mapValues(value, rewrite) {
+  if (!isRecord(value))
+    return value;
+  const rewritten = {};
+  for (const [name, child] of Object.entries(value))
+    rewritten[name] = rewrite(child);
+  return rewritten;
+}
+function withPositionalItems(schema) {
+  if (!isRecord(schema))
+    return schema;
+  const rewritten = {};
+  for (const [key, child] of Object.entries(schema)) {
+    if (SCHEMA_KEYWORDS.includes(key))
+      rewritten[key] = withPositionalItems(child);
+    else if (SCHEMA_LIST_KEYWORDS.includes(key) && Array.isArray(child)) {
+      rewritten[key] = child.map(withPositionalItems);
+    } else if (SCHEMA_MAP_KEYWORDS.includes(key)) {
+      rewritten[key] = mapValues(child, withPositionalItems);
+    } else
+      rewritten[key] = child;
+  }
+  const { items, additionalItems } = rewritten;
+  if (!Array.isArray(items))
+    return rewritten;
+  const positional = {};
+  for (const [key, child] of Object.entries(rewritten)) {
+    if (key === "items")
+      positional.prefixItems = items;
+    else if (key !== "additionalItems")
+      positional[key] = child;
+  }
+  if (additionalItems !== undefined)
+    positional.items = additionalItems;
+  return positional;
+}
+function withDraft2020Keywords(schema) {
+  const positional = withPositionalItems(schema);
+  if (!isRecord(positional))
+    return schema;
+  const definitions = positional[DRAFT_07_KEYWORD];
+  if (!isRecord(definitions) || DEFS_KEYWORD in positional)
+    return positional;
+  const rewritten = {};
+  for (const [key, value] of Object.entries(positional)) {
+    if (key === DRAFT_07_KEYWORD)
+      continue;
+    rewritten[key] = rewriteDefinitionPointers(value);
+  }
+  rewritten[DEFS_KEYWORD] = rewriteDefinitionPointers(definitions);
+  return rewritten;
+}
+
+// src/tools/schema/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"] };
@@ -390,465 +696,130 @@ function findDiscriminator(variants) {
   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) ? stringValues(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 required = 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: required.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, discriminator.key)
-  };
-  const required = [discriminator.key];
-  for (const [key, entries] of perKey) {
-    let merged = mergePropertySchemas(entries, discriminator.key);
-    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);
-      merged = appendHint(merged, `Available if ${discriminator.key} = ${[...new Set(presentLabels)].join(" | ")}.`);
-      if (requiredLabels.length > 0) {
-        merged = appendHint(merged, `Required if ${discriminator.key} = ${[...new Set(requiredLabels)].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 flattenToolJsonSchema2(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/schema/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 findUntypedProperties2(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(...findUntypedProperties2(value, path));
-      }
-    }
-  }
-  for (const key of ["items", "additionalProperties"]) {
-    const child = schema[key];
-    if (isRecord(child))
-      found.push(...findUntypedProperties2(child, prefix));
-    if (Array.isArray(child)) {
-      for (const entry of child) {
-        if (isRecord(entry))
-          found.push(...findUntypedProperties2(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(...findUntypedProperties2(entry, prefix));
-      }
-    }
-  }
-  const patterned = schema.patternProperties;
-  if (isRecord(patterned)) {
-    for (const value of Object.values(patterned)) {
-      if (isRecord(value))
-        found.push(...findUntypedProperties2(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(...findUntypedProperties2(definition, prefix));
-    }
-  }
-  for (const key of ["allOf", "anyOf", "oneOf"]) {
-    const branches = schema[key];
-    if (Array.isArray(branches)) {
-      for (const branch of branches)
-        found.push(...findUntypedProperties2(branch, prefix));
-    }
-  }
-  return found;
-}
-
-// src/tools/internal/tool-view.ts
-function toolSurfaceOutputSchema(operation) {
-  if (!operation.outputSchema)
-    return;
-  return operation.toolView?.output ?? operation.outputSchema;
-}
-function applyToolViewDefaults(inputArgs, defaults) {
-  if (!defaults)
-    return inputArgs;
-  const filled = { ...inputArgs };
-  for (const [key, value] of Object.entries(defaults)) {
-    if (filled[key] === undefined)
-      filled[key] = structuredClone(value);
-  }
-  return filled;
-}
-function projectToolView(options) {
-  const { view } = options;
-  let projected = options.full;
-  if (view.project) {
-    try {
-      projected = Reflect.apply(view.project, undefined, [options.full, options.call]);
-    } catch (error) {
-      const failure = new AppError2("INTERNAL_SERVER_ERROR", {
-        message: `${options.operation} toolView.project threw`,
-        status: 500
-      });
-      failure.cause = error;
-      throw failure;
-    }
-    if (isRecord(projected) && typeof projected.then === "function") {
-      Promise.resolve(projected).catch(() => {
-        return;
-      });
-      throw new AppError2("INTERNAL_SERVER_ERROR", {
-        message: `${options.operation} toolView.project returned a Promise — it must be synchronous`,
-        status: 500
-      });
-    }
-    if (projected === undefined) {
-      return {
-        ok: false,
-        message: `${options.operation} toolView.project returned undefined`
-      };
-    }
-  }
-  const checked = validateDeclaredOutput(view.output ?? options.fullSchema, projected, view.project ? options.onStripped : undefined);
-  if (!checked.ok) {
-    return { ok: false, message: `${options.operation} toolView: ${checked.message}` };
-  }
-  return checked;
-}
-
-// src/tools/schema/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 \`tool.name\`` : "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/schema/presentation.ts
-import { z as z2 } from "zod";
-
-// src/json-schema/dialect.ts
-var DRAFT_07_MARKER = "draft-07";
-var DRAFT_07_KEYWORD = "definitions";
-var DEFS_KEYWORD = "$defs";
-var SCHEMA_KEYWORDS = [
-  "items",
-  "additionalItems",
-  "additionalProperties",
-  "contains",
-  "propertyNames",
-  "not",
-  "if",
-  "then",
-  "else",
-  "unevaluatedItems",
-  "unevaluatedProperties"
-];
-var SCHEMA_LIST_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems"];
-var SCHEMA_MAP_KEYWORDS = [
-  "properties",
-  "patternProperties",
-  "dependentSchemas",
-  DRAFT_07_KEYWORD,
-  DEFS_KEYWORD
-];
-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);
+    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) ? stringValues(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 rewritten;
+  return null;
 }
-function mapValues(value, rewrite) {
-  if (!isRecord(value))
-    return value;
-  const rewritten = {};
-  for (const [name, child] of Object.entries(value))
-    rewritten[name] = rewrite(child);
-  return rewritten;
+function requiredKeys(variant) {
+  if (!Array.isArray(variant.required))
+    return new Set;
+  return new Set(variant.required.filter((key) => typeof key === "string"));
 }
-function withPositionalItems(schema) {
-  if (!isRecord(schema))
-    return schema;
-  const rewritten = {};
-  for (const [key, child] of Object.entries(schema)) {
-    if (SCHEMA_KEYWORDS.includes(key))
-      rewritten[key] = withPositionalItems(child);
-    else if (SCHEMA_LIST_KEYWORDS.includes(key) && Array.isArray(child)) {
-      rewritten[key] = child.map(withPositionalItems);
-    } else if (SCHEMA_MAP_KEYWORDS.includes(key)) {
-      rewritten[key] = mapValues(child, withPositionalItems);
-    } else
-      rewritten[key] = child;
+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 required = 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: required.has(key) });
+      perKey.set(key, entries);
+    }
   }
-  const { items, additionalItems } = rewritten;
-  if (!Array.isArray(items))
-    return rewritten;
-  const positional = {};
-  for (const [key, child] of Object.entries(rewritten)) {
-    if (key === "items")
-      positional.prefixItems = items;
-    else if (key !== "additionalItems")
-      positional[key] = child;
+  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
+    });
   }
-  if (additionalItems !== undefined)
-    positional.items = additionalItems;
-  return positional;
+  const properties = {
+    [discriminator.key]: mergePropertySchemas(discriminatorProperties, discriminator.key)
+  };
+  const required = [discriminator.key];
+  for (const [key, entries] of perKey) {
+    let merged = mergePropertySchemas(entries, discriminator.key);
+    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);
+      merged = appendHint(merged, `Available if ${discriminator.key} = ${[...new Set(presentLabels)].join(" | ")}.`);
+      if (requiredLabels.length > 0) {
+        merged = appendHint(merged, `Required if ${discriminator.key} = ${[...new Set(requiredLabels)].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 withDraft2020Keywords(schema) {
-  const positional = withPositionalItems(schema);
-  if (!isRecord(positional))
-    return schema;
-  const definitions = positional[DRAFT_07_KEYWORD];
-  if (!isRecord(definitions) || DEFS_KEYWORD in positional)
-    return positional;
-  const rewritten = {};
-  for (const [key, value] of Object.entries(positional)) {
-    if (key === DRAFT_07_KEYWORD)
-      continue;
-    rewritten[key] = rewriteDefinitionPointers(value);
+function flattenToolJsonSchema2(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);
   }
-  rewritten[DEFS_KEYWORD] = rewriteDefinitionPointers(definitions);
-  return rewritten;
 }
 
 // src/tools/schema/presentation.ts
@@ -1040,43 +1011,75 @@ function presentationMetadata(schema) {
   return withDraft2020Keywords(withoutDialect(schema));
 }
 
-// src/tools/internal/surface-projector.ts
-import { z as z3 } from "zod";
-
-// src/tools/mcp/round-policy.ts
-function staticInputRounds(policy) {
-  return Array.isArray(policy.inputRequired) ? policy.inputRequired : undefined;
+// src/tools/schema/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 validateMcpRoundPolicy(tool, policy, runtime) {
-  if (!runtime?.stateConfigured) {
-    throw new Error(`[stitchkit] MCP tool "${tool.name}" declares inputRequired but no multiRound.state key is configured`);
+function findUntypedProperties2(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(...findUntypedProperties2(value, path));
+      }
+    }
   }
-  const { maxRounds } = runtime;
-  if (!Number.isInteger(maxRounds) || maxRounds < 1) {
-    throw new Error("[stitchkit] multiRound.serving.maxRounds must be a positive integer");
+  for (const key of ["items", "additionalProperties"]) {
+    const child = schema[key];
+    if (isRecord(child))
+      found.push(...findUntypedProperties2(child, prefix));
+    if (Array.isArray(child)) {
+      for (const entry of child) {
+        if (isRecord(entry))
+          found.push(...findUntypedProperties2(entry, prefix));
+      }
+    }
   }
-  const declared = staticInputRounds(policy);
-  if (!declared)
-    return;
-  if (declared.length === 0) {
-    throw new Error(`[stitchkit] MCP tool "${tool.name}" must declare at least one input round`);
+  for (const key of ["prefixItems"]) {
+    const child = schema[key];
+    if (Array.isArray(child)) {
+      for (const entry of child) {
+        if (isRecord(entry))
+          found.push(...findUntypedProperties2(entry, prefix));
+      }
+    }
   }
-  assertRoundShape(tool, declared, maxRounds);
-}
-function validateResolvedInputRounds(tool, resolved, maxRounds) {
-  assertRoundShape(tool, resolved, maxRounds);
-}
-function assertRoundShape(tool, rounds, maxRounds) {
-  if (rounds.length > maxRounds) {
-    throw new Error(`[stitchkit] MCP tool "${tool.name}" declares ${rounds.length} input rounds, exceeding maxRounds ${maxRounds}`);
+  const patterned = schema.patternProperties;
+  if (isRecord(patterned)) {
+    for (const value of Object.values(patterned)) {
+      if (isRecord(value))
+        found.push(...findUntypedProperties2(value, prefix));
+    }
   }
-  const keys = new Set;
-  for (const request of rounds) {
-    if (keys.has(request.key)) {
-      throw new Error(`[stitchkit] MCP tool "${tool.name}" declares duplicate input key "${request.key}"`);
+  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(...findUntypedProperties2(definition, prefix));
     }
-    keys.add(request.key);
   }
+  for (const key of ["allOf", "anyOf", "oneOf"]) {
+    const branches = schema[key];
+    if (Array.isArray(branches)) {
+      for (const branch of branches)
+        found.push(...findUntypedProperties2(branch, prefix));
+    }
+  }
+  return found;
 }
 
 // src/tools/internal/surface-projector.ts
@@ -1152,7 +1155,7 @@ function projectToolSurface(surface, transport, config = {}) {
       } else if (method.expose && !method.expose.includes(transport)) {
         continue;
       }
-      if (method.multipart || method.rawBody || method.responseMeta || method.rawResponse) {
+      if (isHttpOnlyEndpoint(method)) {
         continue;
       }
       const name = method.toolName ?? toToolName(service.name, methodName);