@botbotgo/agent-harness 0.0.172 → 0.0.173

package/dist/contracts/workspace.d.ts

@@ -84,6 +84,7 @@ export type ParsedToolObject = {
     subprocess?: boolean;
     inputSchemaRef?: string;
     hasModuleSchema?: boolean;
+    modelSchema?: Record<string, unknown>;
     embeddingModelRef?: string;
     backendOperation?: string;
     mcpRef?: string;
@@ -134,6 +135,7 @@ export type CompiledTool = {
     subprocess?: boolean;
     inputSchemaRef?: string;
     hasModuleSchema?: boolean;
+    modelSchema?: Record<string, unknown>;
     embeddingModelRef?: string;
     backendOperation?: string;
     mcpRef?: string;

package/dist/extensions.js

@@ -125,6 +125,7 @@ registerToolKind({
                 subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
                 hasModuleSchema: tool.hasModuleSchema,
+                modelSchema: tool.modelSchema,
                 embeddingModelRef: tool.embeddingModelRef,
                 bundleRefs: [],
                 hitl: tool.hitl
@@ -160,6 +161,7 @@ registerToolKind({
                 subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
                 hasModuleSchema: tool.hasModuleSchema,
+                modelSchema: tool.modelSchema,
                 embeddingModelRef: tool.embeddingModelRef,
                 backendOperation: tool.backendOperation,
                 bundleRefs: [],
@@ -196,6 +198,7 @@ registerToolKind({
                 subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
                 hasModuleSchema: tool.hasModuleSchema,
+                modelSchema: tool.modelSchema,
                 embeddingModelRef: tool.embeddingModelRef,
                 mcpRef: tool.mcpRef,
                 bundleRefs: [],
@@ -238,6 +241,7 @@ registerToolKind({
                 subprocess: tool.subprocess,
                 inputSchemaRef: tool.inputSchemaRef,
                 hasModuleSchema: tool.hasModuleSchema,
+                modelSchema: tool.modelSchema,
                 embeddingModelRef: tool.embeddingModelRef,
                 bundleRefs: [],
                 hitl: tool.hitl

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.171";
+export declare const AGENT_HARNESS_VERSION = "0.0.172";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.171";
+export const AGENT_HARNESS_VERSION = "0.0.172";

package/dist/resource/resource-impl.js

@@ -423,7 +423,14 @@ async function loadFunctionToolModule(tool) {
         const imported = await import(pathToFileURL(isolatedSourcePath).href);
         const implementationName = tool.implementationName ?? tool.id;
         const loaded = loadToolModuleDefinition(imported, implementationName);
-        return { invoke: loaded.invoke, schema: loaded.schema, description: loaded.description, isolatedSourcePath, implementationName };
+        return {
+            invoke: loaded.invoke,
+            schema: loaded.schema,
+            modelSchema: loaded.modelSchema,
+            description: loaded.description,
+            isolatedSourcePath,
+            implementationName,
+        };
     })();
     functionToolModuleCache.set(cacheKey, loading);
     return loading;
@@ -441,6 +448,8 @@ function createFunctionToolResolver(workspace) {
             {
                 name: tool.name,
                 description: tool.description,
+                schema: tool.modelSchema,
+                modelSchema: tool.modelSchema,
                 async invoke(input) {
                     const loaded = await loadFunctionToolModule(tool);
                     const parsedInput = loaded.schema.parse(input ?? {});

package/dist/runtime/adapter/tool/resolved-tool.d.ts

@@ -5,6 +5,7 @@ export type ResolvedToolLike = {
     schema?: {
         parse?: (input: unknown) => unknown;
     };
+    modelSchema?: Record<string, unknown>;
     invoke?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
     call?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
     func?: (input: unknown, config?: Record<string, unknown>) => Promise<unknown> | unknown;
@@ -17,4 +18,9 @@ export declare function normalizeResolvedToolSchema(resolvedTool: ResolvedToolLi
 } | z.ZodObject<{
     [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
 }, z.core.$strip> | z.ZodObject<{}, z.core.$loose> | undefined;
+export declare function normalizeModelFacingToolSchema(resolvedTool: ResolvedToolLike): Record<string, unknown> | {
+    parse?: (input: unknown) => unknown;
+} | z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip> | z.ZodObject<{}, z.core.$loose> | undefined;
 export declare function asStructuredExecutableTool(resolvedTool: unknown, modelFacingName: string, description: string): unknown;

package/dist/runtime/adapter/tool/resolved-tool.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { tool as createLangChainTool } from "@langchain/core/tools";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
 function isZodSchemaLike(value) {
     return typeof value === "object" && value !== null && typeof value.parse === "function";
 }
@@ -10,6 +11,105 @@ function isZodRawShape(value) {
     const entries = Object.values(value);
     return entries.length > 0 && entries.every((entry) => isZodSchemaLike(entry));
 }
+function isJsonSchemaObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getZodLikeTypeName(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const typed = value;
+    if (typeof typed._zod?.def?.type === "string") {
+        return typed._zod.def.type;
+    }
+    if (typeof typed._def?.typeName === "string") {
+        return typed._def.typeName.replace(/^Zod/, "").toLowerCase();
+    }
+    return undefined;
+}
+function getZodLikeInnerSchema(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const typed = value;
+    return typed._zod?.def?.innerType ?? typed._zod?.def?.element ?? typed._zod?.def?.valueType ?? typed._def?.innerType ?? typed._def?.type ?? typed._def?.valueType;
+}
+function getZodLikeObjectShape(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const typed = value;
+    const directShape = typeof typed.shape === "function"
+        ? typed.shape()
+        : typeof typed._def?.shape === "function"
+            ? typed._def.shape()
+            : typed.shape;
+    if (typeof directShape === "object" && directShape !== null && !Array.isArray(directShape)) {
+        return directShape;
+    }
+    const v4Shape = typeof typed._zod?.def?.shape === "function" ? typed._zod.def.shape() : typed._zod?.def?.shape;
+    if (typeof v4Shape === "object" && v4Shape !== null && !Array.isArray(v4Shape)) {
+        return v4Shape;
+    }
+    return undefined;
+}
+function isZodLikeOptional(value) {
+    const typeName = getZodLikeTypeName(value);
+    if (!typeName) {
+        return false;
+    }
+    return typeName === "optional" || typeName === "default" || typeName === "catch";
+}
+function buildBestEffortJsonSchema(value) {
+    const shape = isZodRawShape(value) ? value : getZodLikeObjectShape(value);
+    if (shape) {
+        const properties = Object.fromEntries(Object.entries(shape).map(([key, entry]) => [key, buildBestEffortJsonSchema(getZodLikeInnerSchema(entry) ?? entry) ?? {}]));
+        const required = Object.entries(shape)
+            .filter(([, entry]) => !isZodLikeOptional(entry))
+            .map(([key]) => key);
+        return {
+            type: "object",
+            properties,
+            ...(required.length > 0 ? { required } : {}),
+        };
+    }
+    const typeName = getZodLikeTypeName(value);
+    if (!typeName) {
+        return undefined;
+    }
+    if (typeName === "string") {
+        return { type: "string" };
+    }
+    if (typeName === "number") {
+        return { type: "number" };
+    }
+    if (typeName === "int" || typeName === "integer") {
+        return { type: "integer" };
+    }
+    if (typeName === "boolean") {
+        return { type: "boolean" };
+    }
+    if (typeName === "array") {
+        return {
+            type: "array",
+            items: buildBestEffortJsonSchema(getZodLikeInnerSchema(value)) ?? {},
+        };
+    }
+    if (typeName === "record") {
+        return {
+            type: "object",
+            additionalProperties: buildBestEffortJsonSchema(getZodLikeInnerSchema(value)) ?? {},
+        };
+    }
+    return {};
+}
+function jsonSchemaPreservesShape(schema, expectedKeys) {
+    if (expectedKeys.length === 0 || !isJsonSchemaObject(schema)) {
+        return true;
+    }
+    const properties = isJsonSchemaObject(schema.properties) ? Object.keys(schema.properties) : [];
+    return expectedKeys.every((key) => properties.includes(key));
+}
 export function asRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? { ...value }
@@ -59,6 +159,30 @@ export function normalizeResolvedToolSchema(resolvedTool) {
     }
     return z.object({}).passthrough();
 }
+export function normalizeModelFacingToolSchema(resolvedTool) {
+    if (isJsonSchemaObject(resolvedTool.modelSchema)) {
+        return resolvedTool.modelSchema;
+    }
+    const normalizedSchema = normalizeResolvedToolSchema(resolvedTool);
+    const normalizedJsonSchema = isJsonSchemaObject(normalizedSchema) ? normalizedSchema : undefined;
+    if (normalizedJsonSchema && (normalizedJsonSchema.type === "object" || typeof normalizedJsonSchema.properties === "object")) {
+        return normalizedJsonSchema;
+    }
+    const shape = isZodRawShape(resolvedTool.schema) ? resolvedTool.schema : getZodLikeObjectShape(normalizedSchema);
+    const shapeKeys = shape ? Object.keys(shape) : [];
+    if (shapeKeys.length === 0) {
+        return normalizedSchema;
+    }
+    try {
+        if (jsonSchemaPreservesShape(toJsonSchema(normalizedSchema), shapeKeys)) {
+            return normalizedSchema;
+        }
+    }
+    catch {
+        // Fall through to the best-effort JSON schema below.
+    }
+    return buildBestEffortJsonSchema(resolvedTool.schema ?? normalizedSchema) ?? normalizedSchema;
+}
 export function asStructuredExecutableTool(resolvedTool, modelFacingName, description) {
     if (!hasCallableToolHandler(resolvedTool)) {
         return resolvedTool;
@@ -70,6 +194,6 @@ export function asStructuredExecutableTool(resolvedTool, modelFacingName, descri
     return createLangChainTool(async (input, config) => handler(input, config), {
         name: modelFacingName,
         description,
-        schema: normalizeResolvedToolSchema(resolvedTool),
+        schema: normalizeModelFacingToolSchema(resolvedTool),
     });
 }

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -38,13 +38,17 @@ function mapSingleFieldScalarArg(args, expectedKey, rawArgsInput) {
 }
 export function normalizeToolArgsForSchema(args, schema, rawArgsInput) {
     const schemaDef = isObject(schema) ? schema._def : undefined;
-    const shape = schemaDef
+    const zodShape = schemaDef
         ? isRecord(schemaDef.shape)
             ? schemaDef.shape
             : typeof schemaDef.shape === "function"
                 ? schemaDef.shape()
                 : undefined
         : undefined;
+    const jsonShape = isObject(schema) && isRecord(schema.properties)
+        ? (schema.properties ?? undefined)
+        : undefined;
+    const shape = zodShape && isRecord(zodShape) ? zodShape : jsonShape;
     if (!shape || !isRecord(shape)) {
         return args;
     }

package/dist/tool-modules.d.ts

@@ -4,6 +4,7 @@ export type LoadedToolModule = {
     implementationName: string;
     invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
     schema: ReturnType<typeof normalizeToolSchema>;
+    modelSchema?: Record<string, unknown>;
     hasModuleSchema: boolean;
     description: string;
     retryable?: boolean;

package/dist/tool-modules.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { readSkillMetadata } from "./runtime/support/skill-metadata.js";
-import { TOOL_DEFINITION_MARKER, normalizeToolSchema } from "./tools.js";
+import { TOOL_DEFINITION_MARKER, buildToolJsonSchema, normalizeToolSchema } from "./tools.js";
 const TOOL_MODULE_EXTENSIONS = new Set([".mjs", ".js", ".cjs"]);
 function isToolDefinitionObject(value) {
     return typeof value === "object" && value !== null && value[TOOL_DEFINITION_MARKER] === true;
@@ -20,6 +20,7 @@ function loadToolObjectDefinition(imported, exportName) {
         implementationName: definition.name?.trim() || exportName,
         invoke: definition.invoke,
         schema: normalizeToolSchema(definition.schema),
+        modelSchema: buildToolJsonSchema(definition.schema),
         hasModuleSchema: true,
         description: definition.description.trim(),
         retryable: definition.retryable === true,

package/dist/tools.d.ts

@@ -18,6 +18,7 @@ export type ToolDefinitionObject = {
     invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
     [TOOL_DEFINITION_MARKER]: true;
 };
+export declare function buildToolJsonSchema(schema?: SchemaInput): Record<string, unknown> | undefined;
 export declare function normalizeToolSchema(schema: SchemaInput): ZodTypeAny & {
     shape?: ZodRawShape;
 };

package/dist/tools.js

@@ -3,6 +3,112 @@ export const TOOL_DEFINITION_MARKER = "__agent_harness_tool_definition__";
 function isZodSchema(value) {
     return typeof value === "object" && value !== null && typeof value.parse === "function";
 }
+function getZodLikeTypeName(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const typed = value;
+    if (typeof typed._zod?.def?.type === "string") {
+        return typed._zod.def.type;
+    }
+    if (typeof typed._def?.typeName === "string") {
+        return typed._def.typeName.replace(/^Zod/, "").toLowerCase();
+    }
+    return undefined;
+}
+function getZodLikeObjectShape(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const typed = value;
+    const directShape = typeof typed.shape === "function"
+        ? typed.shape()
+        : typeof typed._def?.shape === "function"
+            ? typed._def.shape()
+            : typed.shape;
+    if (typeof directShape === "object" && directShape !== null && !Array.isArray(directShape)) {
+        return directShape;
+    }
+    const zod4Shape = typeof typed._zod?.def?.shape === "function" ? typed._zod.def.shape() : typed._zod?.def?.shape;
+    if (typeof zod4Shape === "object" && zod4Shape !== null && !Array.isArray(zod4Shape)) {
+        return zod4Shape;
+    }
+    return undefined;
+}
+function getZodLikeInnerSchema(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const typed = value;
+    return typed._zod?.def?.innerType ?? typed._zod?.def?.element ?? typed._zod?.def?.valueType ?? typed._def?.innerType ?? typed._def?.type ?? typed._def?.valueType;
+}
+function buildJsonSchemaFromZodLike(value) {
+    const shape = getZodLikeObjectShape(value);
+    if (shape) {
+        const properties = Object.fromEntries(Object.entries(shape).map(([key, entry]) => [key, buildJsonSchemaFromZodLike(getZodLikeInnerSchema(entry) ?? entry) ?? {}]));
+        const required = Object.entries(shape)
+            .filter(([, entry]) => {
+            const typeName = getZodLikeTypeName(entry);
+            return typeName !== "optional" && typeName !== "default" && typeName !== "catch";
+        })
+            .map(([key]) => key);
+        return {
+            type: "object",
+            properties,
+            ...(required.length > 0 ? { required } : {}),
+        };
+    }
+    const typeName = getZodLikeTypeName(value);
+    switch (typeName) {
+        case "string":
+            return { type: "string" };
+        case "number":
+            return { type: "number" };
+        case "int":
+        case "integer":
+            return { type: "integer" };
+        case "boolean":
+            return { type: "boolean" };
+        case "unknown":
+        case "any":
+            return {};
+        case "array":
+            return {
+                type: "array",
+                items: buildJsonSchemaFromZodLike(getZodLikeInnerSchema(value)) ?? {},
+            };
+        case "record":
+            return {
+                type: "object",
+                additionalProperties: buildJsonSchemaFromZodLike(getZodLikeInnerSchema(value)) ?? {},
+            };
+        case "optional":
+        case "nullable":
+        case "default":
+        case "catch":
+            return buildJsonSchemaFromZodLike(getZodLikeInnerSchema(value)) ?? {};
+        default:
+            return undefined;
+    }
+}
+export function buildToolJsonSchema(schema) {
+    if (!schema) {
+        return undefined;
+    }
+    if (isZodSchema(schema)) {
+        return buildJsonSchemaFromZodLike(schema);
+    }
+    return {
+        type: "object",
+        properties: Object.fromEntries(Object.entries(schema).map(([key, value]) => [key, buildJsonSchemaFromZodLike(value) ?? {}])),
+        required: Object.entries(schema)
+            .filter(([, value]) => {
+            const typeName = getZodLikeTypeName(value);
+            return typeName !== "optional" && typeName !== "default" && typeName !== "catch";
+        })
+            .map(([key]) => key),
+    };
+}
 export function normalizeToolSchema(schema) {
     if (isZodSchema(schema)) {
         return schema;

package/dist/workspace/object-loader.js

@@ -765,6 +765,7 @@ export async function readToolModuleItems(root) {
                     description: definition.description,
                     implementationName: definition.implementationName,
                     hasModuleSchema: definition.hasModuleSchema,
+                    ...(definition.modelSchema ? { modelSchema: definition.modelSchema } : {}),
                     ...(definition.retryable !== undefined ? { retryable: definition.retryable } : {}),
                     ...(definition.memory ? { config: { memory: definition.memory } } : {}),
                 },

package/dist/workspace/resource-compilers.js

@@ -270,6 +270,7 @@ export function parseToolObject(object) {
         subprocess: value.subprocess === true,
         inputSchemaRef: typeof asObject(value.inputSchema)?.ref === "string" ? String(asObject(value.inputSchema)?.ref) : undefined,
         hasModuleSchema: value.hasModuleSchema === true,
+        modelSchema: asObject(value.modelSchema),
         embeddingModelRef: typeof value.embeddingModelRef === "string"
             ? value.embeddingModelRef
             : typeof value.embeddingModel === "string"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.172",
+  "version": "0.0.173",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",