@mcp-web/core 0.1.0

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

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,430 @@
+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

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

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

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