vovk 3.7.0 → 4.0.0-beta.0

package/dist/openapi/openapi-to-vovk-schema/prune-components-schemas.js

@@ -1,6 +1,4 @@
-// Collect the trailing name of every `$ref` in the tree. Covers both pointer styles
-// the transform emits: `#/components/schemas/X` (response slots, raw operation objects)
-// and `#/$defs/X` (request slots embed components under their original names).
+// collects the trailing name of every $ref in the tree, both `#/components/schemas/X` and `#/$defs/X` styles
 function collectRefNames(node, into) {
     if (!node || typeof node !== 'object')
         return;
@@ -21,11 +19,8 @@ function collectRefNames(node, into) {
         }
     }
 }
-/**
- * Shrinks a `components.schemas` dict to the transitive `$ref` closure of `roots`
- * (BFS with a visited set — component graphs of large specs like Stripe are cyclic).
- * Preserves the original key order for deterministic output.
- */
+// shrinks components.schemas to the transitive $ref closure of roots, BFS with a visited set
+// (big specs like Stripe are cyclic); preserves key order for deterministic output
 export function pruneComponentsSchemas(roots, componentsSchemas) {
     const required = new Set();
     collectRefNames(roots, required);

package/dist/openapi/vovk-schema-to-openapi.d.ts

@@ -1,5 +1,5 @@
 import type { OpenAPIObject } from 'openapi3-ts/oas31';
-import type { VovkOutputConfig, VovkStrictConfig, VovkReadmeConfig, VovkSamplesConfig, VovkPackageJson } from '../types/config.js';
+import type { VovkOutputConfig, VovkPackageJson, VovkReadmeConfig, VovkSamplesConfig, VovkStrictConfig } from '../types/config.js';
 import type { VovkSchema } from '../types/core.js';
 export declare function vovkSchemaToOpenAPI({ config, rootEntry, schema: fullSchema, outputConfigs, forceOutputConfigs, isBundle, segmentName: givenSegmentName, projectPackageJson, }: {
     config: VovkStrictConfig | undefined;

package/dist/openapi/vovk-schema-to-openapi.js

@@ -1,6 +1,6 @@
+import { resolveGeneratorConfigValues } from '../core/resolve-generator-config-values.js';
 import { createCodeSamples } from '../samples/create-code-samples.js';
 import { schemaToObject } from '../samples/schema-to-object.js';
-import { resolveGeneratorConfigValues } from '../core/resolve-generator-config-values.js';
 import { HttpStatus } from '../types/enums.js';
 function extractComponents(schema) {
     if (!schema)
@@ -119,7 +119,11 @@ export function vovkSchemaToOpenAPI({ config, rootEntry = 'api', schema: fullSch
                         ],
                         ...(queryParameters || pathParameters
                             ? {
-                                parameters: h.operationObject?.parameters ?? [...(queryParameters || []), ...(pathParameters || [])],
+                                // merge derived path/query parameters with user-declared ones, user wins on (name, in) collision
+                                parameters: [
+                                    ...[...(queryParameters || []), ...(pathParameters || [])].filter((p) => !h.operationObject?.parameters?.some((up) => 'name' in up && up.name === p.name && up.in === p.in)),
+                                    ...(h.operationObject?.parameters ?? []),
+                                ],
                             }
                             : {}),
                         ...(paths[path][httpMethod].parameters
@@ -209,7 +213,9 @@ export function vovkSchemaToOpenAPI({ config, rootEntry = 'api', schema: fullSch
             components: {
                 ...openAPIObject?.components,
                 schemas: {
-                    ...(openAPIObject?.components?.schemas ?? components),
+                    // merge so user-declared schemas extend the derived ones instead of replacing them
+                    ...components,
+                    ...openAPIObject?.components?.schemas,
                     HttpStatus: {
                         type: 'integer',
                         description: 'HTTP status code',

package/dist/req/parse-query.d.ts

@@ -1,24 +1 @@
-/**
- * Deserialize a bracket-based query string into an object.
- *
- * Supports:
- *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
- *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
- *   - Mixed arrays of objects, etc.
- *
- * @example
- *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
- *   => {
- *        x: "xx",
- *        y: ["yy", "uu"],
- *        z: {
- *          f: "x",
- *          u: ["uu", "xx"],
- *          d: { x: "ee" }
- *        }
- *      }
- *
- * @param queryString - The raw query string (e.g. location.search.slice(1))
- * @returns           - A nested object representing the query params
- */
 export declare function parseQuery(queryString: string): Record<string, unknown>;

package/dist/req/parse-query.js

@@ -1,10 +1,6 @@
-/**
- * Parse a bracket-based key (e.g. "z[d][0][x]" or "arr[]")
- * into an array of path segments (strings or special push-markers).
- *
- * Example: "z[d][0][x]" => ["z", "d", "0", "x"]
- * Example: "arr[]"      => ["arr", "" ]  // "" indicates "push" onto array
- */
+// segments that would let a query string reach Object.prototype, such pairs are dropped like qs does
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+// bracket key to path segments: "z[d][0][x]" => ["z", "d", "0", "x"], "arr[]" => ["arr", ""] ("" means push)
 function parseKey(key) {
     // The first segment is everything up to the first '[' (or the entire key if no '[')
     const segments = [];
@@ -28,14 +24,34 @@ function parseKey(key) {
     }
     return segments;
 }
-/**
- * Recursively set a value in a nested object/array, given a path of segments.
- * - If segment is numeric => treat as array index
- * - If segment is empty "" => push to array
- * - Else => object property
- */
+// past this an index becomes an object key, like qs does, so a short query cannot size a huge array
+const ARRAY_LIMIT = 100;
+// digits only, Number() would take "-1" and "1e2" and then drop the value on an array
+function isArrayIndex(segment) {
+    return /^\d+$/.test(segment) && Number(segment) <= ARRAY_LIMIT;
+}
+// which container the next segment needs, "" is a push and so wants an array too
+function wantsArray(segment) {
+    return typeof segment === 'string' && (segment === '' || isArrayIndex(segment));
+}
+// sets a value at a segment path: numeric => array index, "" => array push, else object property
 function setValue(obj, path, value) {
     let current = obj;
+    let parent = null;
+    let parentKey = '';
+    // an array only keeps numeric indices, any other key is dropped on serialization,
+    // so replace the array with an object before setting one
+    const demoteArray = () => {
+        if (!Array.isArray(current))
+            return;
+        const replacement = {};
+        const source = current;
+        for (const key of Object.keys(source))
+            replacement[key] = source[key];
+        if (parent)
+            parent[parentKey] = replacement;
+        current = replacement;
+    };
     for (let i = 0; i < path.length; i++) {
         const segment = path[i];
         // If we're at the last segment, set the value
@@ -47,7 +63,7 @@ function setValue(obj, path, value) {
                 }
                 current.push(value);
             }
-            else if (!Number.isNaN(Number(segment))) {
+            else if (isArrayIndex(segment)) {
                 // Numeric segment => array index
                 const idx = Number(segment);
                 if (!Array.isArray(current)) {
@@ -57,6 +73,7 @@ function setValue(obj, path, value) {
             }
             else {
                 // Object property
+                demoteArray();
                 current[segment] = value;
             }
         }
@@ -73,9 +90,9 @@ function setValue(obj, path, value) {
                 // for the next segment. We'll push something and move current to that.
                 if (current.length === 0) {
                     // nothing in array yet
-                    current.push(typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {});
+                    current.push(wantsArray(nextSegment) ? [] : {});
                 }
-                else if (typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment))) {
+                else if (wantsArray(nextSegment)) {
                     // next is numeric => we want an array
                     if (!Array.isArray(current[current.length - 1])) {
                         current[current.length - 1] = [];
@@ -87,9 +104,11 @@ function setValue(obj, path, value) {
                         current[current.length - 1] = {};
                     }
                 }
+                parent = current;
+                parentKey = current.length - 1;
                 current = current[current.length - 1];
             }
-            else if (!Number.isNaN(Number(segment))) {
+            else if (isArrayIndex(segment)) {
                 // segment is numeric => array index
                 const idx = Number(segment);
                 if (!Array.isArray(current)) {
@@ -97,44 +116,28 @@ function setValue(obj, path, value) {
                 }
                 if (current[idx] === undefined) {
                     // Create placeholder for next segment
-                    current[idx] = typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {};
+                    current[idx] = wantsArray(nextSegment) ? [] : {};
                 }
+                parent = current;
+                parentKey = idx;
                 current = current[idx];
             }
             else {
                 // segment is an object key
+                demoteArray();
                 if (current[segment] === undefined) {
                     // Create placeholder
-                    current[segment] = typeof nextSegment === 'string' && !Number.isNaN(Number(nextSegment)) ? [] : {};
+                    current[segment] = wantsArray(nextSegment) ? [] : {};
                 }
+                parent = current;
+                parentKey = segment;
                 current = current[segment];
             }
         }
     }
 }
-/**
- * Deserialize a bracket-based query string into an object.
- *
- * Supports:
- *   - Key/value pairs with nested brackets (e.g. "a[b][0]=value")
- *   - Arrays with empty bracket (e.g. "arr[]=1&arr[]=2")
- *   - Mixed arrays of objects, etc.
- *
- * @example
- *   parseQuery("x=xx&y[0]=yy&y[1]=uu&z[f]=x&z[u][0]=uu&z[u][1]=xx&z[d][x]=ee")
- *   => {
- *        x: "xx",
- *        y: ["yy", "uu"],
- *        z: {
- *          f: "x",
- *          u: ["uu", "xx"],
- *          d: { x: "ee" }
- *        }
- *      }
- *
- * @param queryString - The raw query string (e.g. location.search.slice(1))
- * @returns           - A nested object representing the query params
- */
+// bracket query string to a nested object, supports "a[b][0]=value", "arr[]=1&arr[]=2" etc,
+// e.g. "x=xx&y[0]=yy&z[f]=x&z[d][x]=ee" => { x: "xx", y: ["yy"], z: { f: "x", d: { x: "ee" } } }
 export function parseQuery(queryString) {
     const result = {};
     if (!queryString)
@@ -144,11 +147,16 @@ export function parseQuery(queryString) {
         .replace(/^\?/, '') // Remove leading "?" if present
         .split('&');
     for (const pair of pairs) {
-        const [rawKey, rawVal = ''] = pair.split('=');
+        // split at the first "=" only, unencoded "=" is legal inside values (base64, JWTs, signatures)
+        const eqIndex = pair.indexOf('=');
+        const rawKey = eqIndex === -1 ? pair : pair.slice(0, eqIndex);
+        const rawVal = eqIndex === -1 ? '' : pair.slice(eqIndex + 1);
         const decodedKey = decodeURIComponent(rawKey);
         const decodedVal = decodeURIComponent(rawVal);
         // Parse bracket notation
         const pathSegments = parseKey(decodedKey);
+        if (pathSegments.some((segment) => FORBIDDEN_KEYS.has(segment)))
+            continue;
         // Insert into the result object
         setValue(result, pathSegments, decodedVal);
     }

package/dist/req/validate-content-type.js

@@ -1,7 +1,7 @@
 import { HttpException } from '../core/http-exception.js';
 import { HttpStatus } from '../types/enums.js';
 export function validateContentType(request, allowed) {
-    // Wildcard — skip validation
+    // wildcard, skip validation
     if (!request?.headers || allowed.includes('*/*'))
         return null;
     const raw = request.headers.get('content-type');

package/dist/samples/create-code-samples.d.ts

@@ -1,5 +1,5 @@
-import type { VovkControllerSchema, VovkHandlerSchema } from '../types/core.js';
 import type { VovkSamplesConfig } from '../types/config.js';
+import type { VovkControllerSchema, VovkHandlerSchema } from '../types/core.js';
 export type CodeSamplePackageJson = {
     name?: string;
     version?: string;

package/dist/samples/create-code-samples.js

@@ -1,5 +1,5 @@
-import { schemaToCode, getSampleValue } from './schema-to-code.js';
 import { objectToCode } from './object-to-code.js';
+import { getSampleValue, schemaToCode } from './schema-to-code.js';
 const toSnakeCase = (str) => str
     .replace(/-/g, '_') // Replace hyphens with underscores
     .replace(/([a-z0-9])([A-Z])/g, '$1_$2') // Add underscore between lowercase/digit and uppercase
@@ -270,8 +270,9 @@ export function createCodeSamples({ handlerName, handlerSchema, controllerSchema
     const iterationValidation = handlerSchema?.validation?.iteration;
     const hasArg = !!queryValidation || !!bodyValidation || !!paramsValidation || !!config?.apiRoot || !!config?.headers;
     const rpcName = controllerSchema.rpcModuleName;
-    const packageName = packageJson?.name || 'vovk-client';
-    const packageNameSnake = toSnakeCase(packageName);
+    const packageName = packageJson?.name || '@/client';
+    // snake fallback avoids invalid "@/client" in py/rs imports
+    const packageNameSnake = toSnakeCase(packageJson?.name || 'client');
     const pyPackageName = packageJson?.py_name ?? packageNameSnake;
     const rsPackageName = packageJson?.rs_name ?? packageNameSnake;
     const commonParams = {

package/dist/samples/schema-to-code.d.ts

@@ -7,5 +7,5 @@ interface SamplerOptions {
     ignoreBinary?: boolean;
 }
 export declare function schemaToCode(schema: VovkJSONSchemaBase, options: SamplerOptions, rootSchema?: VovkJSONSchemaBase): string;
-export declare function getSampleValue(schema: VovkJSONSchemaBase, rootSchema?: VovkJSONSchemaBase, ignoreBinary?: boolean): unknown;
+export declare function getSampleValue(schema: VovkJSONSchemaBase, rootSchema?: VovkJSONSchemaBase, ignoreBinary?: boolean, seen?: Set<string>): unknown;
 export {};

package/dist/samples/schema-to-code.js

@@ -10,7 +10,7 @@ export function schemaToCode(schema, options, rootSchema) {
     return formatWithDescriptions(sampleValue, schema, rootSchema, comment, stripQuotes, indent, nestingIndent, ignoreBinary, true // isTopLevel
     );
 }
-export function getSampleValue(schema, rootSchema, ignoreBinary) {
+export function getSampleValue(schema, rootSchema, ignoreBinary, seen = new Set()) {
     if (!schema || typeof schema !== 'object')
         return null;
     rootSchema = rootSchema || schema;
@@ -32,7 +32,7 @@ export function getSampleValue(schema, rootSchema, ignoreBinary) {
     }
     // Handle $ref if present
     if (schema.$ref) {
-        return handleRef(schema.$ref, rootSchema, ignoreBinary);
+        return handleRef(schema.$ref, rootSchema, ignoreBinary, seen);
     }
     // Handle enum if present
     if (schema.enum && schema.enum.length > 0) {
@@ -40,15 +40,15 @@ export function getSampleValue(schema, rootSchema, ignoreBinary) {
     }
     // Handle oneOf, anyOf, allOf
     if (schema.oneOf && schema.oneOf.length > 0) {
-        return getSampleValue(schema.oneOf[0], rootSchema, ignoreBinary);
+        return getSampleValue(schema.oneOf[0], rootSchema, ignoreBinary, seen);
     }
     if (schema.anyOf && schema.anyOf.length > 0) {
-        return getSampleValue(schema.anyOf[0], rootSchema, ignoreBinary);
+        return getSampleValue(schema.anyOf[0], rootSchema, ignoreBinary, seen);
     }
     if (schema.allOf && schema.allOf.length > 0) {
         // Merge all schemas in allOf
         const mergedSchema = schema.allOf.reduce((acc, s) => Object.assign(acc, s), {});
-        return getSampleValue(mergedSchema, rootSchema, ignoreBinary);
+        return getSampleValue(mergedSchema, rootSchema, ignoreBinary, seen);
     }
     // Handle different types
     if (schema.type) {
@@ -61,9 +61,9 @@ export function getSampleValue(schema, rootSchema, ignoreBinary) {
             case 'boolean':
                 return handleBoolean();
             case 'object':
-                return handleObject(schema, rootSchema, ignoreBinary);
+                return handleObject(schema, rootSchema, ignoreBinary, seen);
             case 'array':
-                return handleArray(schema, rootSchema, ignoreBinary);
+                return handleArray(schema, rootSchema, ignoreBinary, seen);
             case 'null':
                 return null;
             default:
@@ -72,7 +72,7 @@ export function getSampleValue(schema, rootSchema, ignoreBinary) {
     }
     // If type is not specified but properties are, treat it as an object
     if (schema.properties) {
-        return handleObject(schema, rootSchema, ignoreBinary);
+        return handleObject(schema, rootSchema, ignoreBinary, seen);
     }
     // Default fallback
     return null;
@@ -154,9 +154,12 @@ function resolveRef(ref, rootSchema) {
     }
     return current;
 }
-function handleRef(ref, rootSchema, ignoreBinary) {
+function handleRef(ref, rootSchema, ignoreBinary, seen) {
+    // a ref already being expanded means the schema is circular, stop instead of recursing forever
+    if (seen.has(ref))
+        return null;
     const resolved = resolveRef(ref, rootSchema);
-    return getSampleValue(resolved, rootSchema, ignoreBinary);
+    return getSampleValue(resolved, rootSchema, ignoreBinary, new Set(seen).add(ref));
 }
 function handleString(schema) {
     if (schema.format) {
@@ -218,13 +221,13 @@ function handleNumber(schema) {
 function handleBoolean() {
     return true;
 }
-function handleObject(schema, rootSchema, ignoreBinary) {
+function handleObject(schema, rootSchema, ignoreBinary, seen) {
     const result = {};
     if (schema.properties) {
         const required = schema.required || [];
         for (const [key, propSchema] of Object.entries(schema.properties)) {
             if (required.includes(key) || required.length === 0) {
-                const value = getSampleValue(propSchema, rootSchema, ignoreBinary);
+                const value = getSampleValue(propSchema, rootSchema, ignoreBinary, seen);
                 // Only add the property if it's not undefined (which happens when ignoreBinary is true and it's a binary field)
                 if (value !== undefined) {
                     result[key] = value;
@@ -233,14 +236,14 @@ function handleObject(schema, rootSchema, ignoreBinary) {
         }
     }
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-        const value = getSampleValue(schema.additionalProperties, rootSchema, ignoreBinary);
+        const value = getSampleValue(schema.additionalProperties, rootSchema, ignoreBinary, seen);
         if (value !== undefined) {
             result.additionalProp = value;
         }
     }
     return result;
 }
-function handleArray(schema, rootSchema, ignoreBinary) {
+function handleArray(schema, rootSchema, ignoreBinary, seen) {
     if (schema.items) {
         // If items is a boolean, return empty array (true means any items allowed, false means no items)
         if (typeof schema.items === 'boolean') {
@@ -253,7 +256,7 @@ function handleArray(schema, rootSchema, ignoreBinary) {
         }
         const minItems = schema.minItems || 1;
         const numItems = Math.min(minItems, 3);
-        const items = Array.from({ length: numItems }, () => getSampleValue(itemSchema, rootSchema, ignoreBinary)).filter((item) => item !== undefined); // Filter out undefined values from ignored binary items
+        const items = Array.from({ length: numItems }, () => getSampleValue(itemSchema, rootSchema, ignoreBinary, seen)).filter((item) => item !== undefined); // Filter out undefined values from ignored binary items
         // If all items were filtered out (e.g., all were binary), return undefined instead of empty array
         if (items.length === 0 && numItems > 0) {
             return undefined;

package/dist/samples/schema-to-object.d.ts

@@ -1,2 +1,2 @@
 import type { VovkJSONSchemaBase } from '../types/json-schema.js';
-export declare function schemaToObject(schema: VovkJSONSchemaBase, rootSchema?: VovkJSONSchemaBase): unknown;
+export declare function schemaToObject(schema: VovkJSONSchemaBase, rootSchema?: VovkJSONSchemaBase, seen?: Set<string>): unknown;

package/dist/samples/schema-to-object.js

@@ -1,4 +1,4 @@
-export function schemaToObject(schema, rootSchema) {
+export function schemaToObject(schema, rootSchema, seen = new Set()) {
     if (!schema || typeof schema !== 'object')
         return null;
     // Use the input schema as the root if not provided
@@ -17,7 +17,7 @@ export function schemaToObject(schema, rootSchema) {
     }
     // Handle $ref if present
     if (schema.$ref) {
-        return handleRef(schema.$ref, rootSchema);
+        return handleRef(schema.$ref, rootSchema, seen);
     }
     // Handle enum if present
     if (schema.enum && schema.enum.length > 0) {
@@ -25,15 +25,15 @@ export function schemaToObject(schema, rootSchema) {
     }
     // Handle oneOf, anyOf, allOf
     if (schema.oneOf && schema.oneOf.length > 0) {
-        return schemaToObject(schema.oneOf[0], rootSchema);
+        return schemaToObject(schema.oneOf[0], rootSchema, seen);
     }
     if (schema.anyOf && schema.anyOf.length > 0) {
-        return schemaToObject(schema.anyOf[0], rootSchema);
+        return schemaToObject(schema.anyOf[0], rootSchema, seen);
     }
     if (schema.allOf && schema.allOf.length > 0) {
         // Merge all schemas in allOf
         const mergedSchema = schema.allOf.reduce((acc, s) => Object.assign(acc, s), {});
-        return schemaToObject(mergedSchema, rootSchema);
+        return schemaToObject(mergedSchema, rootSchema, seen);
     }
     // Handle different types
     if (schema.type) {
@@ -46,9 +46,9 @@ export function schemaToObject(schema, rootSchema) {
             case 'boolean':
                 return handleBoolean();
             case 'object':
-                return handleObject(schema, rootSchema);
+                return handleObject(schema, rootSchema, seen);
             case 'array':
-                return handleArray(schema, rootSchema);
+                return handleArray(schema, rootSchema, seen);
             case 'null':
                 return null;
             default:
@@ -57,12 +57,15 @@ export function schemaToObject(schema, rootSchema) {
     }
     // If type is not specified but properties are, treat it as an object
     if (schema.properties) {
-        return handleObject(schema, rootSchema);
+        return handleObject(schema, rootSchema, seen);
     }
     // Default fallback
     return null;
 }
-function handleRef(ref, rootSchema) {
+function handleRef(ref, rootSchema, seen) {
+    // a ref already being expanded means the schema is circular, stop instead of recursing forever
+    if (seen.has(ref))
+        return null;
     // Parse the reference path
     const path = ref.split('/').slice(1); // Remove the initial '#'
     // Navigate through the schema to find the referenced definition
@@ -74,7 +77,7 @@ function handleRef(ref, rootSchema) {
         }
     }
     // Process the referenced schema
-    return schemaToObject(current, rootSchema);
+    return schemaToObject(current, rootSchema, new Set(seen).add(ref));
 }
 function handleString(schema) {
     if (schema.format) {
@@ -135,30 +138,30 @@ function handleNumber(schema) {
 function handleBoolean() {
     return true;
 }
-function handleObject(schema, rootSchema) {
+function handleObject(schema, rootSchema, seen) {
     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);
+                result[key] = schemaToObject(propSchema, rootSchema, seen);
             }
         }
     }
     // Handle additionalProperties
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-        result.additionalProp = schemaToObject(schema.additionalProperties, rootSchema);
+        result.additionalProp = schemaToObject(schema.additionalProperties, rootSchema, seen);
     }
     return result;
 }
-function handleArray(schema, rootSchema) {
+function handleArray(schema, rootSchema, seen) {
     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 Array.from({ length: numItems }, () => schemaToObject(itemSchema, rootSchema, seen));
     }
     return [];
 }

package/dist/tools/create-tool-factory.d.ts

@@ -1,8 +1,8 @@
 import type { VovkValidationType } from '../types/core.js';
 import type { VovkTool } from '../types/tools.js';
-import type { DefaultModelOutput, ToModelOutputDefaultFn } from './to-model-output-default.js';
-import type { CombinedSpec } from '../types/validation.js';
 import type { KnownAny } from '../types/utils.js';
+import type { CombinedSpec } from '../types/validation.js';
+import type { DefaultModelOutput, ToModelOutputDefaultFn } from './to-model-output-default.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, }: {

package/dist/tools/derive-tools.d.ts

@@ -1,6 +1,7 @@
-import type { DefaultModelOutput } from './to-model-output-default.js';
 import type { VovkRequest } from '../types/request.js';
-import type { VovkTool, ToModelOutputFn } from '../types/tools.js';
+import type { StandardToolV0 } from '../types/standard-tool.js';
+import type { ToModelOutputFn } from '../types/tools.js';
+import type { DefaultModelOutput } from './to-model-output-default.js';
 type DerivedToolInput = {
     body?: unknown;
     query?: unknown;
@@ -9,12 +10,8 @@ type DerivedToolInput = {
 type DeriveToolsBaseOptions<TOutput = unknown, TFormattedOutput = unknown> = {
     modules: Record<string, object>;
     meta?: Record<string, unknown>;
-    onExecute?: (result: unknown, tool: VovkTool<DerivedToolInput, TOutput, TFormattedOutput>, req: Pick<VovkRequest, 'vovk'> | null) => void;
-    onError?: (error: Error, tool: VovkTool<DerivedToolInput, TOutput, TFormattedOutput>, req: Pick<VovkRequest, 'vovk'> | null) => void;
-};
-type DeriveToolsResult<TOutput, TFormattedOutput> = {
-    tools: VovkTool<DerivedToolInput, TOutput, TFormattedOutput>[];
-    toolsByName: Record<string, VovkTool<DerivedToolInput, TOutput, TFormattedOutput>>;
+    onExecute?: (result: unknown, tool: StandardToolV0<DerivedToolInput, TOutput, TFormattedOutput>, req: Pick<VovkRequest, 'vovk'> | null) => void;
+    onError?: (error: Error, tool: StandardToolV0<DerivedToolInput, TOutput, TFormattedOutput>, req: Pick<VovkRequest, 'vovk'> | null) => void;
 };
 /**
  * Derives AI tools from controllers and RPC modules.
@@ -22,10 +19,9 @@ type DeriveToolsResult<TOutput, TFormattedOutput> = {
  * @example
  * ```ts
  * import { deriveTools, ToModelOutput } from 'vovk';
- * import { UserRPC } from 'vovk-client';
+ * import { UserRPC } from '@/client';
  *
- * // Derive AI tools from the UserRPC module
- * const { tools, toolsByName } = deriveTools({
+ * const tools = deriveTools({
  *   modules: { UserRPC },
  *   toModelOutput: ToModelOutput.MCP,
  *   onExecute: (result, tool) => {
@@ -39,8 +35,8 @@ type DeriveToolsResult<TOutput, TFormattedOutput> = {
  */
 export declare function deriveTools<TOutput = unknown, TFormattedOutput = DefaultModelOutput<TOutput>>(options: DeriveToolsBaseOptions & {
     toModelOutput?: never;
-}): DeriveToolsResult<TOutput, TFormattedOutput>;
+}): StandardToolV0<DerivedToolInput, TOutput, TFormattedOutput>[];
 export declare function deriveTools<TOutput = unknown, TFormattedOutput = unknown>(options: DeriveToolsBaseOptions & {
     toModelOutput: ToModelOutputFn<unknown, TOutput, TFormattedOutput>;
-}): DeriveToolsResult<TOutput, TFormattedOutput>;
+}): StandardToolV0<DerivedToolInput, TOutput, TFormattedOutput>[];
 export {};