veryfront 0.1.501 → 0.1.503

package/esm/src/skill/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/src/skill/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AA2C7C;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAmD1C;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAkCnD;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAmDnD"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/src/skill/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AA4E7C;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAiD1C;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CA6BnD;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAqCnD"}

package/esm/src/skill/tools.js

@@ -8,7 +8,7 @@
  *
  * @module
  */
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
 import { tool } from "../tool/factory.js";
 import { readTextFile } from "../platform/compat/fs.js";
 import { join } from "../platform/compat/path/index.js";
@@ -20,6 +20,26 @@ import { getSkillScriptExecutor } from "./executor.js";
 import { SKILL_ASSETS_DIR, SKILL_MD_FILENAME, SKILL_REFERENCES_DIR, SKILL_SCRIPTS_DIR, } from "./types.js";
 /** Maximum allowed script execution timeout in milliseconds (5 minutes) */
 const MAX_SCRIPT_TIMEOUT_MS = 300_000;
+const getLoadSkillInputSchema = defineSchema((v) => v.object({
+    skillId: v.string().describe("The ID of the skill to load"),
+}));
+const getLoadSkillReferenceInputSchema = defineSchema((v) => v.object({
+    skillId: v.string().describe("The ID of the skill"),
+    reference: v.string().describe("Relative path to the reference file (e.g. 'references/CLAUSES.md')"),
+}));
+const getExecuteSkillScriptInputSchema = defineSchema((v) => v.object({
+    skillId: v.string().describe("The ID of the skill"),
+    script: v.string().describe("Relative path to the script (e.g. 'scripts/setup.sh')"),
+    args: v.array(v.string()).optional().describe("Arguments to pass to the script"),
+    env: v.record(v.string(), v.string()).optional().describe("Environment variables for the script"),
+    timeoutMs: v
+        .number()
+        .int()
+        .positive()
+        .max(MAX_SCRIPT_TIMEOUT_MS)
+        .optional()
+        .describe(`Optional execution timeout in milliseconds (max ${MAX_SCRIPT_TIMEOUT_MS})`),
+}));
 /**
  * Read a file from a skill directory.
  * Uses skill.fsAdapter if available (VFS/cloud), otherwise falls back to compat readTextFile.
@@ -51,9 +71,7 @@ export function createLoadSkillTool() {
         id: "load-skill",
         description: "Load a skill's full instructions. Returns the skill's markdown instructions, " +
             "allowed tools policy, and lists of available reference files and scripts.",
-        inputSchema: z.object({
-            skillId: z.string().describe("The ID of the skill to load"),
-        }),
+        inputSchema: getLoadSkillInputSchema(),
         execute: async (input) => {
             const skill = skillRegistry.get(input.skillId);
             if (!skill) {
@@ -93,10 +111,7 @@ export function createLoadSkillReferenceTool() {
         id: "load-skill-reference",
         description: "Read a reference file from a skill. Only files in the skill's " +
             "references/ and assets/ directories are accessible.",
-        inputSchema: z.object({
-            skillId: z.string().describe("The ID of the skill"),
-            reference: z.string().describe("Relative path to the reference file (e.g. 'references/CLAUSES.md')"),
-        }),
+        inputSchema: getLoadSkillReferenceInputSchema(),
         execute: async (input) => {
             const skill = skillRegistry.get(input.skillId);
             if (!skill) {
@@ -120,19 +135,7 @@ export function createExecuteSkillScriptTool() {
     return tool({
         id: "execute-skill-script",
         description: "Execute a script from a skill's scripts/ directory. Returns stdout, stderr, and exit code.",
-        inputSchema: z.object({
-            skillId: z.string().describe("The ID of the skill"),
-            script: z.string().describe("Relative path to the script (e.g. 'scripts/setup.sh')"),
-            args: z.array(z.string()).optional().describe("Arguments to pass to the script"),
-            env: z.record(z.string(), z.string()).optional().describe("Environment variables for the script"),
-            timeoutMs: z
-                .number()
-                .int()
-                .positive()
-                .max(MAX_SCRIPT_TIMEOUT_MS)
-                .optional()
-                .describe(`Optional execution timeout in milliseconds (max ${MAX_SCRIPT_TIMEOUT_MS})`),
-        }),
+        inputSchema: getExecuteSkillScriptInputSchema(),
         execute: async (input) => {
             const skill = skillRegistry.get(input.skillId);
             if (!skill) {

package/esm/src/tool/factory.d.ts

@@ -1,5 +1,5 @@
 import type { Tool, ToolConfig, ToolExecutionContext } from "./types.js";
-import type { JsonSchema } from "./schema/json-schema.js";
+import type { JsonSchema } from "../extensions/schema/index.js";
 export declare function tool<TInput = unknown, TOutput = unknown>(config: ToolConfig<TInput, TOutput>): Tool<TInput, TOutput>;
 export interface DynamicToolConfig {
     id?: string;

package/esm/src/tool/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/src/tool/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAuI1D,wBAAgB,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACtD,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCvB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACxF,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;IAC7C,GAAG,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;CACzB;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CA4B7E"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/src/tool/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,+BAA+B,CAAC;AAyJxE,wBAAgB,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACtD,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAqCvB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACxF,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;IAC7C,GAAG,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;CACzB;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CA4B7E"}

package/esm/src/tool/factory.js

@@ -1,6 +1,14 @@
 import { zodToJsonSchema } from "./schema/zod-json-schema.js";
 import { agentLogger } from "../utils/logger/logger.js";
 import { createError, getErrorMessage, toError } from "../errors/veryfront-error.js";
+function isContractSchema(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if ("__zod" in value)
+        return true;
+    return ("_output" in value &&
+        typeof value.parse === "function");
+}
 function hasValidZodTypeName(schema) {
     if (schema === null || typeof schema !== "object")
         return false;
@@ -49,7 +57,10 @@ function logSchemaResult(logPrefix, toolId, method, schema) {
     agentLogger.info(`[${logPrefix}] ${method} schema for "${toolId}": ${Object.keys(schema.properties || {}).length} properties`);
 }
 function convertSchemaToJson(schema, toolId, logPrefix, permissive = false) {
-    if (hasValidZodTypeName(schema)) {
+    // Modern path: contract Schema<T> (defineSchema-produced) — route through
+    // the SchemaValidator contract via zodToJsonSchema (which detects both
+    // wrapped and raw zod shapes).
+    if (isContractSchema(schema) || hasValidZodTypeName(schema)) {
         const result = tryConvert(() => zodToJsonSchema(schema), toolId, logPrefix, permissive, "input schema conversion failed");
         logSchemaResult(logPrefix, toolId, "Pre-converted", result);
         return result;

package/esm/src/tool/host-tools.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema } from "./schema/json-schema.js";
+import type { JsonSchema } from "../extensions/schema/index.js";
 import type { Tool, ToolConfig, ToolExecutionContext, ToolSet } from "./types.js";
 type HostToolExecute = {
     bivarianceHack: (input: unknown, options?: ToolExecutionContext) => Promise<unknown> | unknown;

package/esm/src/tool/host-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host-tools.d.ts","sourceRoot":"","sources":["../../../src/src/tool/host-tools.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAElF,KAAK,eAAe,GAAG;IACrB,cAAc,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAChG,CAAC,gBAAgB,CAAC,CAAC;AAEpB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC;IAC5C,GAAG,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAQ7D,MAAM,WAAW,8BAA8B;IAC7C,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CACnD;AAwCD,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC;AACX,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC"}
+{"version":3,"file":"host-tools.d.ts","sourceRoot":"","sources":["../../../src/src/tool/host-tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,+BAA+B,CAAC;AACxE,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAElF,KAAK,eAAe,GAAG;IACrB,cAAc,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAChG,CAAC,gBAAgB,CAAC,CAAC;AAEpB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC;IAC5C,GAAG,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAQ7D,MAAM,WAAW,8BAA8B;IAC7C,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CACnD;AAmDD,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC;AACX,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC"}

package/esm/src/tool/host-tools.js

@@ -3,9 +3,23 @@ import { dynamicTool, tool } from "./factory.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isZodSchema(value) {
-    if (!isRecord(value) || typeof value.parse !== "function")
+/**
+ * Detect a contract `Schema<T>` (defineSchema-produced wrapper) or a raw
+ * zod schema. Both are accepted during the migration window so host tools
+ * can feed either into the framework without bespoke conversion.
+ */
+function isSchemaLike(value) {
+    if (!isRecord(value))
         return false;
+    if (typeof value.parse !== "function")
+        return false;
+    // Contract Schema<T> brand from the ext-zod adapter.
+    if ("__zod" in value)
+        return true;
+    // defineSchema wrapper without a brand yet — match on the contract surface.
+    if ("_output" in value && typeof value.safeParse === "function")
+        return true;
+    // Raw zod schema (legacy host paths still hand us bare zod instances).
     if (!isRecord(value._def))
         return false;
     return typeof value._def.typeName === "string" || typeof value._def.type === "string";
@@ -13,7 +27,7 @@ function isZodSchema(value) {
 function isHostToolDefinition(value) {
     return (isRecord(value) &&
         typeof value.description === "string" &&
-        isZodSchema(value.inputSchema) &&
+        isSchemaLike(value.inputSchema) &&
         typeof value.execute === "function");
 }
 function defaultToolCallId(toolName) {

package/esm/src/tool/index.d.ts

@@ -1,17 +1,19 @@
 /**
- * Define tools with Zod schemas for agents and MCP.
+ * Define tools with `defineSchema`-built input schemas for agents and MCP.
  *
  * @module tool
  *
  * @example Basic tool
  * ```ts
  * import { tool } from "veryfront/tool";
- * import { z } from "zod";
+ * import { defineSchema } from "veryfront/schemas";
+ *
+ * const getWeatherInputSchema = defineSchema((v) => v.object({ city: v.string() }));
  *
  * const weather = tool({
  *   id: "weather",
  *   description: "Get current weather for a city",
- *   inputSchema: z.object({ city: z.string() }),
+ *   inputSchema: getWeatherInputSchema(),
  *   execute: async ({ city }) => {
  *     const res = await fetch(`https://api.weather.com/${city}`);
  *     return res.json();
@@ -23,12 +25,14 @@
  * ```ts
  * import { tool } from "veryfront/tool";
  * import { agent } from "veryfront/agent";
- * import { z } from "zod";
+ * import { defineSchema } from "veryfront/schemas";
+ *
+ * const getWeatherInputSchema = defineSchema((v) => v.object({ city: v.string() }));
  *
  * const weather = tool({
  *   id: "weather",
  *   description: "Get current weather for a city",
- *   inputSchema: z.object({ city: z.string() }),
+ *   inputSchema: getWeatherInputSchema(),
  *   execute: async ({ city }) => {
  *     const res = await fetch(`https://api.weather.com/${city}`);
  *     return res.json();

package/esm/src/tool/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/tool/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,yBAAyB,CAAC;AAGjC,YAAY,EACV,gBAAgB,EAChB,IAAI,EACJ,UAAU,EACV,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,OAAO,GACR,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,8BAA8B,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACxF,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,eAAe,EACf,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AACxF,YAAY,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AACjE,YAAY,EACV,kBAAkB,EAClB,8BAA8B,EAC9B,WAAW,GACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,gCAAgC,EAChC,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,gCAAgC,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,YAAY,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oCAAoC,EACpC,wCAAwC,EACxC,mCAAmC,EACnC,6BAA6B,EAC7B,uBAAuB,EACvB,gCAAgC,EAChC,uCAAuC,GACxC,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EACV,sCAAsC,EACtC,8BAA8B,EAC9B,qCAAqC,EACrC,uCAAuC,EACvC,kCAAkC,EAClC,gCAAgC,EAChC,qCAAqC,EACrC,8BAA8B,GAC/B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/tool/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,yBAAyB,CAAC;AAGjC,YAAY,EACV,gBAAgB,EAChB,IAAI,EACJ,UAAU,EACV,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,OAAO,GACR,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,8BAA8B,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACxF,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,eAAe,EACf,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AACxF,YAAY,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AACjE,YAAY,EACV,kBAAkB,EAClB,8BAA8B,EAC9B,WAAW,GACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,gCAAgC,EAChC,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,gCAAgC,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,YAAY,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oCAAoC,EACpC,wCAAwC,EACxC,mCAAmC,EACnC,6BAA6B,EAC7B,uBAAuB,EACvB,gCAAgC,EAChC,uCAAuC,GACxC,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EACV,sCAAsC,EACtC,8BAA8B,EAC9B,qCAAqC,EACrC,uCAAuC,EACvC,kCAAkC,EAClC,gCAAgC,EAChC,qCAAqC,EACrC,8BAA8B,GAC/B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}

package/esm/src/tool/index.js

@@ -1,17 +1,19 @@
 /**
- * Define tools with Zod schemas for agents and MCP.
+ * Define tools with `defineSchema`-built input schemas for agents and MCP.
  *
  * @module tool
  *
  * @example Basic tool
  * ```ts
  * import { tool } from "veryfront/tool";
- * import { z } from "zod";
+ * import { defineSchema } from "veryfront/schemas";
+ *
+ * const getWeatherInputSchema = defineSchema((v) => v.object({ city: v.string() }));
  *
  * const weather = tool({
  *   id: "weather",
  *   description: "Get current weather for a city",
- *   inputSchema: z.object({ city: z.string() }),
+ *   inputSchema: getWeatherInputSchema(),
  *   execute: async ({ city }) => {
  *     const res = await fetch(`https://api.weather.com/${city}`);
  *     return res.json();
@@ -23,12 +25,14 @@
  * ```ts
  * import { tool } from "veryfront/tool";
  * import { agent } from "veryfront/agent";
- * import { z } from "zod";
+ * import { defineSchema } from "veryfront/schemas";
+ *
+ * const getWeatherInputSchema = defineSchema((v) => v.object({ city: v.string() }));
  *
  * const weather = tool({
  *   id: "weather",
  *   description: "Get current weather for a city",
- *   inputSchema: z.object({ city: z.string() }),
+ *   inputSchema: getWeatherInputSchema(),
  *   execute: async ({ city }) => {
  *     const res = await fetch(`https://api.weather.com/${city}`);
  *     return res.json();

package/esm/src/tool/remote-source-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-source-tools.d.ts","sourceRoot":"","sources":["../../../src/src/tool/remote-source-tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE/F,MAAM,WAAW,gCAAgC;IAC/C,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAUD,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,SAAS,cAAc,EAAE,EACtC,OAAO,GAAE,IAAI,CAAC,gCAAgC,EAAE,SAAS,CAAM,GAC9D,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAsBxC;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,gCAAqC,GAC7C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAKjD"}
+{"version":3,"file":"remote-source-tools.d.ts","sourceRoot":"","sources":["../../../src/src/tool/remote-source-tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE/F,MAAM,WAAW,gCAAgC;IAC/C,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAkBD,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,SAAS,cAAc,EAAE,EACtC,OAAO,GAAE,IAAI,CAAC,gCAAgC,EAAE,SAAS,CAAM,GAC9D,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAsBxC;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,gCAAqC,GAC7C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAKjD"}

package/esm/src/tool/remote-source-tools.js

@@ -1,5 +1,12 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
 import { dynamicTool } from "./factory.js";
+/**
+ * Permissive input schema used for remote tools whose JSON Schema is
+ * sourced from the remote and we only need a no-op contract `Schema<T>` to
+ * satisfy the runtime input-validation pass. Equivalent to
+ * `z.object({}).passthrough()`.
+ */
+const getRemoteToolPassthroughSchema = defineSchema((v) => v.object({}).passthrough());
 function toToolInputRecord(input) {
     if (typeof input !== "object" || input === null || Array.isArray(input)) {
         return {};
@@ -14,7 +21,7 @@ export function createToolsFromRemoteDefinitions(source, definitions, options =
             dynamicTool({
                 id: toolName,
                 description: definition.description,
-                inputSchema: z.object({}).passthrough(),
+                inputSchema: getRemoteToolPassthroughSchema(),
                 inputSchemaJson: definition.parameters,
                 mcp: {
                     title: definition.title,

package/esm/src/tool/schema/json-schema.d.ts

@@ -1,16 +1,9 @@
-export type JsonSchema = {
-    type?: "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
-    description?: string;
-    enum?: unknown[];
-    const?: unknown;
-    default?: unknown;
-    properties?: Record<string, JsonSchema>;
-    required?: string[];
-    items?: JsonSchema;
-    additionalProperties?: boolean | JsonSchema;
-    anyOf?: JsonSchema[];
-    prefixItems?: JsonSchema[];
-    minItems?: number;
-    maxItems?: number;
-};
+/**
+ * Back-compat re-export. The canonical `JsonSchema` type now lives in
+ * `src/extensions/schema/json-schema.ts` so the `SchemaValidator`
+ * contract can reference it without an upward import.
+ *
+ * @module tool/schema/json-schema
+ */
+export type { JsonSchema } from "../../extensions/schema/json-schema.js";
 //# sourceMappingURL=json-schema.d.ts.map

package/esm/src/tool/schema/json-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../../../src/src/tool/schema/json-schema.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;IACjF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,oBAAoB,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IAC5C,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC"}
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../../../src/src/tool/schema/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC"}

package/esm/src/tool/schema/json-schema.js

@@ -1 +1,8 @@
+/**
+ * Back-compat re-export. The canonical `JsonSchema` type now lives in
+ * `src/extensions/schema/json-schema.ts` so the `SchemaValidator`
+ * contract can reference it without an upward import.
+ *
+ * @module tool/schema/json-schema
+ */
 export {};

package/esm/src/tool/schema/zod-json-schema.d.ts

@@ -1,5 +1,34 @@
-import type { z } from "zod";
-import type { JsonSchema } from "./json-schema.js";
-export declare function zodToJsonSchema(schema: z.ZodTypeAny): JsonSchema;
-export declare function isOptionalSchema(schema: z.ZodTypeAny): boolean;
+/**
+ * Schema → JSON Schema conversion shim.
+ *
+ * Historically this module was the in-tree zod-to-JSON-Schema converter.
+ * After Phase B2 the conversion lives behind the `SchemaValidator`
+ * contract (`toJsonSchema` / `isOptional`) and the zod-aware logic moved
+ * to `extensions/ext-zod/src/json-schema.ts`. This file is kept as a
+ * back-compat surface so existing callers (`tool/registry.ts`,
+ * `tool/factory.ts`, `workflow/registry.ts`, `routing/api/openapi/...`,
+ * `mcp/server.ts`, `cli/mcp/server.ts`) continue to compile.
+ *
+ * Inputs may be either an opaque `Schema<T>` produced by `defineSchema`
+ * (the modern path) or a raw zod schema (legacy path during the migration
+ * window). Both shapes are routed through the `SchemaValidator` contract
+ * so no zod-specific logic remains in this file.
+ *
+ * @module tool/schema/zod-json-schema
+ */
+import type { JsonSchema } from "../../extensions/schema/index.js";
+/**
+ * Convert a `Schema<T>` (or, transitionally, a raw zod schema) into a
+ * JSON Schema document.
+ *
+ * Throws if the input is neither a contract schema nor a raw zod schema —
+ * matches the pre-B2 behavior of the original `zodToJsonSchema` guard.
+ */
+export declare function zodToJsonSchema(schema: unknown): JsonSchema;
+/**
+ * Returns `true` when the schema permits `undefined`. Accepts both
+ * contract `Schema<T>` and raw zod schemas for the same compatibility
+ * reasons as `zodToJsonSchema` above.
+ */
+export declare function isOptionalSchema(schema: unknown): boolean;
 //# sourceMappingURL=zod-json-schema.d.ts.map

package/esm/src/tool/schema/zod-json-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod-json-schema.d.ts","sourceRoot":"","sources":["../../../../src/src/tool/schema/zod-json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AA0CnD,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,CAUhE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,GAAG,OAAO,CAE9D"}
+{"version":3,"file":"zod-json-schema.d.ts","sourceRoot":"","sources":["../../../../src/src/tool/schema/zod-json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,kCAAkC,CAAC;AAqC3E;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAQ3D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAQzD"}

package/esm/src/tool/schema/zod-json-schema.js

@@ -1,169 +1,80 @@
-import { INVALID_ARGUMENT } from "../../errors/index.js";
-const LITERAL_TYPE_MAP = {
-    string: "string",
-    number: "number",
-    boolean: "boolean",
-};
-function getLiteralType(value) {
-    return LITERAL_TYPE_MAP[typeof value];
+/**
+ * Schema → JSON Schema conversion shim.
+ *
+ * Historically this module was the in-tree zod-to-JSON-Schema converter.
+ * After Phase B2 the conversion lives behind the `SchemaValidator`
+ * contract (`toJsonSchema` / `isOptional`) and the zod-aware logic moved
+ * to `extensions/ext-zod/src/json-schema.ts`. This file is kept as a
+ * back-compat surface so existing callers (`tool/registry.ts`,
+ * `tool/factory.ts`, `workflow/registry.ts`, `routing/api/openapi/...`,
+ * `mcp/server.ts`, `cli/mcp/server.ts`) continue to compile.
+ *
+ * Inputs may be either an opaque `Schema<T>` produced by `defineSchema`
+ * (the modern path) or a raw zod schema (legacy path during the migration
+ * window). Both shapes are routed through the `SchemaValidator` contract
+ * so no zod-specific logic remains in this file.
+ *
+ * @module tool/schema/zod-json-schema
+ */
+import { isOptionalSchema as schemaIsOptional, schemaToJsonSchema, } from "../../schemas/json-schema.js";
+/** Detect contract `Schema<T>` (carries a `__zod` brand from the ext-zod adapter). */
+function isContractSchema(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if ("__zod" in value)
+        return true;
+    // Fallback: defineSchema-produced wrappers expose `_output`, `parse`, and
+    // `safeParse`. Some test doubles may construct these directly.
+    return ("_output" in value &&
+        typeof value.parse === "function" &&
+        typeof value.safeParse === "function");
 }
-function getDef(schema) {
-    return schema._def;
+/** Detect a raw zod schema: object with `_def` carrying `typeName` (v3) or `type` (v4). */
+function isRawZodSchema(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if (!("_def" in value))
+        return false;
+    const def = value._def;
+    if (!def || typeof def !== "object")
+        return false;
+    return typeof def.typeName === "string" || typeof def.type === "string";
 }
-/** Get the internal type tag from a zod schema (_def.typeName in v3, _def.type in v4). */
-function getTypeTag(schema) {
-    const def = getDef(schema);
-    return def.typeName ?? def.type;
+/**
+ * Adapter that wraps a raw zod schema in the contract's `Schema<unknown>`
+ * shape so the contract's `toJsonSchema` / `isOptional` can unwrap it via
+ * the `__zod` brand.
+ */
+function wrapRawZod(value) {
+    return { __zod: value };
 }
+/**
+ * Convert a `Schema<T>` (or, transitionally, a raw zod schema) into a
+ * JSON Schema document.
+ *
+ * Throws if the input is neither a contract schema nor a raw zod schema —
+ * matches the pre-B2 behavior of the original `zodToJsonSchema` guard.
+ */
 export function zodToJsonSchema(schema) {
-    // Guard against invalid schemas (can happen with different zod instances in npm bundle)
-    if (!schema || typeof schema !== "object" || !("_def" in schema)) {
-        throw INVALID_ARGUMENT.create({ detail: "Invalid Zod schema: missing _def property" });
+    if (isContractSchema(schema)) {
+        return schemaToJsonSchema(schema);
     }
-    const { schema: unwrapped, nullable } = unwrapSchema(schema);
-    const json = convert(unwrapped);
-    return nullable ? { anyOf: [json, { type: "null" }] } : json;
+    if (isRawZodSchema(schema)) {
+        return schemaToJsonSchema(wrapRawZod(schema));
+    }
+    throw new Error("Invalid Zod schema: missing _def property");
 }
+/**
+ * Returns `true` when the schema permits `undefined`. Accepts both
+ * contract `Schema<T>` and raw zod schemas for the same compatibility
+ * reasons as `zodToJsonSchema` above.
+ */
 export function isOptionalSchema(schema) {
-    return unwrapSchema(schema).optional;
-}
-function convert(schema) {
-    const tag = getTypeTag(schema);
-    const def = getDef(schema);
-    switch (tag) {
-        case "ZodString":
-        case "string":
-            return { type: "string" };
-        case "ZodNumber":
-        case "number":
-            return { type: "number" };
-        case "ZodBoolean":
-        case "boolean":
-            return { type: "boolean" };
-        case "ZodBigInt":
-        case "bigint":
-            return { type: "integer" };
-        case "ZodLiteral":
-        case "literal": {
-            // v3: _def.value, v4: _def.values (array of accepted values)
-            const literal = def.value ?? (Array.isArray(def.values) ? def.values[0] : def.values);
-            return { const: literal, type: getLiteralType(literal) };
-        }
-        case "ZodEnum":
-        case "ZodNativeEnum":
-        case "enum": {
-            // v3: _def.values (array), v4: _def.entries (object {key: value})
-            const values = def.values ?? (def.entries ? Object.values(def.entries) : []);
-            if (Array.isArray(values)) {
-                return { type: "string", enum: values };
-            }
-            // Native enum: filter out reverse-mapped numeric keys
-            return {
-                enum: Object.values(values).filter((value) => typeof value !== "number"),
-            };
-        }
-        case "ZodObject":
-        case "object": {
-            const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-            const properties = {};
-            const required = [];
-            for (const [key, value] of Object.entries(shape ?? {})) {
-                const zodSchema = value;
-                properties[key] = zodToJsonSchema(zodSchema);
-                if (!isOptionalSchema(zodSchema))
-                    required.push(key);
-            }
-            const json = { type: "object", properties };
-            if (required.length)
-                json.required = required;
-            return json;
-        }
-        case "ZodArray":
-        case "array": {
-            // v3: _def.type (item schema), v4: _def.element (item schema)
-            const itemType = def.element ?? def.type;
-            if (!itemType || typeof itemType === "string")
-                return { type: "array" };
-            return { type: "array", items: zodToJsonSchema(itemType) };
-        }
-        case "ZodTuple":
-        case "tuple": {
-            const items = def.items ?? [];
-            return {
-                type: "array",
-                prefixItems: items.map((item) => zodToJsonSchema(item)),
-                minItems: items.length,
-                maxItems: items.length,
-            };
-        }
-        case "ZodUnion":
-        case "ZodDiscriminatedUnion":
-        case "union": {
-            const options = def.options ?? [];
-            const optionArray = options instanceof Map ? Array.from(options.values()) : options;
-            return { anyOf: optionArray.map((option) => zodToJsonSchema(option)) };
-        }
-        case "ZodRecord":
-        case "record": {
-            const valueSchema = def.valueType ?? def.element;
-            if (!valueSchema)
-                return { type: "object" };
-            return { type: "object", additionalProperties: zodToJsonSchema(valueSchema) };
-        }
-        case "ZodDefault":
-        case "default": {
-            const innerType = def.innerType ?? def.schema;
-            if (!innerType)
-                return { type: "object" };
-            const inner = zodToJsonSchema(innerType);
-            const defaultValue = typeof def.defaultValue === "function"
-                ? def.defaultValue()
-                : def.defaultValue;
-            if (typeof inner === "object" && !("anyOf" in inner) && defaultValue !== undefined) {
-                inner.default = defaultValue;
-            }
-            return inner;
-        }
-        case "ZodLazy":
-        case "lazy":
-            return def.getter ? convert(def.getter()) : { type: "object" };
-        case "ZodEffects":
-        case "pipe": {
-            // v3: ZodEffects wraps schema in _def.schema
-            // v4: pipe wraps in _def.in (input schema)
-            const innerSchema = def.schema ?? def.in;
-            return innerSchema ? convert(innerSchema) : { type: "object" };
-        }
-        default:
-            return { type: "object" };
+    if (isContractSchema(schema)) {
+        return schemaIsOptional(schema);
     }
-}
-function unwrapSchema(schema) {
-    let current = schema;
-    let nullable = false;
-    let optional = false;
-    while (true) {
-        const tag = getTypeTag(current);
-        const def = getDef(current);
-        switch (tag) {
-            case "ZodNullable":
-            case "nullable":
-                nullable = true;
-                current = (def.innerType ?? def.schema);
-                break;
-            case "ZodOptional":
-            case "optional":
-                optional = true;
-                current = (def.innerType ?? def.schema);
-                break;
-            case "ZodEffects":
-            case "pipe":
-                current = def.schema ?? def.in ?? current;
-                if (current === schema)
-                    return { schema: current, nullable, optional };
-                break;
-            default:
-                return { schema: current, nullable, optional };
-        }
+    if (isRawZodSchema(schema)) {
+        return schemaIsOptional(wrapRawZod(schema));
     }
+    return false;
 }