@mcp-web/core 0.1.0 → 0.1.2

package/dist/expanded-schema-tools/schema-helpers.test.js

@@ -1,223 +0,0 @@
-import { expect, test } from 'bun:test';
-import { z } from 'zod';
-import { deriveAddInputSchema, deriveSetInputSchema, hasDefault, id, isKeyField, isSystemField, system, unwrapDefault, unwrapSchema, validateSystemFields, } from './schema-helpers.js';
-// ============================================================================
-// Schema Markers
-// ============================================================================
-test('id() - marks field as unique identifier', () => {
-    const schema = id(z.string());
-    expect(isKeyField(schema)).toBe(true);
-});
-test('system() - marks field as system-generated', () => {
-    const schema = system(z.string().default('auto'));
-    expect(isSystemField(schema)).toBe(true);
-});
-test('isKeyField() - detects id() marker', () => {
-    const markedSchema = id(z.string());
-    const normalSchema = z.string();
-    expect(isKeyField(markedSchema)).toBe(true);
-    expect(isKeyField(normalSchema)).toBe(false);
-});
-test('isSystemField() - detects system() marker', () => {
-    const markedSchema = system(z.string().default('auto'));
-    const normalSchema = z.string();
-    expect(isSystemField(markedSchema)).toBe(true);
-    expect(isSystemField(normalSchema)).toBe(false);
-});
-test('id() and system() can be combined', () => {
-    const schema = id(system(z.string().default(() => crypto.randomUUID())));
-    expect(isKeyField(schema)).toBe(true);
-    expect(isSystemField(schema)).toBe(true);
-});
-// ============================================================================
-// Schema Unwrapping
-// ============================================================================
-test('unwrapSchema() - unwraps ZodDefault', () => {
-    const schema = z.string().default('hello');
-    const unwrapped = unwrapSchema(schema);
-    expect(unwrapped).toBeInstanceOf(z.ZodString);
-});
-test('unwrapSchema() - unwraps ZodOptional', () => {
-    const schema = z.string().optional();
-    const unwrapped = unwrapSchema(schema);
-    expect(unwrapped).toBeInstanceOf(z.ZodString);
-});
-test('unwrapSchema() - unwraps ZodNullable', () => {
-    const schema = z.string().nullable();
-    const unwrapped = unwrapSchema(schema);
-    expect(unwrapped).toBeInstanceOf(z.ZodString);
-});
-test('unwrapSchema() - handles nested wrappers', () => {
-    const schema = z.string().optional().default('hello').nullable();
-    const unwrapped = unwrapSchema(schema);
-    expect(unwrapped).toBeInstanceOf(z.ZodString);
-});
-test('unwrapSchema() - returns same schema if not wrapped', () => {
-    const schema = z.string();
-    const unwrapped = unwrapSchema(schema);
-    expect(unwrapped).toBe(schema);
-});
-test('unwrapDefault() - unwraps only ZodDefault', () => {
-    const schema = z.string().default('hello');
-    const unwrapped = unwrapDefault(schema);
-    expect(unwrapped).toBeInstanceOf(z.ZodString);
-});
-test('unwrapDefault() - returns same schema if not ZodDefault', () => {
-    const schema = z.string().optional();
-    const unwrapped = unwrapDefault(schema);
-    expect(unwrapped).toBe(schema);
-});
-// ============================================================================
-// Default Detection
-// ============================================================================
-test('hasDefault() - detects ZodDefault wrapper', () => {
-    const withDefault = z.string().default('hello');
-    const withoutDefault = z.string();
-    expect(hasDefault(withDefault)).toBe(true);
-    expect(hasDefault(withoutDefault)).toBe(false);
-});
-test('hasDefault() - works with nullable defaults', () => {
-    const schema = z.string().nullable().default(null);
-    expect(hasDefault(schema)).toBe(true);
-});
-test('hasDefault() - returns false for optional without default', () => {
-    const schema = z.string().optional();
-    expect(hasDefault(schema)).toBe(false);
-});
-// ============================================================================
-// Input Schema Derivation - Add
-// ============================================================================
-test('deriveAddInputSchema() - excludes system() fields', () => {
-    const schema = z.object({
-        id: system(z.string().default(() => crypto.randomUUID())),
-        value: z.string(),
-        priority: z.number().default(3),
-    });
-    const addSchema = deriveAddInputSchema(schema);
-    const shape = addSchema.shape;
-    expect('id' in shape).toBe(false);
-    expect('value' in shape).toBe(true);
-    expect('priority' in shape).toBe(true);
-});
-test('deriveAddInputSchema() - makes default() fields optional', () => {
-    const schema = z.object({
-        required: z.string(),
-        withDefault: z.number().default(5),
-    });
-    const addSchema = deriveAddInputSchema(schema);
-    // Required field should be required
-    const requiredResult = addSchema.safeParse({ required: 'test' });
-    expect(requiredResult.success).toBe(true);
-    // Field with default should be optional
-    const optionalResult = addSchema.safeParse({ required: 'test' });
-    expect(optionalResult.success).toBe(true);
-    // Can also provide the default field
-    const withBothResult = addSchema.safeParse({
-        required: 'test',
-        withDefault: 10,
-    });
-    expect(withBothResult.success).toBe(true);
-});
-test('deriveAddInputSchema() - keeps required fields required', () => {
-    const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-    });
-    const addSchema = deriveAddInputSchema(schema);
-    // Should fail without required fields
-    const missingName = addSchema.safeParse({ age: 30 });
-    expect(missingName.success).toBe(false);
-    const missingAge = addSchema.safeParse({ name: 'Alice' });
-    expect(missingAge.success).toBe(false);
-    // Should pass with both fields
-    const complete = addSchema.safeParse({ name: 'Alice', age: 30 });
-    expect(complete.success).toBe(true);
-});
-// ============================================================================
-// Input Schema Derivation - Set
-// ============================================================================
-test('deriveSetInputSchema() - excludes system() fields', () => {
-    const schema = z.object({
-        id: system(z.string().default(() => crypto.randomUUID())),
-        updated_at: system(z.number().default(() => Date.now())),
-        value: z.string(),
-    });
-    const setSchema = deriveSetInputSchema(schema);
-    const shape = setSchema.shape;
-    expect('id' in shape).toBe(false);
-    expect('updated_at' in shape).toBe(false);
-    expect('value' in shape).toBe(true);
-});
-test('deriveSetInputSchema() - makes all fields optional', () => {
-    const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-        email: z.string(),
-    });
-    const setSchema = deriveSetInputSchema(schema);
-    // All fields optional - any combination should work
-    expect(setSchema.safeParse({}).success).toBe(true);
-    expect(setSchema.safeParse({ name: 'Alice' }).success).toBe(true);
-    expect(setSchema.safeParse({ age: 30 }).success).toBe(true);
-    expect(setSchema.safeParse({ name: 'Alice', age: 30 }).success).toBe(true);
-    expect(setSchema.safeParse({ name: 'Alice', age: 30, email: 'alice@example.com' })
-        .success).toBe(true);
-});
-// ============================================================================
-// Validation
-// ============================================================================
-test('validateSystemFields() - passes when system fields have defaults', () => {
-    const schema = z.object({
-        id: system(z.string().default(() => crypto.randomUUID())),
-        created_at: system(z.number().default(() => Date.now())),
-        value: z.string(),
-    });
-    expect(() => validateSystemFields(schema)).not.toThrow();
-});
-test('validateSystemFields() - throws when system field lacks default', () => {
-    const schema = z.object({
-        id: system(z.string()),
-        value: z.string(),
-    });
-    expect(() => validateSystemFields(schema)).toThrow();
-});
-test('validateSystemFields() - error message includes field name', () => {
-    const schema = z.object({
-        timestamp: system(z.number()),
-    });
-    try {
-        validateSystemFields(schema);
-        expect(true).toBe(false); // Should not reach here
-    }
-    catch (error) {
-        const message = error.message;
-        expect(message).toContain('timestamp');
-        expect(message).toContain('system()');
-        expect(message).toContain('default');
-    }
-});
-test('validateSystemFields() - error message suggests fix', () => {
-    const schema = z.object({
-        created_at: system(z.number()),
-    });
-    try {
-        validateSystemFields(schema);
-        expect(true).toBe(false); // Should not reach here
-    }
-    catch (error) {
-        const message = error.message;
-        expect(message).toContain('Fix:');
-        expect(message).toContain('.default(');
-    }
-});
-test('validateSystemFields() - passes with empty object', () => {
-    const schema = z.object({});
-    expect(() => validateSystemFields(schema)).not.toThrow();
-});
-test('validateSystemFields() - passes with no system fields', () => {
-    const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-    });
-    expect(() => validateSystemFields(schema)).not.toThrow();
-});

package/dist/expanded-schema-tools/tool-generator.d.ts

@@ -1,10 +0,0 @@
-import type { MCPWeb } from '../web.js';
-import type { GeneratedTools, ToolGenerationOptions } from './types.js';
-/**
- * Generates MCP tools for a schema based on its shape.
- * - Fixed-shape schemas → get + set with deep merge
- * - Dynamic-shape schemas → get + add + set + delete (arrays) or get + set + delete (records)
- * - Mixed schemas → asymmetric get/set + collection tools
- */
-export declare function generateToolsForSchema(options: ToolGenerationOptions, mcpWeb: MCPWeb): GeneratedTools;
-//# sourceMappingURL=tool-generator.d.ts.map

package/dist/expanded-schema-tools/tool-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-generator.d.ts","sourceRoot":"","sources":["../../src/expanded-schema-tools/tool-generator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AASxC,OAAO,KAAK,EAAE,cAAc,EAA+B,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOrG;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,MAAM,GACb,cAAc,CAsDhB"}

package/dist/expanded-schema-tools/tool-generator.js

@@ -1,430 +0,0 @@
-import { z } from 'zod';
-import { generateFixedShapeTools } from './generate-fixed-shape-tools.js';
-import { analyzeSchemaShape, findIdField } from './schema-analysis.js';
-import { deriveAddInputSchema, deriveSetInputSchema, unwrapSchema, validateSystemFields, } from './schema-helpers.js';
-import { deepMerge } from './utils.js';
-// ============================================================================
-// Main Entry Point
-// ============================================================================
-/**
- * Generates MCP tools for a schema based on its shape.
- * - Fixed-shape schemas → get + set with deep merge
- * - Dynamic-shape schemas → get + add + set + delete (arrays) or get + set + delete (records)
- * - Mixed schemas → asymmetric get/set + collection tools
- */
-export function generateToolsForSchema(options, mcpWeb) {
-    const { name, schema } = options;
-    const tools = [];
-    const warnings = [];
-    // Validate schema
-    const unwrapped = unwrapSchema(schema);
-    // Validate system fields if it's an object
-    if (unwrapped instanceof z.ZodObject) {
-        validateSystemFields(unwrapped);
-    }
-    // Analyze schema shape
-    const shape = analyzeSchemaShape(schema);
-    // Warn about optional fields (once)
-    if (shape.hasOptionalFields) {
-        warnings.push(`⚠️ Warning: Schema for '${name}' uses optional() on field(s): ${shape.optionalPaths.join(', ')}.\n\n` +
-            `Problem: optional() creates ambiguity in partial updates:\n` +
-            `- Is the field missing because AI didn't provide it? (keep current)\n` +
-            `- Or because AI wants to clear it? (set to undefined)\n\n` +
-            `Solution: Use nullable() instead:\n` +
-            `- fieldName: z.string().nullable()\n\n` +
-            `This makes intent explicit:\n` +
-            `- Omit field → keep current value\n` +
-            `- Pass null → clear the value`);
-    }
-    // Generate tools based on schema type
-    if (shape.type === 'fixed') {
-        // Fixed-shape: primitives, tuples, or objects with only fixed props
-        tools.push(...generateFixedShapeTools(options, shape));
-    }
-    else if (shape.type === 'dynamic') {
-        // Dynamic-shape: arrays or records at root, or objects with only dynamic props
-        if (shape.subtype === 'array') {
-            tools.push(...generateArrayTools(options, mcpWeb));
-        }
-        else if (shape.subtype === 'record') {
-            tools.push(...generateRecordTools(options, mcpWeb));
-        }
-    }
-    else if (shape.type === 'mixed') {
-        // Mixed: objects with both fixed and dynamic props
-        tools.push(...generateMixedObjectTools(options, shape, mcpWeb));
-    }
-    else {
-        // Unsupported type
-        warnings.push(`⚠️ Warning: Schema for '${name}' contains unsupported types.\n` +
-            `Only JSON-compatible types are supported (objects, arrays, records, primitives).`);
-    }
-    return { tools, warnings };
-}
-// ============================================================================
-// Array Tools Generator
-// ============================================================================
-/**
- * Generates tools for array schemas.
- * Creates 4 tools: get, add, set, delete
- * Uses index-based addressing by default, ID-based when id() marker present.
- */
-function generateArrayTools(options, _mcpWeb) {
-    const { name, description, get, set, schema } = options;
-    const tools = [];
-    const unwrapped = unwrapSchema(schema);
-    const elementSchema = unwrapped.element;
-    // Check if element is an object with id() marker
-    const elementUnwrapped = unwrapSchema(elementSchema);
-    let idField = { type: 'none' };
-    if (elementUnwrapped instanceof z.ZodObject) {
-        idField = findIdField(elementUnwrapped);
-    }
-    const useIdBased = idField.type === 'explicit';
-    // Derive input schemas (exclude system fields)
-    let addInputSchema = elementSchema;
-    let setInputSchema = elementSchema;
-    if (elementUnwrapped instanceof z.ZodObject) {
-        addInputSchema = deriveAddInputSchema(elementUnwrapped);
-        setInputSchema = deriveSetInputSchema(elementUnwrapped);
-    }
-    // GET tool
-    if (useIdBased) {
-        const keyField = idField.field;
-        tools.push({
-            name: `get_${name}`,
-            description: `Get ${description} by ID, or get all if no ID provided`,
-            inputSchema: z.object({ id: z.string().optional() }),
-            handler: async (input) => {
-                const array = get();
-                if (input.id !== undefined) {
-                    return array.find((item) => item[keyField] === input.id);
-                }
-                return array;
-            },
-        });
-    }
-    else {
-        tools.push({
-            name: `get_${name}`,
-            description: `Get ${description} by index, or get all if no index provided`,
-            inputSchema: z.object({ index: z.number().int().min(0).optional() }),
-            handler: async (input) => {
-                const array = get();
-                if (input.index !== undefined) {
-                    return array[input.index];
-                }
-                return array;
-            },
-        });
-    }
-    // ADD tool
-    if (useIdBased) {
-        tools.push({
-            name: `add_${name}`,
-            description: `Add a new item to ${description}`,
-            inputSchema: z.object({ value: addInputSchema }),
-            handler: async (input) => {
-                const array = get();
-                const parsed = elementSchema.parse(input.value);
-                array.push(parsed);
-                set(array);
-                return { success: true, value: parsed };
-            },
-        });
-    }
-    else {
-        tools.push({
-            name: `add_${name}`,
-            description: `Add a new item to ${description} at the specified index (default: end)`,
-            inputSchema: z.object({
-                value: addInputSchema,
-                index: z.number().int().min(0).optional()
-            }),
-            handler: async (input) => {
-                const array = get();
-                const parsed = elementSchema.parse(input.value);
-                if (input.index !== undefined) {
-                    array.splice(input.index, 0, parsed);
-                }
-                else {
-                    array.push(parsed);
-                }
-                set(array);
-                return { success: true, value: parsed };
-            },
-        });
-    }
-    // SET tool (partial update with deep merge)
-    if (useIdBased) {
-        const keyField = idField.field;
-        tools.push({
-            name: `set_${name}`,
-            description: `Update an item in ${description} by ID (partial update with deep merge)`,
-            inputSchema: z.object({
-                id: z.string(),
-                value: setInputSchema
-            }),
-            handler: async (input) => {
-                const array = get();
-                const index = array.findIndex((item) => item[keyField] === input.id);
-                if (index === -1) {
-                    throw new Error(`Item with id '${input.id}' not found in ${name}`);
-                }
-                const merged = deepMerge(array[index], input.value);
-                const validated = elementSchema.parse(merged);
-                array[index] = validated;
-                set(array);
-                return { success: true, value: validated };
-            },
-        });
-    }
-    else {
-        tools.push({
-            name: `set_${name}`,
-            description: `Update an item in ${description} by index (partial update with deep merge)`,
-            inputSchema: z.object({
-                index: z.number().int().min(0),
-                value: setInputSchema
-            }),
-            handler: async (input) => {
-                const array = get();
-                if (input.index >= array.length) {
-                    throw new Error(`Index ${input.index} out of bounds for ${name} (length: ${array.length})`);
-                }
-                const merged = deepMerge(array[input.index], input.value);
-                const validated = elementSchema.parse(merged);
-                array[input.index] = validated;
-                set(array);
-                return { success: true, value: validated };
-            },
-        });
-    }
-    // DELETE tool
-    if (useIdBased) {
-        const keyField = idField.field;
-        tools.push({
-            name: `delete_${name}`,
-            description: `Delete an item from ${description} by ID, or delete all items`,
-            inputSchema: z.union([
-                z.object({ id: z.string() }),
-                z.object({ all: z.literal(true) })
-            ]),
-            handler: async (input) => {
-                const array = get();
-                if (input.all) {
-                    set([]);
-                }
-                else if (input.id) {
-                    const index = array.findIndex((item) => item[keyField] === input.id);
-                    if (index !== -1) {
-                        array.splice(index, 1);
-                        set(array);
-                    }
-                }
-                return { success: true };
-            },
-        });
-    }
-    else {
-        tools.push({
-            name: `delete_${name}`,
-            description: `Delete an item from ${description} by index, or delete all items`,
-            inputSchema: z.union([
-                z.object({ index: z.number().int().min(0) }),
-                z.object({ all: z.literal(true) })
-            ]),
-            handler: async (input) => {
-                const array = get();
-                if (input.all) {
-                    set([]);
-                }
-                else if (input.index !== undefined) {
-                    if (input.index < array.length) {
-                        array.splice(input.index, 1);
-                        set(array);
-                    }
-                }
-                return { success: true };
-            },
-        });
-    }
-    return tools;
-}
-// ============================================================================
-// Record Tools Generator
-// ============================================================================
-/**
- * Generates tools for record schemas.
- * Creates 3 tools: get, set (upsert), delete
- * Records use string keys naturally, no ID marker needed.
- */
-function generateRecordTools(options, _mcpWeb) {
-    const { name, description, get, set, schema } = options;
-    const tools = [];
-    const unwrapped = unwrapSchema(schema);
-    const def = unwrapped._def;
-    const valueSchema = def.valueType || z.unknown();
-    // Derive input schemas (exclude system fields if value is object)
-    const valueUnwrapped = unwrapSchema(valueSchema);
-    let setInputSchema = valueSchema;
-    if (valueUnwrapped instanceof z.ZodObject) {
-        setInputSchema = deriveSetInputSchema(valueUnwrapped);
-    }
-    // GET tool
-    tools.push({
-        name: `get_${name}`,
-        description: `Get ${description} by key, or get all if no key provided`,
-        inputSchema: z.object({ key: z.string().optional() }),
-        handler: async (input) => {
-            const record = get();
-            if (input.key !== undefined) {
-                return record[input.key];
-            }
-            return record;
-        },
-    });
-    // SET tool (upsert: add or update)
-    tools.push({
-        name: `set_${name}`,
-        description: `Set (add or update) an entry in ${description} (partial update with deep merge for objects)`,
-        inputSchema: z.object({
-            key: z.string(),
-            value: setInputSchema
-        }),
-        handler: async (input) => {
-            const record = get();
-            // If value schema is object and entry exists, deep merge
-            if (valueUnwrapped instanceof z.ZodObject && record[input.key] !== undefined) {
-                const merged = deepMerge(record[input.key], input.value);
-                const validated = valueSchema.parse(merged);
-                record[input.key] = validated;
-                set(record);
-                return { success: true, value: validated };
-            }
-            // Otherwise, full replacement (upsert)
-            const validated = valueSchema.parse(input.value);
-            record[input.key] = validated;
-            set(record);
-            return { success: true, value: validated };
-        },
-    });
-    // DELETE tool
-    tools.push({
-        name: `delete_${name}`,
-        description: `Delete an entry from ${description} by key, or delete all entries`,
-        inputSchema: z.union([
-            z.object({ key: z.string() }),
-            z.object({ all: z.literal(true) })
-        ]),
-        handler: async (input) => {
-            const record = get();
-            if (input.all) {
-                set({});
-            }
-            else if (input.key) {
-                delete record[input.key];
-                set(record);
-            }
-            return { success: true };
-        },
-    });
-    return tools;
-}
-// ============================================================================
-// Mixed Object Tools Generator
-// ============================================================================
-/**
- * Generates tools for mixed objects (both fixed and dynamic props).
- * Creates asymmetric get/set:
- * - get() returns full state (including collections)
- * - set() only updates fixed-shape props
- * - Separate tools for each collection
- */
-function generateMixedObjectTools(options, _shape, mcpWeb) {
-    const { name, description, get, set, schema } = options;
-    const tools = [];
-    const unwrapped = unwrapSchema(schema);
-    // Split into fixed and dynamic parts
-    const fixedShape = {};
-    const dynamicFields = [];
-    for (const [key, field] of Object.entries(unwrapped.shape)) {
-        const zodField = field;
-        const unwrappedField = unwrapSchema(zodField);
-        if (unwrappedField instanceof z.ZodArray || unwrappedField instanceof z.ZodRecord) {
-            dynamicFields.push({ key, field: zodField });
-        }
-        else {
-            fixedShape[key] = zodField;
-        }
-    }
-    const hasFixedProps = Object.keys(fixedShape).length > 0;
-    // ROOT GETTER - always returns full state
-    tools.push({
-        name: `get_${name}`,
-        description: `Get the current ${description} (full state including collections)`,
-        inputSchema: z.object({ excludeCollections: z.boolean().optional() }),
-        handler: async (input) => {
-            const fullState = get();
-            if (input.excludeCollections) {
-                // Return only fixed-shape props
-                const fixedState = {};
-                for (const key of Object.keys(fixedShape)) {
-                    fixedState[key] = fullState[key];
-                }
-                return fixedState;
-            }
-            return fullState;
-        },
-    });
-    // ROOT SETTER - only if there are fixed props
-    if (hasFixedProps) {
-        const setInputSchema = deriveSetInputSchema(z.object(fixedShape));
-        tools.push({
-            name: `set_${name}`,
-            description: `Update ${description} settings (fixed-shape props only, use collection tools for arrays/records)`,
-            inputSchema: setInputSchema,
-            handler: async (input) => {
-                const current = get();
-                // Merge only the fixed props
-                const fixedUpdate = {};
-                for (const key of Object.keys(fixedShape)) {
-                    if (key in input) {
-                        fixedUpdate[key] = input[key];
-                    }
-                }
-                const merged = deepMerge(current, fixedUpdate);
-                const validated = schema.parse(merged);
-                set(validated);
-                // Return only the fixed props that were updated
-                const result = {};
-                for (const key of Object.keys(fixedShape)) {
-                    result[key] = validated[key];
-                }
-                return { success: true, value: result };
-            },
-        });
-    }
-    // COLLECTION TOOLS - generate for each dynamic field
-    for (const { key, field } of dynamicFields) {
-        const unwrappedField = unwrapSchema(field);
-        const collectionOptions = {
-            name: `${name}_${key}`,
-            description: `${key} in ${description}`,
-            get: () => get()[key],
-            set: (value) => {
-                const current = get();
-                current[key] = value;
-                set(current);
-            },
-            schema: field,
-        };
-        if (unwrappedField instanceof z.ZodArray) {
-            tools.push(...generateArrayTools(collectionOptions, mcpWeb));
-        }
-        else if (unwrappedField instanceof z.ZodRecord) {
-            tools.push(...generateRecordTools(collectionOptions, mcpWeb));
-        }
-    }
-    return tools;
-}

package/dist/expanded-schema-tools/tool-generator.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=tool-generator.test.d.ts.map

package/dist/expanded-schema-tools/tool-generator.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-generator.test.d.ts","sourceRoot":"","sources":["../../src/expanded-schema-tools/tool-generator.test.ts"],"names":[],"mappings":""}