vovk 3.0.0-draft.99 → 3.0.0

package/dist/samples/schemaToObject.js

@@ -0,0 +1,164 @@
+export function schemaToObject(schema, rootSchema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    // Use the input schema as the root if not provided
+    rootSchema = rootSchema || schema;
+    // If there's an example, use it
+    if (schema.example !== undefined) {
+        return schema.example;
+    }
+    // If there are examples, use one of them
+    if (schema.examples && schema.examples.length > 0) {
+        return schema.examples[0];
+    }
+    // Handle const if present
+    if (schema.const !== undefined) {
+        return schema.const;
+    }
+    // Handle $ref if present
+    if (schema.$ref) {
+        return handleRef(schema.$ref, rootSchema);
+    }
+    // Handle enum if present
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum[0];
+    }
+    // Handle oneOf, anyOf, allOf
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        return schemaToObject(schema.oneOf[0], rootSchema);
+    }
+    if (schema.anyOf && schema.anyOf.length > 0) {
+        return schemaToObject(schema.anyOf[0], rootSchema);
+    }
+    if (schema.allOf && schema.allOf.length > 0) {
+        // Merge all schemas in allOf
+        const mergedSchema = schema.allOf.reduce((acc, s) => ({ ...acc, ...s }), {});
+        return schemaToObject(mergedSchema, rootSchema);
+    }
+    // Handle different types
+    if (schema.type) {
+        switch (schema.type) {
+            case 'string':
+                return handleString(schema);
+            case 'number':
+            case 'integer':
+                return handleNumber(schema);
+            case 'boolean':
+                return handleBoolean();
+            case 'object':
+                return handleObject(schema, rootSchema);
+            case 'array':
+                return handleArray(schema, rootSchema);
+            case 'null':
+                return null;
+            default:
+                return null;
+        }
+    }
+    // If type is not specified but properties are, treat it as an object
+    if (schema.properties) {
+        return handleObject(schema, rootSchema);
+    }
+    // Default fallback
+    return null;
+}
+function handleRef(ref, rootSchema) {
+    // Parse the reference path
+    const path = ref.split('/').slice(1); // Remove the initial '#'
+    // Navigate through the schema to find the referenced definition
+    let current = rootSchema;
+    for (const segment of path) {
+        current = current[segment];
+        if (current === undefined) {
+            return null; // Reference not found
+        }
+    }
+    // Process the referenced schema
+    return schemaToObject(current, rootSchema);
+}
+function handleString(schema) {
+    if (schema.format) {
+        switch (schema.format) {
+            case 'email':
+            case 'idn-email':
+                return 'user@example.com';
+            case 'uri':
+            case 'url':
+            case 'iri':
+                return 'https://example.com';
+            case 'date':
+                return '2023-01-01';
+            case 'date-time':
+                return '2023-01-01T00:00:00Z';
+            case 'time':
+                return '12:00:00Z';
+            case 'duration':
+                return 'PT1H';
+            case 'uuid':
+                return '00000000-0000-0000-0000-000000000000';
+            case 'regex':
+                return '^[a-zA-Z0-9]+$';
+            case 'relative-json-pointer':
+                return '/some/relative/path';
+            case 'color':
+                return '#000000';
+            case 'hostname':
+                return 'example.com';
+            case 'zipcode':
+                return '12345';
+            case 'phone':
+                return '+123-456-7890';
+            case 'password':
+                return '******';
+            default:
+                return 'string';
+        }
+    }
+    if (schema.pattern) {
+        // For simplicity, return a basic string for patterns
+        return 'pattern-string';
+    }
+    return 'string';
+}
+function handleNumber(schema) {
+    if (schema.minimum !== undefined && schema.maximum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.minimum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.maximum !== undefined) {
+        return schema.maximum;
+    }
+    return 0;
+}
+function handleBoolean() {
+    return true;
+}
+function handleObject(schema, rootSchema) {
+    const result = {};
+    if (schema.properties) {
+        const required = schema.required || [];
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            // Only include required properties or as a basic example
+            if (required.includes(key) || required.length === 0) {
+                result[key] = schemaToObject(propSchema, rootSchema);
+            }
+        }
+    }
+    // Handle additionalProperties
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        result['additionalProp'] = schemaToObject(schema.additionalProperties, rootSchema);
+    }
+    return result;
+}
+function handleArray(schema, rootSchema) {
+    if (schema.items && typeof schema.items === 'object') {
+        const itemSchema = schema.items;
+        const minItems = schema.minItems || 1;
+        // Create minimum number of items (capped at a reasonable max for examples)
+        const numItems = Math.min(minItems, 3);
+        return Array.from({ length: numItems }, () => schemaToObject(itemSchema, rootSchema));
+    }
+    return [];
+}

package/dist/samples/schemaToTsType.d.ts

@@ -0,0 +1,2 @@
+import { VovkJSONSchemaBase } from 'vovk';
+export declare function schemaToTsType(jsonSchema: VovkJSONSchemaBase | boolean): string;

package/dist/samples/schemaToTsType.js

@@ -0,0 +1,114 @@
+export function schemaToTsType(jsonSchema) {
+    if (jsonSchema === true)
+        return 'unknown';
+    if (jsonSchema === false)
+        return 'never';
+    if (jsonSchema === null || jsonSchema === undefined)
+        return 'unknown';
+    if (typeof jsonSchema !== 'object')
+        return 'unknown';
+    // Handle const
+    if ('const' in jsonSchema) {
+        return JSON.stringify(jsonSchema.const);
+    }
+    // Handle enum
+    if (jsonSchema.enum) {
+        return jsonSchema.enum.map((v) => JSON.stringify(v)).join(' | ') || 'never';
+    }
+    // Handle allOf (intersection)
+    if (jsonSchema.allOf) {
+        const parts = jsonSchema.allOf.map((s) => schemaToTsType(s));
+        return parts.length ? `(${parts.join(' & ')})` : 'unknown';
+    }
+    // Handle anyOf (union)
+    if (jsonSchema.anyOf) {
+        const parts = jsonSchema.anyOf.map((s) => schemaToTsType(s));
+        return parts.length ? `(${parts.join(' | ')})` : 'never';
+    }
+    // Handle oneOf (union)
+    if (jsonSchema.oneOf) {
+        const parts = jsonSchema.oneOf.map((s) => schemaToTsType(s));
+        return parts.length ? `(${parts.join(' | ')})` : 'never';
+    }
+    // Handle not (negate - approximate as unknown)
+    if (jsonSchema.not) {
+        return 'unknown';
+    }
+    // Handle type as array (union of types)
+    if (Array.isArray(jsonSchema.type)) {
+        const types = jsonSchema.type.map((t) => schemaToTsType({ ...jsonSchema, type: t }));
+        return types.length ? `(${types.join(' | ')})` : 'unknown';
+    }
+    const type = jsonSchema.type;
+    // Primitives
+    if (type === 'string')
+        return 'string';
+    if (type === 'number' || type === 'integer')
+        return 'number';
+    if (type === 'boolean')
+        return 'boolean';
+    if (type === 'null')
+        return 'null';
+    // Object
+    if (type === 'object' || jsonSchema.properties || jsonSchema.additionalProperties !== undefined) {
+        const props = jsonSchema.properties || {};
+        const required = jsonSchema.required || [];
+        const propEntries = Object.entries(props);
+        const propStrings = propEntries.map(([key, value]) => {
+            const isRequired = required.includes(key);
+            const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+            return `${safeName}${isRequired ? '' : '?'}: ${schemaToTsType(value)}`;
+        });
+        // Handle additionalProperties
+        let additionalType = null;
+        if (jsonSchema.additionalProperties === true) {
+            additionalType = 'unknown';
+        }
+        else if (jsonSchema.additionalProperties && typeof jsonSchema.additionalProperties === 'object') {
+            additionalType = schemaToTsType(jsonSchema.additionalProperties);
+        }
+        if (propStrings.length === 0 && additionalType) {
+            return `{ [key: string]: ${additionalType} }`;
+        }
+        if (propStrings.length === 0 && !additionalType) {
+            return jsonSchema.additionalProperties === false ? '{}' : '{ [key: string]: unknown }';
+        }
+        let result = `{ ${propStrings.join('; ')} }`;
+        if (additionalType) {
+            result = `(${result} & { [key: string]: ${additionalType} })`;
+        }
+        return result;
+    }
+    // Array
+    if (type === 'array' || jsonSchema.items || jsonSchema.prefixItems) {
+        // Tuple (prefixItems)
+        if (jsonSchema.prefixItems) {
+            const tupleTypes = jsonSchema.prefixItems.map((s) => schemaToTsType(s));
+            if (jsonSchema.items === false) {
+                return `[${tupleTypes.join(', ')}]`;
+            }
+            const restType = jsonSchema.items ? schemaToTsType(jsonSchema.items) : 'unknown';
+            return `[${tupleTypes.join(', ')}, ...${restType}[]]`;
+        }
+        // Regular array
+        if (jsonSchema.items) {
+            if (Array.isArray(jsonSchema.items)) {
+                // Legacy tuple syntax
+                const tupleTypes = jsonSchema.items.map((s) => schemaToTsType(s));
+                if (jsonSchema.additionalItems === false) {
+                    return `[${tupleTypes.join(', ')}]`;
+                }
+                const restType = jsonSchema.additionalItems ? schemaToTsType(jsonSchema.additionalItems) : 'unknown';
+                return `[${tupleTypes.join(', ')}, ...${restType}[]]`;
+            }
+            return `${schemaToTsType(jsonSchema.items)}[]`;
+        }
+        return 'unknown[]';
+    }
+    // No type specified - try to infer from structure
+    if (jsonSchema.properties) {
+        return schemaToTsType({ ...jsonSchema, type: 'object' });
+    }
+    // Fallback for empty or unknown schema
+    return 'unknown';
+}

package/dist/tools/ToModelOutput.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Collection of functions to convert model outputs into different formats.
+ * @see https://vovk.dev/tools
+ */
+export declare const ToModelOutput: {
+    readonly DEFAULT: import("./toModelOutputDefault.js").ToModelOutputDefaultFn;
+    readonly MCP: <TOutput>(result: TOutput | Error, tool: import("../index.js").VovkTool, req: Pick<import("../index.js").VovkRequest, "vovk"> | null) => Promise<import("./toModelOutputMCP.js").MCPModelOutput>;
+};

package/dist/tools/ToModelOutput.js

@@ -0,0 +1,10 @@
+import { toModelOutputDefault } from './toModelOutputDefault.js';
+import { toModelOutputMCP } from './toModelOutputMCP.js';
+/**
+ * Collection of functions to convert model outputs into different formats.
+ * @see https://vovk.dev/tools
+ */
+export const ToModelOutput = {
+    DEFAULT: toModelOutputDefault,
+    MCP: toModelOutputMCP,
+};

package/dist/tools/createTool.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Function to create a standalone AI tool.
+ * @see https://vovk.dev/tools
+ */
+export declare const createTool: {
+    <TInput, TOutput, TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => import("../types/utils.js").KnownAny>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema: import("../types/validation.js").CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema: import("../types/validation.js").CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): import("../internal.js").VovkToolNonDerived<TInput, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+    <TInput, TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema: import("../types/validation.js").CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema: import("../types/validation.js").CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): import("../internal.js").VovkToolNonDerived<TInput, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>;
+    <TInput, TOutput, TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => import("../types/utils.js").KnownAny>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema: import("../types/validation.js").CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): import("../internal.js").VovkToolNonDerived<TInput, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+    <TInput, TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<TInput, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema: import("../types/validation.js").CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): import("../internal.js").VovkToolNonDerived<TInput, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>;
+    <TOutput, TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => import("../types/utils.js").KnownAny>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema: import("../types/validation.js").CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): import("../internal.js").VovkToolNonDerived<null, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+    <TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema: import("../types/validation.js").CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): import("../internal.js").VovkToolNonDerived<null, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>;
+    <TOutput, TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => import("../types/utils.js").KnownAny>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): import("../internal.js").VovkToolNonDerived<null, TOutput, TToModelOutput extends import("./toModelOutputDefault.js").ToModelOutputDefaultFn ? import("./toModelOutputDefault.js").DefaultModelOutput<TOutput> : TToModelOutput extends (...args: import("../types/utils.js").KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown>;
+    <TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: import("../internal.js").VovkToolNonDerived<null, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: import("../types/validation.js").CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): import("../internal.js").VovkToolNonDerived<null, TOutput, import("./toModelOutputDefault.js").DefaultModelOutput<TOutput>>;
+};

package/dist/tools/createTool.js

@@ -0,0 +1,6 @@
+import { procedure } from '../validation/procedure.js';
+/**
+ * Function to create a standalone AI tool.
+ * @see https://vovk.dev/tools
+ */
+export const createTool = procedure.createTool;

package/dist/tools/createToolFactory.d.ts

@@ -0,0 +1,135 @@
+import type { VovkValidationType } from '../types/core.js';
+import type { VovkToolNonDerived } from '../types/tools.js';
+import type { DefaultModelOutput, ToModelOutputDefaultFn } from './toModelOutputDefault.js';
+import type { CombinedSpec } from '../types/validation.js';
+import type { KnownAny } from '../types/utils.js';
+type InferFormattedOutput<TFn, TOutput> = TFn extends ToModelOutputDefaultFn ? DefaultModelOutput<TOutput> : TFn extends (...args: KnownAny[]) => infer R ? R extends Promise<infer U> ? U : R : unknown;
+type AnyToModelOutputFn = (...args: KnownAny[]) => KnownAny;
+export declare function createToolFactory({ toJSONSchema, }: {
+    toJSONSchema: (model: KnownAny, meta: {
+        validationType: VovkValidationType;
+        target: CombinedSpec.Target | undefined;
+    }) => KnownAny;
+}): {
+    <TInput, TOutput, TToModelOutput extends AnyToModelOutputFn>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<TInput, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<TInput, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema: CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema: CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): VovkToolNonDerived<TInput, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>;
+    <TInput, TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<TInput, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<TInput, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema: CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema: CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): VovkToolNonDerived<TInput, TOutput, DefaultModelOutput<TOutput>>;
+    <TInput, TOutput, TToModelOutput extends AnyToModelOutputFn>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<TInput, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<TInput, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema: CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): VovkToolNonDerived<TInput, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>;
+    <TInput, TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<TInput, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<TInput, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema: CombinedSpec<TInput, TInput>;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: TInput, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): VovkToolNonDerived<TInput, TOutput, DefaultModelOutput<TOutput>>;
+    <TOutput, TToModelOutput extends AnyToModelOutputFn>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<null, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<null, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema: CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): VovkToolNonDerived<null, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>;
+    <TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<null, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<null, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema: CombinedSpec<TOutput, TOutput>;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): VovkToolNonDerived<null, TOutput, DefaultModelOutput<TOutput>>;
+    <TOutput, TToModelOutput extends AnyToModelOutputFn>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<null, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<null, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput: TToModelOutput;
+    }): VovkToolNonDerived<null, TOutput, InferFormattedOutput<TToModelOutput, TOutput>>;
+    <TOutput>(options: {
+        name: string;
+        title?: string;
+        description: string;
+        onExecute?: ((result: unknown, tool: VovkToolNonDerived<null, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        onError?: ((error: Error, tool: VovkToolNonDerived<null, TOutput, DefaultModelOutput<TOutput>>) => void) | undefined;
+        target?: CombinedSpec.Target;
+    } & {
+        inputSchema?: undefined;
+    } & {
+        outputSchema?: undefined;
+    } & {
+        execute: (input: null, processingMeta?: unknown) => TOutput | Promise<TOutput>;
+        toModelOutput?: undefined;
+    }): VovkToolNonDerived<null, TOutput, DefaultModelOutput<TOutput>>;
+};
+export {};

package/dist/tools/createToolFactory.js

@@ -0,0 +1,61 @@
+import { ToModelOutput } from './ToModelOutput.js';
+export function createToolFactory({ toJSONSchema, }) {
+    // Implementation
+    function createTool({ name, title, description, toModelOutput = ToModelOutput.DEFAULT, onExecute, onError, inputSchema, outputSchema, execute, target, }) {
+        let parameters;
+        const tool = {
+            type: 'function',
+            name,
+            title,
+            description,
+            get parameters() {
+                return (parameters ??= inputSchema ? toJSONSchema(inputSchema, { validationType: 'tool-input', target }) : {});
+            },
+            inputSchema: inputSchema,
+            outputSchema: outputSchema,
+            inputSchemas: undefined,
+            async execute(input, processingMeta) {
+                let result;
+                try {
+                    let validatedInput;
+                    if (inputSchema) {
+                        const validatedInputResult = await inputSchema['~standard'].validate(input);
+                        if (validatedInputResult.issues?.length) {
+                            throw new Error(`Input validation failed. ${validatedInputResult.issues
+                                .map(({ message, path }) => `${message}${path ? ` at ${path.join('.')}` : ''}`)
+                                .join(', ')}`);
+                        }
+                        validatedInput = validatedInputResult.value;
+                    }
+                    else {
+                        validatedInput = null;
+                    }
+                    result = await execute(validatedInput, processingMeta);
+                    if (outputSchema) {
+                        const validatedOutputResult = await outputSchema['~standard'].validate(result);
+                        if (validatedOutputResult.issues?.length) {
+                            throw new Error(`Output validation failed. ${validatedOutputResult.issues
+                                .map(({ message, path }) => `${message}${path ? ` at ${path.join('.')}` : ''}`)
+                                .join(', ')}`);
+                        }
+                        result = validatedOutputResult.value;
+                    }
+                    onExecute?.(result, tool);
+                }
+                catch (e) {
+                    onError?.(e, tool);
+                    result = e;
+                }
+                if (result instanceof Error) {
+                    result.toJSON = () => ({
+                        isError: true,
+                        message: result.message,
+                    });
+                }
+                return toModelOutput(result, tool, null);
+            },
+        };
+        return tool;
+    }
+    return createTool;
+}