@inkeep/agents-core 0.79.1 → 0.80.0

package/dist/utils/json-schema-walk.d.ts

@@ -0,0 +1,50 @@
+//#region src/utils/json-schema-walk.d.ts
+/**
+ * Generic, reusable JSON Schema walker.
+ *
+ * Turns a JSON Schema into a normalized, `$ref`-resolved, cycle-safe tree of nodes
+ * that callers can render or introspect without re-implementing ref resolution,
+ * nullability unwrapping, or recursion guards. Format-specific emitting (XML, etc.)
+ * is left to the caller.
+ *
+ * Handles the shapes Pydantic-style MCP tool schemas produce: `$ref`/`$defs`,
+ * nested objects, array `items`, `anyOf`/`oneOf` nullables (`anyOf [t, null]` and
+ * `type: [t, "null"]`), and `enum`/`const`.
+ */
+interface NormalizedSchemaNode {
+  /** Property name (or `"item"` for an array element). */
+  name: string;
+  /** Resolved JSON Schema type (non-null branch of a nullable), defaults to `string`. */
+  type: string;
+  required: boolean;
+  nullable: boolean;
+  description?: string;
+  enumValues?: unknown[];
+  /** Present for object nodes. */
+  properties?: NormalizedSchemaNode[];
+  /** Present for array nodes. */
+  items?: NormalizedSchemaNode;
+  /** Present for multi-branch unions (`anyOf`/`oneOf` with more than one non-null branch). */
+  variants?: NormalizedSchemaNode[];
+  /** Set when a `$ref` cycle or the depth cap stopped the walk at this node. */
+  recursive?: boolean;
+}
+interface WalkJsonSchemaOptions {
+  /** Backstop against pathological/cyclic schemas. Defaults to 12. */
+  maxDepth?: number;
+}
+/**
+ * Normalize a schema's top-level `properties` into ref-resolved, cycle-safe nodes.
+ * `$defs`/`definitions` and `$ref: "#"` are resolved against the passed schema root.
+ */
+declare function normalizeJsonSchemaProperties(schema: any, options?: WalkJsonSchemaOptions): NormalizedSchemaNode[];
+/**
+ * Unwrap an AI SDK `jsonSchema()` wrapper (`{ jsonSchema, validate, _type }`) to the
+ * underlying JSON Schema. The MCP ingestion fallback wraps a raw schema this way; without
+ * unwrapping, downstream readers (provider tool def, prompt renderer, manage UI) see the
+ * wrapper's top-level keys instead of the real `properties`/`$defs`. A non-wrapper value
+ * (plain JSON Schema, or a Zod schema, which has no `jsonSchema` property) passes through.
+ */
+declare function unwrapJsonSchemaWrapper<T>(value: T): T | Record<string, unknown>;
+//#endregion
+export { NormalizedSchemaNode, WalkJsonSchemaOptions, normalizeJsonSchemaProperties, unwrapJsonSchemaWrapper };

package/dist/utils/json-schema-walk.js

@@ -0,0 +1,202 @@
+//#region src/utils/json-schema-walk.ts
+const DEFAULT_MAX_DEPTH = 12;
+function resolveRef(node, ctx) {
+	if (node && typeof node === "object" && typeof node.$ref === "string") {
+		const ref = node.$ref;
+		if (ref === "#") return {
+			node: ctx.root ?? node,
+			refName: "#"
+		};
+		const refName = ref.split("/").pop();
+		const resolved = ctx.defs[refName];
+		return resolved ? {
+			node: resolved,
+			refName
+		} : {
+			node,
+			refName
+		};
+	}
+	return { node };
+}
+function unwrapNullable(node) {
+	if (!node || typeof node !== "object") return {
+		inner: node,
+		nullable: false
+	};
+	if (Array.isArray(node.type) && node.type.includes("null")) {
+		const nonNull = node.type.filter((t) => t !== "null");
+		return {
+			inner: {
+				...node,
+				type: nonNull.length === 1 ? nonNull[0] : nonNull
+			},
+			nullable: true
+		};
+	}
+	const variants = node.anyOf ?? node.oneOf;
+	if (Array.isArray(variants)) {
+		const nonNull = variants.filter((v) => v?.type !== "null");
+		const hasNull = variants.some((v) => v?.type === "null");
+		if (hasNull && nonNull.length === 1) return {
+			inner: nonNull[0],
+			nullable: true
+		};
+		if (!hasNull && nonNull.length === 1) return {
+			inner: nonNull[0],
+			nullable: false
+		};
+		if (hasNull) {
+			const key = node.anyOf ? "anyOf" : "oneOf";
+			return {
+				inner: {
+					...node,
+					[key]: nonNull
+				},
+				nullable: true
+			};
+		}
+	}
+	return {
+		inner: node,
+		nullable: false
+	};
+}
+/**
+* Flatten an `allOf` composition into a single node by merging the (deref'd) branches'
+* properties, required, type, description, and enum. Pydantic v2 emits this shape when it
+* combines a `$ref` with extra constraints (e.g. `{ allOf: [{ $ref }], description }`).
+*/
+function mergeAllOf(node, ctx) {
+	if (!node || typeof node !== "object" || !Array.isArray(node.allOf)) return node;
+	const merged = { ...node };
+	merged.allOf = void 0;
+	merged.properties = { ...node.properties ?? {} };
+	const required = new Set(Array.isArray(node.required) ? node.required : []);
+	const stack = [...node.allOf];
+	const visited = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const { node: branch, refName } = resolveRef(stack.pop(), ctx);
+		if (refName) {
+			if (visited.has(refName)) continue;
+			visited.add(refName);
+		}
+		if (!branch || typeof branch !== "object") continue;
+		if (Array.isArray(branch.allOf)) stack.push(...branch.allOf);
+		if (branch.properties && typeof branch.properties === "object") Object.assign(merged.properties, branch.properties);
+		if (Array.isArray(branch.required)) for (const r of branch.required) required.add(r);
+		if (!merged.type && typeof branch.type === "string") merged.type = branch.type;
+		if (!merged.description && typeof branch.description === "string") merged.description = branch.description;
+		if (!merged.enum && Array.isArray(branch.enum)) merged.enum = branch.enum;
+	}
+	if (Object.keys(merged.properties).length === 0) merged.properties = void 0;
+	if (required.size > 0) merged.required = [...required];
+	if (!merged.type && merged.properties) merged.type = "object";
+	return merged;
+}
+function nodeType(node) {
+	if (!node) return "string";
+	if (typeof node.type === "string") return node.type;
+	if (Array.isArray(node.type)) return node.type.filter((t) => t !== "null")[0] || "string";
+	if (Array.isArray(node.anyOf) || Array.isArray(node.oneOf)) return "union";
+	if (Array.isArray(node.enum)) return typeof node.enum[0] === "number" ? "number" : "string";
+	return "string";
+}
+function enumValues(node) {
+	if (Array.isArray(node?.enum)) return node.enum;
+	if (node?.const !== void 0) return [node.const];
+}
+function walkNode(name, rawNode, required, ctx) {
+	const { node: derefed, refName: outerRef } = resolveRef(rawNode, ctx);
+	const { inner: unwrapped, nullable } = unwrapNullable(derefed);
+	const { node: reResolved, refName: innerRef } = resolveRef(unwrapped, ctx);
+	const inner = mergeAllOf(reResolved, ctx);
+	const refName = outerRef ?? innerRef;
+	const descRaw = inner?.description ?? rawNode?.description;
+	const description = typeof descRaw === "string" ? descRaw.trim() || void 0 : void 0;
+	const type = nodeType(inner);
+	const base = {
+		name,
+		type,
+		required,
+		nullable,
+		description
+	};
+	if ((refName ? ctx.seen.has(refName) : false) || ctx.depth >= ctx.maxDepth) return {
+		...base,
+		recursive: true
+	};
+	const childCtx = refName ? {
+		...ctx,
+		depth: ctx.depth + 1,
+		seen: new Set([...ctx.seen, refName])
+	} : {
+		...ctx,
+		depth: ctx.depth + 1
+	};
+	if (inner?.properties && typeof inner.properties === "object") {
+		const entries = Object.entries(inner.properties);
+		if (entries.length > 0) {
+			const childRequired = Array.isArray(inner.required) ? inner.required : [];
+			const properties = entries.map(([k, v]) => walkNode(k, v, childRequired.includes(k), childCtx));
+			return {
+				...base,
+				type: "object",
+				properties
+			};
+		}
+	}
+	if (type === "array" && inner?.items && typeof inner.items === "object") return {
+		...base,
+		type: "array",
+		items: walkNode("item", inner.items, false, childCtx)
+	};
+	const branches = inner?.anyOf ?? inner?.oneOf;
+	if (Array.isArray(branches) && branches.length > 1) {
+		const variants = branches.map((branch, i) => walkNode(`variant${i}`, branch, false, childCtx));
+		return {
+			...base,
+			type: "union",
+			variants
+		};
+	}
+	const ev = enumValues(inner);
+	return ev ? {
+		...base,
+		enumValues: ev
+	} : base;
+}
+/**
+* Normalize a schema's top-level `properties` into ref-resolved, cycle-safe nodes.
+* `$defs`/`definitions` and `$ref: "#"` are resolved against the passed schema root.
+*/
+function normalizeJsonSchemaProperties(schema, options = {}) {
+	if (!schema || typeof schema !== "object") return [];
+	const properties = schema.properties ?? {};
+	const required = Array.isArray(schema.required) ? schema.required : [];
+	const ctx = {
+		defs: schema.$defs ?? schema.definitions ?? {},
+		root: schema,
+		depth: 0,
+		maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
+		seen: /* @__PURE__ */ new Set()
+	};
+	return Object.entries(properties).map(([name, node]) => walkNode(name, node, required.includes(name), ctx));
+}
+/**
+* Unwrap an AI SDK `jsonSchema()` wrapper (`{ jsonSchema, validate, _type }`) to the
+* underlying JSON Schema. The MCP ingestion fallback wraps a raw schema this way; without
+* unwrapping, downstream readers (provider tool def, prompt renderer, manage UI) see the
+* wrapper's top-level keys instead of the real `properties`/`$defs`. A non-wrapper value
+* (plain JSON Schema, or a Zod schema, which has no `jsonSchema` property) passes through.
+*/
+function unwrapJsonSchemaWrapper(value) {
+	if (value && typeof value === "object") {
+		const inner = value.jsonSchema;
+		if (inner && typeof inner === "object") return inner;
+	}
+	return value;
+}
+
+//#endregion
+export { normalizeJsonSchemaProperties, unwrapJsonSchemaWrapper };

package/dist/utils/mcp-client.js

@@ -1,4 +1,5 @@
 import { MCPTransportType } from "../types/utility.js";
+import { getLogger } from "./logger.js";
 import { MCP_TOOL_CONNECTION_TIMEOUT_MS, MCP_TOOL_INITIAL_RECONNECTION_DELAY_MS, MCP_TOOL_MAX_RECONNECTION_DELAY_MS, MCP_TOOL_MAX_RETRIES, MCP_TOOL_RECONNECTION_DELAY_GROWTH_FACTOR } from "../constants/execution-limits-shared/index.js";
 import { z } from "@hono/zod-openapi";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -6,11 +7,12 @@ import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { tool } from "ai";
+import { jsonSchema, tool } from "ai";
 import { asyncExitHook } from "exit-hook";
 import { match } from "ts-pattern";
 
 //#region src/utils/mcp-client.ts
+const logger = getLogger("mcp-client");
 const activeMcpClients = /* @__PURE__ */ new Set();
 let exitHookRegistered = false;
 function ensureExitHook() {
@@ -141,37 +143,17 @@ var McpClient = class {
 		const tools = await this.selectTools();
 		const results = {};
 		for (const def of tools) try {
-			const createZodSchema = (inputSchema) => {
-				if (!inputSchema || !inputSchema.properties) return z.object({});
-				const zodProperties = {};
-				for (const [key, prop] of Object.entries(inputSchema.properties)) {
-					const propDef = prop;
-					let zodType;
-					switch (propDef.type) {
-						case "string":
-							zodType = z.string();
-							break;
-						case "number":
-							zodType = z.number();
-							break;
-						case "boolean":
-							zodType = z.boolean();
-							break;
-						case "array":
-							zodType = z.array(z.any());
-							break;
-						case "object":
-							zodType = createZodSchema(propDef);
-							break;
-						default: zodType = z.any();
-					}
-					if (propDef.description) zodType = zodType.describe(propDef.description);
-					if (!inputSchema.required?.includes(key)) zodType = zodType.optional();
-					zodProperties[key] = zodType;
-				}
-				return z.object(zodProperties);
-			};
-			const schema = createZodSchema(def.inputSchema);
+			let schema;
+			try {
+				schema = z.fromJSONSchema(def.inputSchema);
+			} catch (conversionError) {
+				logger.warn({
+					server: this.name,
+					tool: def.name,
+					error: conversionError instanceof Error ? conversionError.message : String(conversionError)
+				}, "z.fromJSONSchema failed; passing raw JSON Schema through");
+				schema = jsonSchema(def.inputSchema ?? {});
+			}
 			const createdTool = tool({
 				id: `${this.name}.${def.name}`,
 				description: def.description || "",

package/dist/validation/drizzle-schema-helpers.d.ts

@@ -1,10 +1,10 @@
 import { z } from "@hono/zod-openapi";
-import * as drizzle_zod403 from "drizzle-zod";
+import * as drizzle_zod0 from "drizzle-zod";
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 
 //#region src/validation/drizzle-schema-helpers.d.ts
-declare function createSelectSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod403.BuildSchema<"select", T["_"]["columns"], drizzle_zod403.BuildRefine<T["_"]["columns"], undefined>, undefined>;
-declare function createInsertSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod403.BuildSchema<"insert", T["_"]["columns"], drizzle_zod403.BuildRefine<Pick<T["_"]["columns"], keyof T["$inferInsert"]>, undefined>, undefined>;
+declare function createSelectSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod0.BuildSchema<"select", T["_"]["columns"], drizzle_zod0.BuildRefine<T["_"]["columns"], undefined>, undefined>;
+declare function createInsertSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod0.BuildSchema<"insert", T["_"]["columns"], drizzle_zod0.BuildRefine<Pick<T["_"]["columns"], keyof T["$inferInsert"]>, undefined>, undefined>;
 declare const createSelectSchema: typeof createSelectSchemaWithModifiers;
 declare const createInsertSchema: typeof createInsertSchemaWithModifiers;
 /**

package/dist/validation/schemas/skills.d.ts

@@ -352,12 +352,12 @@ declare const SkillUpdateSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const SkillApiSelectSchema: z.ZodObject<{
   id: z.ZodString;
-  name: z.ZodString;
   createdAt: z.ZodString;
-  updatedAt: z.ZodString;
+  name: z.ZodString;
   metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
   description: z.ZodString;
   content: z.ZodString;
+  updatedAt: z.ZodString;
 }, z.core.$strip>;
 declare const SkillApiInsertSchema: z.ZodPipe<z.ZodPipe<z.ZodObject<{
   files: z.ZodArray<z.ZodObject<{
@@ -411,8 +411,8 @@ declare const SkillApiUpdateSchema: z.ZodPipe<z.ZodPipe<z.ZodObject<{
 declare const SkillFileApiSelectSchema: z.ZodObject<{
   id: z.ZodString;
   createdAt: z.ZodString;
-  updatedAt: z.ZodString;
   content: z.ZodString;
+  updatedAt: z.ZodString;
   skillId: z.ZodString;
   filePath: z.ZodString;
 }, z.core.$strip>;
@@ -425,17 +425,17 @@ declare const SkillFileApiUpdateSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const SkillWithFilesApiSelectSchema: z.ZodObject<{
   id: z.ZodString;
-  name: z.ZodString;
   createdAt: z.ZodString;
-  updatedAt: z.ZodString;
+  name: z.ZodString;
   metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
   description: z.ZodString;
   content: z.ZodString;
+  updatedAt: z.ZodString;
   files: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodString;
-    updatedAt: z.ZodString;
     content: z.ZodString;
+    updatedAt: z.ZodString;
     skillId: z.ZodString;
     filePath: z.ZodString;
   }, z.core.$strip>>;
@@ -488,8 +488,8 @@ declare const SubAgentSkillUpdateSchema: z.ZodObject<{
 declare const SubAgentSkillApiSelectSchema: z.ZodObject<{
   id: z.ZodString;
   createdAt: z.ZodString;
-  updatedAt: z.ZodString;
   subAgentId: z.ZodString;
+  updatedAt: z.ZodString;
   skillId: z.ZodString;
   index: z.ZodInt;
   alwaysLoaded: z.ZodBoolean;
@@ -507,20 +507,20 @@ declare const SubAgentSkillApiInsertSchema: z.ZodObject<{
 declare const SubAgentSkillApiUpdateSchema: z.ZodObject<{
   id: z.ZodOptional<z.ZodOptional<z.ZodString>>;
   createdAt: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodString>>>;
-  updatedAt: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodString>>>;
   subAgentId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  updatedAt: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodString>>>;
   skillId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
   index: z.ZodOptional<z.ZodOptional<z.ZodInt>>;
   alwaysLoaded: z.ZodOptional<z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>>;
 }, z.core.$strip>;
 declare const SubAgentSkillWithIndexSchema: z.ZodObject<{
   id: z.ZodString;
-  name: z.ZodString;
   createdAt: z.ZodString;
-  updatedAt: z.ZodString;
+  name: z.ZodString;
   metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
   description: z.ZodString;
   content: z.ZodString;
+  updatedAt: z.ZodString;
   subAgentSkillId: z.ZodString;
   subAgentId: z.ZodString;
   index: z.ZodInt;
@@ -530,8 +530,8 @@ declare const SkillFileResponse: z.ZodObject<{
   data: z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodString;
-    updatedAt: z.ZodString;
     content: z.ZodString;
+    updatedAt: z.ZodString;
     skillId: z.ZodString;
     filePath: z.ZodString;
   }, z.core.$strip>;
@@ -539,17 +539,17 @@ declare const SkillFileResponse: z.ZodObject<{
 declare const SkillWithFilesResponse: z.ZodObject<{
   data: z.ZodObject<{
     id: z.ZodString;
-    name: z.ZodString;
     createdAt: z.ZodString;
-    updatedAt: z.ZodString;
+    name: z.ZodString;
     metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
     description: z.ZodString;
     content: z.ZodString;
+    updatedAt: z.ZodString;
     files: z.ZodArray<z.ZodObject<{
       id: z.ZodString;
       createdAt: z.ZodString;
-      updatedAt: z.ZodString;
       content: z.ZodString;
+      updatedAt: z.ZodString;
       skillId: z.ZodString;
       filePath: z.ZodString;
     }, z.core.$strip>>;
@@ -558,12 +558,12 @@ declare const SkillWithFilesResponse: z.ZodObject<{
 declare const SkillListResponse: z.ZodObject<{
   data: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
-    name: z.ZodString;
     createdAt: z.ZodString;
-    updatedAt: z.ZodString;
+    name: z.ZodString;
     metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
     description: z.ZodString;
     content: z.ZodString;
+    updatedAt: z.ZodString;
   }, z.core.$strip>>;
   pagination: z.ZodObject<{
     page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -577,8 +577,8 @@ declare const SubAgentSkillResponse: z.ZodObject<{
   data: z.ZodObject<{
     id: z.ZodString;
     createdAt: z.ZodString;
-    updatedAt: z.ZodString;
     subAgentId: z.ZodString;
+    updatedAt: z.ZodString;
     skillId: z.ZodString;
     index: z.ZodInt;
     alwaysLoaded: z.ZodBoolean;
@@ -587,12 +587,12 @@ declare const SubAgentSkillResponse: z.ZodObject<{
 declare const SubAgentSkillWithIndexArrayResponse: z.ZodObject<{
   data: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
-    name: z.ZodString;
     createdAt: z.ZodString;
-    updatedAt: z.ZodString;
+    name: z.ZodString;
     metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
     description: z.ZodString;
     content: z.ZodString;
+    updatedAt: z.ZodString;
     subAgentSkillId: z.ZodString;
     subAgentId: z.ZodString;
     index: z.ZodInt;