stitchkit 0.1.0 → 0.2.0

package/dist/tools.js

@@ -1,23 +1,54 @@
 import {
   createClient
 } from "./index-5sxnvwb1.js";
-import {
-  formatZodError,
-  normalizeError
-} from "./index-gfzn1n4n.js";
-import"./index-7wfkbvss.js";
 import {
   isRecord
 } from "./index-809wc1tt.js";
+import {
+  formatZodError,
+  normalizeError
+} from "./index-a35v22fh.js";
+import"./index-kckky6zw.js";
 
 // src/tools/agent.ts
 import { tool, zodSchema } from "ai";
 
-// src/tools/mount.ts
-import { z as z2 } from "zod";
+// src/tools/schema.ts
+import { z } from "zod";
+function objectShapeKeys(schema) {
+  return schema instanceof z.ZodObject ? Object.keys(schema.shape) : [];
+}
+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 z.object({ ...paramsObject?.shape ?? {}, ...inputSchema.shape });
+  }
+  return paramsObject ? z.intersection(paramsObject, inputSchema) : inputSchema;
+}
 
 // src/tools/execute.ts
-async function executeToolMethod(method, toolName, rawArgs, context, hooks) {
+function toolResultFromError(err) {
+  const appErr = normalizeError(err);
+  return {
+    ok: false,
+    code: appErr.code,
+    details: appErr.details ?? { message: appErr.message },
+    ...appErr.hint && { hint: appErr.hint }
+  };
+}
+async function executeToolMethod(method, toolName, rawArgs, context, hooks, lifecycle) {
   const startedAt = Date.now();
   const finish = async (result) => {
     await hooks?.afterToolCall?.(toolName, rawArgs, result, Date.now() - startedAt, context);
@@ -26,9 +57,18 @@ async function executeToolMethod(method, toolName, rawArgs, context, hooks) {
   if (hooks?.beforeToolCall) {
     await hooks.beforeToolCall(toolName, rawArgs, context);
   }
+  const paramKeys = new Set(objectShapeKeys(method.paramsSchema));
+  const paramArgs = {};
+  const inputArgs = {};
+  for (const [key, value] of Object.entries(rawArgs)) {
+    if (paramKeys.has(key))
+      paramArgs[key] = value;
+    else
+      inputArgs[key] = value;
+  }
   let params;
   if (method.paramsSchema) {
-    const result = method.paramsSchema.safeParse(rawArgs);
+    const result = method.paramsSchema.safeParse(paramArgs);
     if (!result.success) {
       return finish({
         ok: false,
@@ -40,7 +80,7 @@ async function executeToolMethod(method, toolName, rawArgs, context, hooks) {
   }
   let input;
   if (method.inputSchema) {
-    const result = method.inputSchema.safeParse(rawArgs);
+    const result = method.inputSchema.safeParse(inputArgs);
     if (!result.success) {
       return finish({
         ok: false,
@@ -51,120 +91,101 @@ async function executeToolMethod(method, toolName, rawArgs, context, hooks) {
     input = result.data;
   }
   try {
-    const ctx = { params, input, ...context };
-    const data = await method.handler(ctx);
+    const ctx = { ...context, params, input, source: context.source };
+    if (lifecycle?.beforeHandle) {
+      await lifecycle.beforeHandle(ctx, method);
+    }
+    let data = await method.handler(ctx);
+    if (lifecycle?.afterHandle) {
+      const transformed = await lifecycle.afterHandle(ctx, data, method);
+      if (transformed !== undefined)
+        data = transformed;
+    }
+    if (method.outputSchema) {
+      const parsed = method.outputSchema.safeParse(data);
+      if (!parsed.success) {
+        return finish({
+          ok: false,
+          code: "INTERNAL_SERVER_ERROR",
+          details: {
+            message: `Handler output does not match the contract: ${formatZodError(parsed.error)}`
+          }
+        });
+      }
+      data = parsed.data;
+    }
     const output = data === undefined || data === null ? { status: "ok" } : data;
     return finish({ ok: true, data: output });
   } catch (err) {
-    const appErr = normalizeError(err);
-    return finish({
-      ok: false,
-      code: appErr.code,
-      details: appErr.details ?? { message: appErr.message },
-      ...appErr.hint && { hint: appErr.hint }
-    });
+    return finish(toolResultFromError(err));
   }
 }
 
-// src/tools/names.ts
-var SINGULAR_EXCEPTIONS = new Set([
-  "analytics",
-  "status",
-  "stats",
-  "settings",
-  "media",
-  "progress",
-  "news"
-]);
-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 toToolName(serviceName, methodName) {
-  const normalized = serviceName.replace(/-/g, "_");
-  const singular = singularize(normalized);
-  if (methodName === "list")
-    return `list_${normalized}`;
-  if (methodName === "get")
-    return `get_${singular}`;
-  if (methodName === "create")
-    return `create_${singular}`;
-  if (methodName === "update")
-    return `update_${singular}`;
-  if (methodName === "delete")
-    return `delete_${singular}`;
-  const snake = methodName.replace(/([A-Z])/g, "_$1").toLowerCase();
-  return `${snake}_${singular}`.replace(/^_/, "");
-}
+// src/tools/mount.ts
+import { z as z4 } from "zod";
 
-// src/tools/schema.ts
-import { z } from "zod";
+// src/tools/coerce.ts
+import { z as z2 } from "zod";
 function needsJsonCoercion(field) {
-  if (field instanceof z.ZodArray || field instanceof z.ZodObject)
+  if (field instanceof z2.ZodArray || field instanceof z2.ZodObject)
     return true;
-  if (field instanceof z.ZodOptional || field instanceof z.ZodNullable || field instanceof z.ZodDefault) {
+  if (field instanceof z2.ZodOptional || field instanceof z2.ZodNullable || field instanceof z2.ZodDefault) {
     return needsJsonCoercion(field.unwrap());
   }
   return false;
 }
 var jsonCoerce = (val) => {
-  if (typeof val === "string") {
-    try {
-      return JSON.parse(val);
-    } catch {
-      return val;
-    }
+  if (typeof val !== "string")
+    return val;
+  try {
+    return JSON.parse(val);
+  } catch {
+    return val;
   }
-  return val;
 };
 function withJsonCoercion(schema) {
   const shape = schema.shape;
   const coerced = {};
-  for (const [key, field] of Object.entries(shape)) {
-    if (!needsJsonCoercion(field)) {
-      coerced[key] = field;
+  for (const key of Object.keys(shape)) {
+    const field = shape[key];
+    if (!field || !needsJsonCoercion(field)) {
+      if (field)
+        coerced[key] = field;
       continue;
     }
     let inner = field;
     const wrappers = [];
-    while (inner instanceof z.ZodOptional || inner instanceof z.ZodNullable) {
-      if (inner instanceof z.ZodOptional) {
-        wrappers.push("optional");
-        inner = inner.unwrap();
-      } else {
-        wrappers.push("nullable");
-        inner = inner.unwrap();
-      }
+    while (inner instanceof z2.ZodOptional || inner instanceof z2.ZodNullable) {
+      wrappers.push(inner instanceof z2.ZodOptional ? "optional" : "nullable");
+      inner = inner.unwrap();
     }
-    let result = z.preprocess(jsonCoerce, inner);
+    let result = z2.preprocess(jsonCoerce, inner);
     for (const wrapper of wrappers.reverse()) {
-      result = wrapper === "optional" ? z.optional(result) : z.nullable(result);
+      result = wrapper === "optional" ? z2.optional(result) : z2.nullable(result);
     }
     coerced[key] = result;
   }
-  return z.object(coerced);
+  return z2.object(coerced);
 }
+
+// src/tools/flatten.ts
+import { z as z3 } from "zod";
 function flattenDiscriminatedUnion(union) {
   const discriminator = union.def.discriminator;
   const literalValues = [];
   const fieldToVariants = new Map;
   const fieldSchemas = {};
   for (const opt of union.def.options) {
-    if (!(opt instanceof z.ZodObject)) {
-      throw new Error(`flattenDiscriminatedUnion: option for discriminator '${discriminator}' is not a ZodObject`);
+    if (!(opt instanceof z3.ZodObject)) {
+      throw new Error(`flattenDiscriminatedUnion: variant for discriminator '${discriminator}' is not a ZodObject`);
     }
     const discField = opt.shape[discriminator];
-    if (!(discField instanceof z.ZodLiteral)) {
+    if (!(discField instanceof z3.ZodLiteral)) {
       throw new Error(`flattenDiscriminatedUnion: discriminator field '${discriminator}' must be z.literal()`);
     }
     const [literalValue] = discField.def.values;
     if (typeof literalValue !== "string") {
-      throw new Error(`flattenDiscriminatedUnion: discriminator literal must be a string (got ${typeof literalValue})`);
+      throw new Error("flattenDiscriminatedUnion: discriminator literal must be a string");
     }
     literalValues.push(literalValue);
     for (const [key, field] of Object.entries(opt.shape)) {
@@ -174,7 +195,7 @@ function flattenDiscriminatedUnion(union) {
       variants.push(literalValue);
       fieldToVariants.set(key, variants);
       if (!(key in fieldSchemas)) {
-        fieldSchemas[key] = field instanceof z.ZodOptional ? field : z.optional(field);
+        fieldSchemas[key] = field instanceof z3.ZodOptional ? field : z3.optional(field);
       }
     }
   }
@@ -183,32 +204,65 @@ function flattenDiscriminatedUnion(union) {
     throw new Error("flattenDiscriminatedUnion: union has no options");
   }
   const shape = {
-    [discriminator]: z.enum([firstLiteral, ...restLiterals])
+    [discriminator]: z3.enum([firstLiteral, ...restLiterals])
   };
   for (const [key, field] of Object.entries(fieldSchemas)) {
     const variants = fieldToVariants.get(key) ?? [];
     const hint = `Required if ${discriminator} = ${variants.join(" | ")}`;
-    shape[key] = field instanceof z.ZodType ? field.describe(hint) : field;
+    shape[key] = field instanceof z3.ZodType ? field.describe(hint) : field;
   }
-  return z.object(shape);
+  return z3.object(shape);
 }
-function mergeSchemas(paramsSchema, inputSchema) {
-  const paramsShape = paramsSchema instanceof z.ZodObject ? paramsSchema.shape : {};
-  const inputShape = inputSchema instanceof z.ZodObject ? inputSchema.shape : inputSchema instanceof z.ZodDiscriminatedUnion ? flattenDiscriminatedUnion(inputSchema).shape : {};
-  const paramsKeys = Object.keys(paramsShape);
-  const inputKeys = new Set(Object.keys(inputShape));
-  const conflicts = paramsKeys.filter((k) => inputKeys.has(k));
-  if (conflicts.length > 0) {
-    throw new Error(`Schema merge conflict: ${conflicts.join(", ")} appear in both params and input`);
-  }
-  const merged = { ...paramsShape, ...inputShape };
-  if (Object.keys(merged).length === 0)
-    return z.object({});
-  return withJsonCoercion(z.object(merged));
+
+// src/tools/names.ts
+var SINGULAR_EXCEPTIONS = new Set([
+  "analytics",
+  "status",
+  "stats",
+  "settings",
+  "media",
+  "progress",
+  "news"
+]);
+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 toToolName(serviceName, methodName) {
+  const normalized = serviceName.replace(/-/g, "_");
+  const singular = singularize(normalized);
+  if (methodName === "list")
+    return `list_${normalized}`;
+  if (methodName === "get")
+    return `get_${singular}`;
+  if (methodName === "create")
+    return `create_${singular}`;
+  if (methodName === "update")
+    return `update_${singular}`;
+  if (methodName === "delete")
+    return `delete_${singular}`;
+  const snake = methodName.replace(/([A-Z])/g, "_$1").toLowerCase();
+  return `${snake}_${singular}`.replace(/^_/, "");
 }
 
 // src/tools/mount.ts
-function collectTools(service, transport, extend) {
+function applyExtend(base, extra) {
+  if (base instanceof z4.ZodObject) {
+    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`);
+    }
+    return z4.object({ ...extra, ...base.shape });
+  }
+  return z4.intersection(z4.object(extra), base);
+}
+function collectTools(service, transport, config = {}) {
+  const { extend, coerceJsonArgs = true, flattenUnionInput = false } = config;
   const tools = [];
   for (const [methodName, method] of Object.entries(service.methods)) {
     if (method.expose && !method.expose.includes(transport))
@@ -216,9 +270,15 @@ function collectTools(service, transport, extend) {
     if (method.multipart)
       continue;
     const name = method.toolName ?? toToolName(service.name, methodName);
-    const baseSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
+    let baseSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
+    if (flattenUnionInput && baseSchema instanceof z4.ZodDiscriminatedUnion) {
+      baseSchema = flattenDiscriminatedUnion(baseSchema);
+    }
+    if (coerceJsonArgs && baseSchema instanceof z4.ZodObject) {
+      baseSchema = withJsonCoercion(baseSchema);
+    }
     const shouldExtend = !!extend && (!extend.filter || extend.filter(service, method));
-    const schema = shouldExtend ? z2.object({ ...extend?.schema, ...baseSchema.shape }) : baseSchema;
+    const schema = shouldExtend && extend ? applyExtend(baseSchema, extend.schema) : baseSchema;
     tools.push({ method, name, schema, shouldExtend });
   }
   return tools;
@@ -231,111 +291,226 @@ function createToolRunner(config) {
       extraContext = await config.extend.resolve(rawArgs);
     }
     const cleanArgs = extendKeys ? Object.fromEntries(Object.entries(rawArgs).filter(([key]) => !extendKeys.has(key))) : rawArgs;
-    return executeToolMethod(tool.method, tool.name, cleanArgs, { source: config.source, ...config.context, ...extraContext }, config.hooks);
+    return executeToolMethod(tool.method, tool.name, cleanArgs, { ...config.context, ...extraContext, source: config.source }, config.hooks, config.lifecycle);
   };
 }
-function formatToolError(result) {
+function formatToolError(result, toolName, errorHint) {
   const err = { error: result.code };
   if (result.details)
     err.details = result.details;
+  const hints = [];
   if (result.hint)
-    err._hint = result.hint;
+    hints.push(result.hint);
+  if (errorHint && toolName) {
+    const global = errorHint(toolName, result.code);
+    if (global)
+      hints.push(global);
+  }
+  if (hints.length > 0)
+    err._hint = hints.join(" ");
   return err;
 }
 
 // src/tools/agent.ts
-function formatAgentResult(result) {
-  return result.ok ? result.data : formatToolError(result);
-}
-function mountAgent(service, config = {}) {
+function mountAgent(services, config = {}) {
+  const serviceList = Array.isArray(services) ? services : [services];
   const tools = {};
   const runTool = createToolRunner({
     source: "agent",
     extend: config.extend,
     context: config.context,
-    hooks: config.hooks
+    hooks: config.hooks,
+    lifecycle: config.lifecycle,
+    errorHint: config.errorHint
   });
-  for (const mountable of collectTools(service, "AGENT", config.extend)) {
-    tools[mountable.name] = tool({
-      description: mountable.method.desc,
-      inputSchema: zodSchema(mountable.schema),
-      execute: async (rawArgs) => {
-        try {
-          const result = await runTool(mountable, rawArgs);
-          return formatAgentResult(result);
-        } catch (err) {
-          const appErr = normalizeError(err);
-          return { error: appErr.code, details: appErr.details };
-        }
+  for (const service of serviceList) {
+    for (const mountable of collectTools(service, "AGENT", {
+      extend: config.extend,
+      coerceJsonArgs: config.coerceJsonArgs,
+      flattenUnionInput: config.flattenUnionInput
+    })) {
+      if (mountable.name in tools) {
+        throw new Error(`Duplicate agent tool name "${mountable.name}" across mounted services`);
       }
-    });
+      tools[mountable.name] = tool({
+        description: mountable.method.desc,
+        inputSchema: zodSchema(mountable.schema),
+        execute: async (rawArgs) => {
+          const args = isRecord(rawArgs) ? rawArgs : {};
+          try {
+            const result = await runTool(mountable, args);
+            if (result.ok)
+              return result.data;
+            return formatToolError(result, mountable.name, config.errorHint);
+          } catch (err) {
+            return formatToolError(toolResultFromError(err), mountable.name, config.errorHint);
+          }
+        }
+      });
+    }
   }
   return tools;
 }
+// src/tools/json-schema.ts
+import { z as z5 } from "zod";
+function toJsonSchema(schema, io) {
+  return z5.toJSONSchema(schema, {
+    io,
+    target: "draft-2020-12",
+    unrepresentable: "throw",
+    cycles: "ref"
+  });
+}
+
+// src/tools/manifest.ts
+function buildToolManifest(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.method.desc,
+    inputSchema: toJsonSchema(t.schema, "input")
+  }));
+}
 // src/tools/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z3 } from "zod";
+import { z as z6 } from "zod";
 function textBlock(text) {
   return [{ type: "text", text }];
 }
-function formatMcpResult(result, hasOutputSchema) {
+function formatMcpResult(result, mode, toolName, errorHint) {
   if (result.ok) {
     const content = textBlock(JSON.stringify(result.data, null, 2));
-    if (hasOutputSchema && isRecord(result.data)) {
+    if (mode === "wrapped") {
+      return { content, structuredContent: { result: result.data } };
+    }
+    if (mode === "direct" && isRecord(result.data)) {
       return { content, structuredContent: result.data };
     }
     return { content };
   }
   return {
-    content: textBlock(JSON.stringify(formatToolError(result), null, 2)),
+    content: textBlock(JSON.stringify(formatToolError(result, toolName, errorHint), null, 2)),
     isError: true
   };
 }
+function probeSchema(schema, io) {
+  try {
+    toJsonSchema(schema, io);
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+function resolveOutputSchema(outputSchema) {
+  if (!outputSchema)
+    return null;
+  if (outputSchema instanceof z6.ZodObject) {
+    return { schema: outputSchema, mode: "direct" };
+  }
+  return { schema: z6.object({ result: outputSchema }), mode: "wrapped" };
+}
+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 throwIfFailures(failures) {
+  if (failures.length > 0) {
+    throw new Error(`[stitchkit] ${failures.length} MCP tool(s) have an incompatible schema:
+ - ${failures.join(`
+ - `)}`);
+  }
+}
+function prepareMcpTool(mountable, policy, logger, failures, seen) {
+  if (seen.has(mountable.name)) {
+    throw new Error(`Duplicate MCP tool name "${mountable.name}" across mounted services`);
+  }
+  seen.add(mountable.name);
+  if (!(mountable.schema instanceof z6.ZodObject)) {
+    reportIncompatible(`MCP tool "${mountable.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, logger, failures);
+    return null;
+  }
+  const inputError = probeSchema(mountable.schema, "input");
+  if (inputError) {
+    reportIncompatible(`MCP tool "${mountable.name}" — input schema is not JSON Schema-compatible: ${inputError}`, policy, logger, failures);
+    return null;
+  }
+  const resolved = resolveOutputSchema(mountable.method.outputSchema);
+  if (!resolved)
+    return { outputMode: "none" };
+  const outputError = probeSchema(resolved.schema, "output");
+  if (outputError) {
+    reportIncompatible(`MCP tool "${mountable.name}" — output schema is not JSON Schema-compatible: ${outputError}`, policy, logger, failures);
+    return { outputMode: "none" };
+  }
+  return { outputSchema: resolved.schema, outputMode: resolved.mode };
+}
+function validateMcpSchemas(services, onIncompatibleSchema = "throw", logger) {
+  const seen = new Set;
+  const failures = [];
+  for (const service of services) {
+    for (const mountable of collectTools(service, "MCP", undefined)) {
+      prepareMcpTool(mountable, onIncompatibleSchema, logger, failures, seen);
+    }
+  }
+  throwIfFailures(failures);
+}
 function mountMcp(mcpServer, services, config = {}) {
   const serviceList = Array.isArray(services) ? services : [services];
+  const policy = config.onIncompatibleSchema ?? "throw";
   const runTool = createToolRunner({
     source: "mcp",
     extend: config.extend,
     context: config.context,
-    hooks: config.hooks
+    hooks: config.hooks,
+    lifecycle: config.lifecycle,
+    errorHint: config.errorHint
   });
+  const seen = new Set;
+  const failures = [];
   for (const service of serviceList) {
-    for (const mountable of collectTools(service, "MCP", config.extend)) {
-      try {
-        z3.toJSONSchema(mountable.schema);
-      } catch (err) {
-        console.error(`[stitchkit] SKIPPING MCP tool "${mountable.name}" — schema not JSON Schema-compatible: ${err instanceof Error ? err.message : err}`);
+    for (const mountable of collectTools(service, "MCP", {
+      extend: config.extend,
+      coerceJsonArgs: config.coerceJsonArgs,
+      flattenUnionInput: config.flattenUnionInput
+    })) {
+      const prepared = prepareMcpTool(mountable, policy, config.logger, failures, seen);
+      if (!prepared)
         continue;
-      }
-      let outputSchema;
-      if (mountable.method.outputSchema instanceof z3.ZodObject) {
-        try {
-          z3.toJSONSchema(mountable.method.outputSchema);
-          outputSchema = mountable.method.outputSchema;
-        } catch {
-          outputSchema = undefined;
-        }
-      }
-      const toolConfig = { description: mountable.method.desc, inputSchema: mountable.schema.shape };
-      if (outputSchema)
-        toolConfig.outputSchema = outputSchema.shape;
+      const toolConfig = { description: mountable.method.desc, inputSchema: mountable.schema };
+      if (prepared.outputSchema)
+        toolConfig.outputSchema = prepared.outputSchema;
       mcpServer.registerTool(mountable.name, toolConfig, async (rawArgs) => {
+        const args = isRecord(rawArgs) ? rawArgs : {};
         try {
-          const result = await runTool(mountable, rawArgs);
-          return formatMcpResult(result, outputSchema !== undefined);
+          const result = await runTool(mountable, args);
+          return formatMcpResult(result, prepared.outputMode, mountable.name, config.errorHint);
         } catch (err) {
-          const appErr = normalizeError(err);
-          return formatMcpResult({ ok: false, code: appErr.code, details: appErr.details }, false);
+          return formatMcpResult(toolResultFromError(err), "none", mountable.name, config.errorHint);
         }
       });
     }
   }
+  throwIfFailures(failures);
 }
 function buildMcpServer(config, auth) {
   const server = new McpServer(config.serverInfo, config.instructions ? { instructions: config.instructions } : undefined);
   const services = typeof config.services === "function" ? config.services(auth) : config.services;
   const context = config.context?.(auth);
-  mountMcp(server, services, { context, hooks: config.hooks });
+  mountMcp(server, services, {
+    context,
+    hooks: config.hooks,
+    lifecycle: config.lifecycle,
+    onIncompatibleSchema: config.onIncompatibleSchema,
+    logger: config.logger,
+    coerceJsonArgs: config.coerceJsonArgs,
+    flattenUnionInput: config.flattenUnionInput,
+    errorHint: config.errorHint
+  });
   config.nativeTools?.(server);
   return server;
 }
@@ -382,6 +557,9 @@ function jsonRpcError(code, message, status) {
   return Response.json({ jsonrpc: "2.0", error: { code, message }, id: null }, { status });
 }
 function createMcpHandler(config) {
+  if (Array.isArray(config.services)) {
+    validateMcpSchemas(config.services, config.onIncompatibleSchema, config.logger);
+  }
   const eventStore = new InMemoryEventStore;
   const sessions = new Map;
   setInterval(() => {
@@ -481,7 +659,7 @@ import { lookup } from "node:dns/promises";
 import { readFile, stat } from "node:fs/promises";
 import { isIP } from "node:net";
 import { extname, resolve, sep } from "node:path";
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 var MAX_INLINE_BYTES = 20 * 1024 * 1024;
 var EXT_MIME = {
   ".png": "image/png",
@@ -624,7 +802,7 @@ function mountViewFile(server, options = {}) {
   server.registerTool("view_file", {
     description: "View media (image, audio, video) by URL or local path — returns it as content you can SEE / HEAR. Pass several paths to view multiple files at once. Use it on a generation `output` url to inspect the result.",
     inputSchema: {
-      paths: z4.union([z4.string(), z4.array(z4.string())]).describe("Media URL(s) or file path(s) to view")
+      paths: z7.union([z7.string(), z7.array(z7.string())]).describe("Media URL(s) or file path(s) to view")
     }
   }, async (args) => {
     const list = Array.isArray(args.paths) ? args.paths : [args.paths];
@@ -643,12 +821,17 @@ function mountViewFile(server, options = {}) {
   });
 }
 export {
+  withJsonCoercion,
+  validateMcpSchemas,
   resolveMedia,
   mountViewFile,
   mountMcp,
   mountAgent,
   implementRemote,
+  flattenDiscriminatedUnion,
   createStdioMcpServer,
   createMcpHandler,
+  collectTools,
+  buildToolManifest,
   buildMcpServer
 };