ont-run 0.0.5 → 0.0.7

package/src/config/zod-utils.ts

@@ -0,0 +1,133 @@
+/**
+ * Utility functions for inspecting Zod 4 schemas.
+ * These use duck typing to work across bundle boundaries.
+ */
+
+/**
+ * Check if a value is a Zod 3 schema (has _def but not _zod)
+ */
+export function isZod3Schema(val: unknown): boolean {
+  if (val === null || typeof val !== "object") return false;
+  // Zod 3 uses _def property without _zod
+  if ("_def" in val && "safeParse" in val && !("_zod" in val)) return true;
+  return false;
+}
+
+/**
+ * Check if a value is a Zod schema (duck typing to work across bundle boundaries)
+ */
+export function isZodSchema(val: unknown): boolean {
+  if (val === null || typeof val !== "object") return false;
+  // Zod 4 uses _zod property
+  if ("_zod" in val && "safeParse" in val) return true;
+  return false;
+}
+
+/**
+ * Get the Zod type name from a schema
+ */
+export function getZodTypeName(schema: unknown): string | undefined {
+  if (!isZodSchema(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: check _zod.def.typeName
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (typeof def.typeName === "string") return def.typeName;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Check if schema is a ZodObject
+ */
+export function isZodObject(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodObject";
+}
+
+/**
+ * Check if schema is a ZodOptional
+ */
+export function isZodOptional(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodOptional";
+}
+
+/**
+ * Check if schema is a ZodNullable
+ */
+export function isZodNullable(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodNullable";
+}
+
+/**
+ * Check if schema is a ZodArray
+ */
+export function isZodArray(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodArray";
+}
+
+/**
+ * Check if schema is a ZodDefault
+ */
+export function isZodDefault(schema: unknown): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName === "ZodDefault";
+}
+
+/**
+ * Get the shape of a ZodObject schema
+ */
+export function getObjectShape(schema: unknown): Record<string, unknown> | undefined {
+  if (!isZodObject(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: shape is in _zod.def.shape
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.shape && typeof def.shape === "object") {
+        return def.shape as Record<string, unknown>;
+      }
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Get the inner schema from Optional/Nullable/Default
+ */
+export function getInnerSchema(schema: unknown): unknown {
+  const s = schema as Record<string, unknown>;
+  // Zod 4: innerType is in _zod.def.innerType
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.innerType) return def.innerType;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Get the element schema from a ZodArray
+ */
+export function getArrayElement(schema: unknown): unknown {
+  if (!isZodArray(schema)) return undefined;
+  const s = schema as Record<string, unknown>;
+  // Zod 4: element is in _zod.def.element
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod as Record<string, unknown>;
+    if (zod.def && typeof zod.def === "object") {
+      const def = zod.def as Record<string, unknown>;
+      if (def.element) return def.element;
+    }
+  }
+  return undefined;
+}

package/src/lockfile/hasher.ts

@@ -1,8 +1,17 @@
 import { createHash } from "crypto";
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import type { OntologyConfig } from "../config/types.js";
 import { getFieldFromMetadata, getUserContextFields } from "../config/categorical.js";
+import {
+  isZodObject,
+  isZodOptional,
+  isZodNullable,
+  isZodArray,
+  isZodDefault,
+  getObjectShape,
+  getInnerSchema,
+  getArrayElement,
+} from "../config/zod-utils.js";
 import type {
   OntologySnapshot,
   FunctionShape,
@@ -28,34 +37,48 @@ function extractFieldReferences(
   }
 
   // Handle ZodObject - recurse into properties
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldPath = path ? `${path}.${key}` : key;
-      results.push(
-        ...extractFieldReferences(value as z.ZodType<unknown>, fieldPath)
-      );
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        const fieldPath = path ? `${path}.${key}` : key;
+        results.push(
+          ...extractFieldReferences(value as z.ZodType<unknown>, fieldPath)
+        );
+      }
     }
   }
 
   // Handle ZodOptional - unwrap
-  if (schema instanceof z.ZodOptional) {
-    results.push(...extractFieldReferences(schema.unwrap(), path));
+  if (isZodOptional(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodNullable - unwrap
-  if (schema instanceof z.ZodNullable) {
-    results.push(...extractFieldReferences(schema.unwrap(), path));
+  if (isZodNullable(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodArray - recurse into element
-  if (schema instanceof z.ZodArray) {
-    results.push(...extractFieldReferences(schema.element, `${path}[]`));
+  if (isZodArray(schema)) {
+    const element = getArrayElement(schema);
+    if (element) {
+      results.push(...extractFieldReferences(element as z.ZodType<unknown>, `${path}[]`));
+    }
   }
 
   // Handle ZodDefault - unwrap
-  if (schema instanceof z.ZodDefault) {
-    results.push(...extractFieldReferences(schema._def.innerType, path));
+  if (isZodDefault(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferences(inner as z.ZodType<unknown>, path));
+    }
   }
 
   return results;
@@ -85,14 +108,14 @@ export function extractOntology(config: OntologyConfig): OntologySnapshot {
     // This ensures we're comparing the shape, not the Zod instance
     let inputsSchema: Record<string, unknown>;
     try {
-      inputsSchema = zodToJsonSchema(fn.inputs, {
-        // Remove $schema to make hashing more stable
-        $refStrategy: "none",
+      inputsSchema = z.toJSONSchema(fn.inputs, {
+        reused: "inline",
+        unrepresentable: "any",
       }) as Record<string, unknown>;
       // Remove $schema key if present
       delete inputsSchema.$schema;
     } catch {
-      // If zodToJsonSchema fails, use a placeholder
+      // If z.toJSONSchema fails, use a placeholder
       inputsSchema = { type: "unknown" };
     }
 
@@ -100,8 +123,9 @@ export function extractOntology(config: OntologyConfig): OntologySnapshot {
     let outputsSchema: Record<string, unknown> | undefined;
     if (fn.outputs) {
       try {
-        outputsSchema = zodToJsonSchema(fn.outputs, {
-          $refStrategy: "none",
+        outputsSchema = z.toJSONSchema(fn.outputs, {
+          reused: "inline",
+          unrepresentable: "any",
         }) as Record<string, unknown>;
         delete outputsSchema.$schema;
       } catch {

package/src/server/mcp/tools.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import type {
   OntologyConfig,
   FunctionDefinition,
@@ -8,6 +7,16 @@ import type {
   AuthResult,
 } from "../../config/types.js";
 import { getFieldFromMetadata, getUserContextFields, hasUserContextMetadata } from "../../config/categorical.js";
+import {
+  isZodObject,
+  isZodOptional,
+  isZodNullable,
+  isZodArray,
+  isZodDefault,
+  getObjectShape,
+  getInnerSchema,
+  getArrayElement,
+} from "../../config/zod-utils.js";
 import type { Logger } from "../resolver.js";
 
 /**
@@ -94,36 +103,48 @@ function extractFieldReferencesForMcp(
   }
 
   // Handle ZodObject - recurse into properties
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldPath = path ? `${path}.${key}` : key;
-      results.push(
-        ...extractFieldReferencesForMcp(value as z.ZodType<unknown>, fieldPath)
-      );
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        const fieldPath = path ? `${path}.${key}` : key;
+        results.push(
+          ...extractFieldReferencesForMcp(value as z.ZodType<unknown>, fieldPath)
+        );
+      }
     }
   }
 
   // Handle ZodOptional - unwrap
-  if (schema instanceof z.ZodOptional) {
-    results.push(...extractFieldReferencesForMcp(schema.unwrap(), path));
+  if (isZodOptional(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferencesForMcp(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodNullable - unwrap
-  if (schema instanceof z.ZodNullable) {
-    results.push(...extractFieldReferencesForMcp(schema.unwrap(), path));
+  if (isZodNullable(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferencesForMcp(inner as z.ZodType<unknown>, path));
+    }
   }
 
   // Handle ZodArray - recurse into element
-  if (schema instanceof z.ZodArray) {
-    results.push(...extractFieldReferencesForMcp(schema.element, `${path}[]`));
+  if (isZodArray(schema)) {
+    const element = getArrayElement(schema);
+    if (element) {
+      results.push(...extractFieldReferencesForMcp(element as z.ZodType<unknown>, `${path}[]`));
+    }
   }
 
   // Handle ZodDefault - unwrap
-  if (schema instanceof z.ZodDefault) {
-    results.push(
-      ...extractFieldReferencesForMcp(schema._def.innerType, path)
-    );
+  if (isZodDefault(schema)) {
+    const inner = getInnerSchema(schema);
+    if (inner) {
+      results.push(...extractFieldReferencesForMcp(inner as z.ZodType<unknown>, path));
+    }
   }
 
   return results;
@@ -139,8 +160,9 @@ export function generateMcpTools(config: OntologyConfig): McpTool[] {
     // Convert Zod schema to JSON Schema for MCP
     let inputSchema: Record<string, unknown>;
     try {
-      inputSchema = zodToJsonSchema(fn.inputs, {
-        $refStrategy: "none",
+      inputSchema = z.toJSONSchema(fn.inputs, {
+        reused: "inline",
+        unrepresentable: "any",
       }) as Record<string, unknown>;
       // Remove $schema key if present
       delete inputSchema.$schema;
@@ -154,8 +176,9 @@ export function generateMcpTools(config: OntologyConfig): McpTool[] {
     let outputSchema: Record<string, unknown> | undefined;
     if (fn.outputs) {
       try {
-        outputSchema = zodToJsonSchema(fn.outputs, {
-          $refStrategy: "none",
+        outputSchema = z.toJSONSchema(fn.outputs, {
+          reused: "inline",
+          unrepresentable: "any",
         }) as Record<string, unknown>;
         delete outputSchema.$schema;
       } catch {