ont-run 0.0.6 → 0.0.8

package/dist/index.js

@@ -13892,57 +13892,19 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// src/config/categorical.ts
-function fieldFrom(functionName) {
-  const schema = exports_external.string();
-  schema[FIELD_FROM_METADATA] = { functionName };
-  return schema;
-}
-function hasFieldFromMetadata(schema) {
-  return schema !== null && typeof schema === "object" && FIELD_FROM_METADATA in schema;
-}
-function getFieldFromMetadata(schema) {
-  if (hasFieldFromMetadata(schema)) {
-    return schema[FIELD_FROM_METADATA];
-  }
-  return null;
-}
-function userContext(schema) {
-  const marked = schema;
-  marked[USER_CONTEXT_METADATA] = true;
-  return marked;
-}
-function hasUserContextMetadata(schema) {
-  return schema !== null && typeof schema === "object" && USER_CONTEXT_METADATA in schema && schema[USER_CONTEXT_METADATA] === true;
-}
-function getUserContextFields(schema) {
-  const fields = [];
-  const def = schema._def;
-  if (def?.typeName === "ZodObject" && typeof def.shape === "function") {
-    const shape = def.shape();
-    for (const [key, value] of Object.entries(shape)) {
-      if (hasUserContextMetadata(value)) {
-        fields.push(key);
-      }
-    }
-  }
-  return fields;
-}
-var FIELD_FROM_METADATA, USER_CONTEXT_METADATA;
-var init_categorical = __esm(() => {
-  init_zod();
-  FIELD_FROM_METADATA = Symbol.for("ont:fieldFrom");
-  USER_CONTEXT_METADATA = Symbol.for("ont:userContext");
-});
-
 // src/config/zod-utils.ts
+function isZod3Schema(val) {
+  if (val === null || typeof val !== "object")
+    return false;
+  if ("_def" in val && "safeParse" in val && !("_zod" in val))
+    return true;
+  return false;
+}
 function isZodSchema(val) {
   if (val === null || typeof val !== "object")
     return false;
   if ("_zod" in val && "safeParse" in val)
     return true;
-  if ("_def" in val && "safeParse" in val)
-    return true;
   return false;
 }
 function getZodTypeName(schema) {
@@ -13951,38 +13913,39 @@ function getZodTypeName(schema) {
   const s = schema;
   if (s._zod && typeof s._zod === "object") {
     const zod = s._zod;
+    if (zod.traits && zod.traits instanceof Set) {
+      const traits = Array.from(zod.traits);
+      const zodType = traits.find((t) => t.startsWith("Zod") && !t.startsWith("$") && !t.startsWith("_"));
+      if (zodType)
+        return zodType;
+    }
     if (zod.def && typeof zod.def === "object") {
       const def = zod.def;
       if (typeof def.typeName === "string")
         return def.typeName;
     }
   }
-  if (s._def && typeof s._def === "object") {
-    const def = s._def;
-    if (typeof def.typeName === "string")
-      return def.typeName;
-  }
   return;
 }
 function isZodObject(schema) {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodObject" || typeName === "object";
+  return typeName === "ZodObject";
 }
 function isZodOptional(schema) {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodOptional" || typeName === "optional";
+  return typeName === "ZodOptional";
 }
 function isZodNullable(schema) {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodNullable" || typeName === "nullable";
+  return typeName === "ZodNullable";
 }
 function isZodArray(schema) {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodArray" || typeName === "array";
+  return typeName === "ZodArray";
 }
 function isZodDefault(schema) {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodDefault" || typeName === "default";
+  return typeName === "ZodDefault";
 }
 function getObjectShape(schema) {
   if (!isZodObject(schema))
@@ -13992,12 +13955,15 @@ function getObjectShape(schema) {
     const zod = s._zod;
     if (zod.def && typeof zod.def === "object") {
       const def = zod.def;
-      if (def.shape && typeof def.shape === "object") {
-        return def.shape;
+      if (def.shape) {
+        const shape = def.shape;
+        if (typeof shape === "object" && shape !== null) {
+          return shape;
+        }
       }
     }
   }
-  if (typeof s.shape === "object" && s.shape !== null) {
+  if ("shape" in s && s.shape && typeof s.shape === "object") {
     return s.shape;
   }
   return;
@@ -14012,14 +13978,6 @@ function getInnerSchema(schema) {
         return def.innerType;
     }
   }
-  if (typeof s.unwrap === "function") {
-    return s.unwrap();
-  }
-  if (s._def && typeof s._def === "object") {
-    const def = s._def;
-    if (def.innerType)
-      return def.innerType;
-  }
   return;
 }
 function getArrayElement(schema) {
@@ -14034,11 +13992,53 @@ function getArrayElement(schema) {
         return def.element;
     }
   }
-  if (s.element)
-    return s.element;
   return;
 }
 
+// src/config/categorical.ts
+function fieldFrom(functionName) {
+  const schema = exports_external.string();
+  schema[FIELD_FROM_METADATA] = { functionName };
+  return schema;
+}
+function hasFieldFromMetadata(schema) {
+  return schema !== null && typeof schema === "object" && FIELD_FROM_METADATA in schema;
+}
+function getFieldFromMetadata(schema) {
+  if (hasFieldFromMetadata(schema)) {
+    return schema[FIELD_FROM_METADATA];
+  }
+  return null;
+}
+function userContext(schema) {
+  const marked = schema;
+  marked[USER_CONTEXT_METADATA] = true;
+  return marked;
+}
+function hasUserContextMetadata(schema) {
+  return schema !== null && typeof schema === "object" && USER_CONTEXT_METADATA in schema && schema[USER_CONTEXT_METADATA] === true;
+}
+function getUserContextFields(schema) {
+  const fields = [];
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        if (hasUserContextMetadata(value)) {
+          fields.push(key);
+        }
+      }
+    }
+  }
+  return fields;
+}
+var FIELD_FROM_METADATA, USER_CONTEXT_METADATA;
+var init_categorical = __esm(() => {
+  init_zod();
+  FIELD_FROM_METADATA = Symbol.for("ont:fieldFrom");
+  USER_CONTEXT_METADATA = Symbol.for("ont:userContext");
+});
+
 // node_modules/consola/dist/chunks/prompt.mjs
 var exports_prompt = {};
 __export(exports_prompt, {
@@ -22094,15 +22094,24 @@ var EntityDefinitionSchema = exports_external.object({
 function isFunction(val) {
   return typeof val === "function";
 }
+function validateZodSchema(val, fieldName) {
+  if (isZodSchema(val))
+    return true;
+  if (isZod3Schema(val)) {
+    throw new Error(`${fieldName} appears to be a Zod 3 schema. ont-run requires Zod 4.
+` + `Please upgrade: bun add zod@4`);
+  }
+  return false;
+}
 var FunctionDefinitionSchema = exports_external.object({
   description: exports_external.string(),
   access: exports_external.array(exports_external.string()).min(1),
   entities: exports_external.array(exports_external.string()),
-  inputs: exports_external.custom(isZodSchema, {
-    message: "inputs must be a Zod schema"
+  inputs: exports_external.custom((val) => validateZodSchema(val, "inputs"), {
+    message: "inputs must be a Zod 4 schema"
   }),
-  outputs: exports_external.custom(isZodSchema, {
-    message: "outputs must be a Zod schema"
+  outputs: exports_external.custom((val) => validateZodSchema(val, "outputs"), {
+    message: "outputs must be a Zod 4 schema"
   }).optional(),
   resolver: exports_external.custom(isFunction, {
     message: "resolver must be a function"

package/dist/src/config/categorical.d.ts

@@ -132,7 +132,6 @@ export declare function hasUserContextMetadata(schema: unknown): schema is UserC
 /**
  * Get all userContext field names from a Zod object schema
  *
- * Note: Uses _def.typeName check instead of instanceof to work across
- * module boundaries in bundled CLI.
+ * Note: Uses zod-utils for bundler compatibility (instanceof fails across module boundaries)
  */
 export declare function getUserContextFields(schema: z.ZodType): string[];

package/dist/src/config/zod-utils.d.ts

@@ -1,44 +1,48 @@
 /**
- * Utility functions for inspecting Zod schemas.
- * These use duck typing to work across Zod 3 and Zod 4.
+ * Utility functions for inspecting Zod 4 schemas.
+ * These use duck typing to work across bundle boundaries.
  */
 /**
- * Check if a value is a Zod schema (duck typing to work across bundle boundaries and Zod versions)
+ * Check if a value is a Zod 3 schema (has _def but not _zod)
+ */
+export declare function isZod3Schema(val: unknown): boolean;
+/**
+ * Check if a value is a Zod schema (duck typing to work across bundle boundaries)
  */
 export declare function isZodSchema(val: unknown): boolean;
 /**
- * Get the Zod type name from a schema (works with both Zod 3 and 4)
+ * Get the Zod type name from a schema
  */
 export declare function getZodTypeName(schema: unknown): string | undefined;
 /**
- * Check if schema is a ZodObject (works with both Zod 3 and 4)
+ * Check if schema is a ZodObject
  */
 export declare function isZodObject(schema: unknown): boolean;
 /**
- * Check if schema is a ZodOptional (works with both Zod 3 and 4)
+ * Check if schema is a ZodOptional
  */
 export declare function isZodOptional(schema: unknown): boolean;
 /**
- * Check if schema is a ZodNullable (works with both Zod 3 and 4)
+ * Check if schema is a ZodNullable
  */
 export declare function isZodNullable(schema: unknown): boolean;
 /**
- * Check if schema is a ZodArray (works with both Zod 3 and 4)
+ * Check if schema is a ZodArray
  */
 export declare function isZodArray(schema: unknown): boolean;
 /**
- * Check if schema is a ZodDefault (works with both Zod 3 and 4)
+ * Check if schema is a ZodDefault
  */
 export declare function isZodDefault(schema: unknown): boolean;
 /**
- * Get the shape of a ZodObject schema (works with both Zod 3 and 4)
+ * Get the shape of a ZodObject schema
  */
 export declare function getObjectShape(schema: unknown): Record<string, unknown> | undefined;
 /**
- * Get the inner schema from Optional/Nullable/Default (works with both Zod 3 and 4)
+ * Get the inner schema from Optional/Nullable/Default
  */
 export declare function getInnerSchema(schema: unknown): unknown;
 /**
- * Get the element schema from a ZodArray (works with both Zod 3 and 4)
+ * Get the element schema from a ZodArray
  */
 export declare function getArrayElement(schema: unknown): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ont-run",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Ontology-enforced API framework for AI coding agents",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   "scripts": {
     "dev": "bun run bin/ont.ts",
     "build": "bun build ./src/index.ts --outdir ./dist --target node",
-    "build:cli": "bun build ./bin/ont.ts --outfile ./dist/bin/ont.js --target node --external @modelcontextprotocol/sdk",
+    "build:cli": "bun build ./bin/ont.ts --outfile ./dist/bin/ont.js --target node --external @modelcontextprotocol/sdk --external zod",
     "build:types": "tsc --declaration --emitDeclarationOnly",
     "prepublishOnly": "bun run build && bun run build:cli && bun run build:types",
     "docs": "cd docs && bun run dev",
@@ -34,15 +34,16 @@
     "citty": "^0.1.6",
     "consola": "^3.2.0",
     "hono": "^4.6.0",
-    "open": "^10.0.0",
-    "zod": "4"
+    "open": "^10.0.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "typescript": "^5.5.0"
+    "typescript": "^5.5.0",
+    "zod": "^4.0.0"
   },
   "peerDependencies": {
-    "bun": ">=1.0.0"
+    "bun": ">=1.0.0",
+    "zod": ">=4"
   },
   "peerDependenciesMeta": {
     "bun": {

package/src/config/categorical.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { isZodObject, getObjectShape } from "./zod-utils";
 
 /**
  * Symbol for storing fieldFrom metadata on Zod schemas
@@ -175,19 +176,18 @@ export function hasUserContextMetadata(
 /**
  * Get all userContext field names from a Zod object schema
  *
- * Note: Uses _def.typeName check instead of instanceof to work across
- * module boundaries in bundled CLI.
+ * Note: Uses zod-utils for bundler compatibility (instanceof fails across module boundaries)
  */
 export function getUserContextFields(schema: z.ZodType): string[] {
   const fields: string[] = [];
 
-  // Use _def.typeName check for bundler compatibility (instanceof fails across module boundaries)
-  const def = (schema as unknown as { _def?: { typeName?: string; shape?: () => Record<string, unknown> } })._def;
-  if (def?.typeName === "ZodObject" && typeof def.shape === "function") {
-    const shape = def.shape();
-    for (const [key, value] of Object.entries(shape)) {
-      if (hasUserContextMetadata(value)) {
-        fields.push(key);
+  if (isZodObject(schema)) {
+    const shape = getObjectShape(schema);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        if (hasUserContextMetadata(value)) {
+          fields.push(key);
+        }
       }
     }
   }

package/src/config/schema.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { getFieldFromMetadata, getUserContextFields } from "./categorical.js";
 import {
   isZodSchema,
+  isZod3Schema,
   isZodObject,
   isZodOptional,
   isZodNullable,
@@ -43,6 +44,20 @@ function isFunction(val: unknown): val is (...args: unknown[]) => unknown {
   return typeof val === "function";
 }
 
+/**
+ * Validate that a value is a Zod 4 schema, with helpful error for Zod 3
+ */
+function validateZodSchema(val: unknown, fieldName: string): boolean {
+  if (isZodSchema(val)) return true;
+  if (isZod3Schema(val)) {
+    throw new Error(
+      `${fieldName} appears to be a Zod 3 schema. ont-run requires Zod 4.\n` +
+      `Please upgrade: bun add zod@4`
+    );
+  }
+  return false;
+}
+
 /**
  * Schema for function definition
  */
@@ -50,12 +65,12 @@ export const FunctionDefinitionSchema = z.object({
   description: z.string(),
   access: z.array(z.string()).min(1),
   entities: z.array(z.string()),
-  inputs: z.custom<z.ZodType>(isZodSchema, {
-    message: "inputs must be a Zod schema",
+  inputs: z.custom<z.ZodType>((val) => validateZodSchema(val, "inputs"), {
+    message: "inputs must be a Zod 4 schema",
   }),
   outputs: z
-    .custom<z.ZodType>(isZodSchema, {
-      message: "outputs must be a Zod schema",
+    .custom<z.ZodType>((val) => validateZodSchema(val, "outputs"), {
+      message: "outputs must be a Zod 4 schema",
     })
     .optional(),
   resolver: z.custom<(...args: unknown[]) => unknown>(isFunction, {

package/src/config/zod-utils.ts

@@ -1,107 +1,122 @@
 /**
- * Utility functions for inspecting Zod schemas.
- * These use duck typing to work across Zod 3 and Zod 4.
+ * Utility functions for inspecting Zod 4 schemas.
+ * These use duck typing to work across bundle boundaries.
  */
 
 /**
- * Check if a value is a Zod schema (duck typing to work across bundle boundaries and Zod versions)
+ * 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;
-  // Zod 3 uses _def property
-  if ("_def" in val && "safeParse" in val) return true;
   return false;
 }
 
 /**
- * Get the Zod type name from a schema (works with both Zod 3 and 4)
+ * 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
+  // Zod 4: check _zod.traits for type name
   if (s._zod && typeof s._zod === "object") {
     const zod = s._zod as Record<string, unknown>;
+    // Check traits Set for the Zod type name
+    if (zod.traits && zod.traits instanceof Set) {
+      const traits = Array.from(zod.traits as Set<string>);
+      // Find the main type name (e.g., "ZodObject", "ZodString", etc.)
+      const zodType = traits.find(t => t.startsWith('Zod') && !t.startsWith('$') && !t.startsWith('_'));
+      if (zodType) return zodType;
+    }
+    // Fallback: check _zod.def.typeName for older versions
     if (zod.def && typeof zod.def === "object") {
       const def = zod.def as Record<string, unknown>;
       if (typeof def.typeName === "string") return def.typeName;
     }
   }
-  // Zod 3: check _def.typeName
-  if (s._def && typeof s._def === "object") {
-    const def = s._def as Record<string, unknown>;
-    if (typeof def.typeName === "string") return def.typeName;
-  }
   return undefined;
 }
 
 /**
- * Check if schema is a ZodObject (works with both Zod 3 and 4)
+ * Check if schema is a ZodObject
  */
 export function isZodObject(schema: unknown): boolean {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodObject" || typeName === "object";
+  return typeName === "ZodObject";
 }
 
 /**
- * Check if schema is a ZodOptional (works with both Zod 3 and 4)
+ * Check if schema is a ZodOptional
  */
 export function isZodOptional(schema: unknown): boolean {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodOptional" || typeName === "optional";
+  return typeName === "ZodOptional";
 }
 
 /**
- * Check if schema is a ZodNullable (works with both Zod 3 and 4)
+ * Check if schema is a ZodNullable
  */
 export function isZodNullable(schema: unknown): boolean {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodNullable" || typeName === "nullable";
+  return typeName === "ZodNullable";
 }
 
 /**
- * Check if schema is a ZodArray (works with both Zod 3 and 4)
+ * Check if schema is a ZodArray
  */
 export function isZodArray(schema: unknown): boolean {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodArray" || typeName === "array";
+  return typeName === "ZodArray";
 }
 
 /**
- * Check if schema is a ZodDefault (works with both Zod 3 and 4)
+ * Check if schema is a ZodDefault
  */
 export function isZodDefault(schema: unknown): boolean {
   const typeName = getZodTypeName(schema);
-  return typeName === "ZodDefault" || typeName === "default";
+  return typeName === "ZodDefault";
 }
 
 /**
- * Get the shape of a ZodObject schema (works with both Zod 3 and 4)
+ * 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
+  // Zod 4: shape is in _zod.def.shape (may be a getter)
   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>;
+      if (def.shape) {
+        // In Zod 4, shape might be a getter, so access it
+        const shape = def.shape;
+        if (typeof shape === "object" && shape !== null) {
+          return shape as Record<string, unknown>;
+        }
       }
     }
   }
-  // Zod 3: shape property directly on schema
-  if (typeof s.shape === "object" && s.shape !== null) {
+  // Fallback: try accessing .shape directly on the schema
+  if ('shape' in s && s.shape && typeof s.shape === "object") {
     return s.shape as Record<string, unknown>;
   }
   return undefined;
 }
 
 /**
- * Get the inner schema from Optional/Nullable/Default (works with both Zod 3 and 4)
+ * Get the inner schema from Optional/Nullable/Default
  */
 export function getInnerSchema(schema: unknown): unknown {
   const s = schema as Record<string, unknown>;
@@ -113,19 +128,11 @@ export function getInnerSchema(schema: unknown): unknown {
       if (def.innerType) return def.innerType;
     }
   }
-  // Zod 3: unwrap method or _def.innerType
-  if (typeof s.unwrap === "function") {
-    return (s.unwrap as () => unknown)();
-  }
-  if (s._def && typeof s._def === "object") {
-    const def = s._def as Record<string, unknown>;
-    if (def.innerType) return def.innerType;
-  }
   return undefined;
 }
 
 /**
- * Get the element schema from a ZodArray (works with both Zod 3 and 4)
+ * Get the element schema from a ZodArray
  */
 export function getArrayElement(schema: unknown): unknown {
   if (!isZodArray(schema)) return undefined;
@@ -138,7 +145,5 @@ export function getArrayElement(schema: unknown): unknown {
       if (def.element) return def.element;
     }
   }
-  // Zod 3: element property directly on schema
-  if (s.element) return s.element;
   return undefined;
 }