@mcp-web/core 0.1.0

package/dist/tool-generators/tool-generator.js

@@ -0,0 +1,437 @@
+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
+ *
+ * Returns tool definitions without registering them - the caller is responsible for registration.
+ */
+export function generateToolsForSchema(options) {
+    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));
+        }
+        else if (shape.subtype === 'record') {
+            tools.push(...generateRecordTools(options));
+        }
+    }
+    else if (shape.type === 'mixed') {
+        // Mixed: objects with both fixed and dynamic props
+        tools.push(...generateMixedObjectTools(options, shape));
+    }
+    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) {
+    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().describe('The ID of the item to retrieve. If omitted, returns all items.'),
+            }),
+            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().describe('The zero-based index of the item to retrieve. If omitted, returns all items.'),
+            }),
+            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.describe('The item to add.'),
+            }),
+            handler: async (input) => {
+                const array = get();
+                const parsed = elementSchema.parse(input.value);
+                set([...array, parsed]);
+                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.describe('The item to add.'),
+                index: z.number().int().min(0).optional().describe('The zero-based index at which to insert the item. If omitted, the item is added at the end.'),
+            }),
+            handler: async (input) => {
+                const array = get();
+                const parsed = elementSchema.parse(input.value);
+                if (input.index !== undefined) {
+                    set([...array.slice(0, input.index), parsed, ...array.slice(input.index)]);
+                }
+                else {
+                    set([...array, parsed]);
+                }
+                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().describe('The ID of the item to update.'),
+                value: setInputSchema.describe('The fields to update. Only provided fields will be changed; omitted fields retain their current values.'),
+            }),
+            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);
+                const newArray = [...array];
+                newArray[index] = validated;
+                set(newArray);
+                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).describe('The zero-based index of the item to update.'),
+                value: setInputSchema.describe('The fields to update. Only provided fields will be changed; omitted fields retain their current values.'),
+            }),
+            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);
+                const newArray = [...array];
+                newArray[input.index] = validated;
+                set(newArray);
+                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.object({
+                id: z.string().optional().describe('The ID of the item to delete. Ignored if `all` is true.'),
+                all: z.literal(true).optional().describe(`Delete all items in ${description}. This takes precedence over \`id\`.`),
+            }),
+            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) {
+                        set([...array.slice(0, index), ...array.slice(index + 1)]);
+                    }
+                }
+                return { success: true };
+            },
+        });
+    }
+    else {
+        tools.push({
+            name: `delete_${name}`,
+            description: `Delete an item from ${description} by index, or delete all items`,
+            inputSchema: z.object({
+                index: z.number().int().min(0).optional().describe('The zero-based index of the item to delete. Ignored if `all` is true.'),
+                all: z.literal(true).optional().describe(`Delete all items in ${description}. This takes precedence over \`index\`.`),
+            }),
+            handler: async (input) => {
+                const array = get();
+                if (input.all) {
+                    set([]);
+                }
+                else if (input.index !== undefined) {
+                    if (input.index < array.length) {
+                        set([...array.slice(0, input.index), ...array.slice(input.index + 1)]);
+                    }
+                }
+                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) {
+    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().describe('The key of the entry to retrieve. If omitted, returns all entries.'),
+        }),
+        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().describe('The key for the entry to set.'),
+            value: setInputSchema.describe('The value to set. For existing object entries, only provided fields will be changed.'),
+        }),
+        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);
+                set({ ...record, [input.key]: validated });
+                return { success: true, value: validated };
+            }
+            // Otherwise, full replacement (upsert)
+            const validated = valueSchema.parse(input.value);
+            set({ ...record, [input.key]: validated });
+            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.object({
+            key: z.string().optional().describe('The key of the entry to delete. Ignored if `all` is true.'),
+            all: z.literal(true).optional().describe(`Delete all entries in ${description}. This takes precedence over \`key\`.`),
+        }),
+        handler: async (input) => {
+            const record = get();
+            if (input.all) {
+                set({});
+            }
+            else if (input.key) {
+                const { [input.key]: _, ...rest } = record;
+                set(rest);
+            }
+            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) {
+    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().describe('If true, excludes array and record collections from the response, returning only fixed-shape properties.'),
+        }),
+        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();
+                set({ ...current, [key]: value });
+            },
+            schema: field,
+        };
+        if (unwrappedField instanceof z.ZodArray) {
+            tools.push(...generateArrayTools(collectionOptions));
+        }
+        else if (unwrappedField instanceof z.ZodRecord) {
+            tools.push(...generateRecordTools(collectionOptions));
+        }
+    }
+    return tools;
+}

package/dist/tool-generators/types.d.ts

@@ -0,0 +1,26 @@
+import type { ToolDefinitionZod } from '@mcp-web/types';
+import type { z } from 'zod';
+export interface ToolGenerationOptions {
+    name: string;
+    description: string;
+    get: () => unknown;
+    set: (value: unknown) => void;
+    schema: z.ZodTypeAny;
+}
+export interface GeneratedTools {
+    tools: ToolDefinitionZod[];
+    warnings: string[];
+}
+export interface SchemaShape {
+    type: 'fixed' | 'dynamic' | 'mixed' | 'unsupported';
+    subtype: 'object' | 'array' | 'record' | 'primitive' | 'tuple' | 'unknown';
+    hasOptionalFields: boolean;
+    optionalPaths: string[];
+    fixedPaths: string[];
+    dynamicPaths: string[];
+}
+export interface KeyFieldResult {
+    type: 'explicit' | 'none';
+    field?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tool-generators/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tool-generators/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,OAAO,CAAC;IACnB,GAAG,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9B,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,CAAC;IACpD,OAAO,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,GAAG,SAAS,CAAC;IAC3E,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/tool-generators/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tool-generators/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Deep merge two objects recursively.
+ * Used for partial updates to state objects.
+ *
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns The merged result
+ *
+ * Key behaviors:
+ * - `undefined` in source → keep target value (no change)
+ * - `null` in source → set to null (explicit clear)
+ * - Nested objects → recursively merged
+ * - Arrays → replaced entirely (not merged)
+ */
+export declare function deepMerge(target: unknown, source: unknown): unknown;
+//# sourceMappingURL=utils.d.ts.map

package/dist/tool-generators/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/tool-generators/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAenE"}

package/dist/tool-generators/utils.js

@@ -0,0 +1,35 @@
+/**
+ * Deep merge two objects recursively.
+ * Used for partial updates to state objects.
+ *
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns The merged result
+ *
+ * Key behaviors:
+ * - `undefined` in source → keep target value (no change)
+ * - `null` in source → set to null (explicit clear)
+ * - Nested objects → recursively merged
+ * - Arrays → replaced entirely (not merged)
+ */
+export function deepMerge(target, source) {
+    // Base cases
+    if (source === null)
+        return source; // Explicit null clears the value
+    if (source === undefined)
+        return target; // Undefined means "no change"
+    if (typeof source !== 'object')
+        return source;
+    if (Array.isArray(source))
+        return source; // Arrays are replaced, not merged
+    if (typeof target !== 'object' || target === null)
+        return source;
+    if (Array.isArray(target))
+        return source;
+    // Object merge: recursively merge properties
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        result[key] = deepMerge(result[key], value);
+    }
+    return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+import type { ToolDefinition } from '@mcp-web/types';
+import type { z } from 'zod';
+import type { ContextItemSchema, EphemeralContextSchema, QueryRequestSchema, QueryResponseResultAcceptedSchema, QueryResponseResultCompleteSchema, QueryResponseResultFailureSchema, QueryResponseResultProgressSchema, QueryResponseResultSchema } from './schemas.js';
+export type QueryResponseResult = z.infer<typeof QueryResponseResultSchema>;
+export type QueryRequest = Omit<z.input<typeof QueryRequestSchema>, 'responseTool' | 'tools' | 'context'> & {
+    responseTool?: ToolDefinition;
+    tools?: ToolDefinition[];
+    context?: (ToolDefinition | EphemeralContext)[];
+};
+export type QueryRequestOutput = z.infer<typeof QueryRequestSchema>;
+export type QueryResponseResultAccepted = z.infer<typeof QueryResponseResultAcceptedSchema>;
+export type QueryResponseResultProgress = z.infer<typeof QueryResponseResultProgressSchema>;
+export type QueryResponseResultComplete = z.infer<typeof QueryResponseResultCompleteSchema>;
+export type QueryResponseResultFailure = z.infer<typeof QueryResponseResultFailureSchema>;
+export type ContextItem = z.infer<typeof ContextItemSchema>;
+export type EphemeralContext = z.infer<typeof EphemeralContextSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EACV,iBAAiB,EACjB,sBAAsB,EACtB,kBAAkB,EAClB,iCAAiC,EACjC,iCAAiC,EACjC,gCAAgC,EAChC,iCAAiC,EACjC,yBAAyB,EAC1B,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,EAAE,cAAc,GAAG,OAAO,GAAG,SAAS,CAAC,GAAG;IAC1G,YAAY,CAAC,EAAE,cAAc,CAAC;IAC9B,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,CAAC,cAAc,GAAG,gBAAgB,CAAC,EAAE,CAAC;CACjD,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAC1F,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,31 @@
+import type { ToolMetadataJson, ToolDefinition } from '@mcp-web/types';
+import { z } from 'zod';
+export declare function isZodSchema(schema: z.ZodType<unknown> | z.core.JSONSchema.JSONSchema): schema is z.ZodType<unknown>;
+export declare function toJSONSchema(schema: z.ZodType | z.core.JSONSchema.JSONSchema): z.core.JSONSchema.JSONSchema;
+export declare function toToolZodSchema<T>(schema?: z.ZodType<T> | z.core.JSONSchema.JSONSchema): z.ZodObject;
+export declare function toToolSchema<T>(schema?: z.ZodType<T> | z.core.JSONSchema.JSONSchema): z.ZodObject | z.core.JSONSchema.JSONSchema;
+export declare function validateInput<T>(input: unknown, schema: z.ZodType<T> | z.core.JSONSchema.JSONSchema): T;
+/**
+ * Convert a ToolDefinition to ToolMetadataJson for wire transmission.
+ * Removes the handler and converts Zod schemas to JSON Schema.
+ *
+ * @param tool - The tool definition to convert
+ * @returns Serializable tool metadata without handler, with JSON Schema schemas
+ */
+export declare function toToolMetadataJson(tool: ToolDefinition): ToolMetadataJson;
+/**
+ * Deep merge two objects recursively.
+ * Used for partial updates to state objects.
+ *
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns The merged result
+ *
+ * Key behaviors:
+ * - `undefined` in source → keep target value (no change)
+ * - `null` in source → set to null (explicit clear)
+ * - Nested objects → recursively merged
+ * - Arrays → replaced entirely (not merged)
+ */
+export declare function deepMerge(target: unknown, source: unknown): unknown;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEvE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,wBAAgB,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAEnH;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAY3G;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,CAAC,CAAC,SAAS,CAOpG;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAWhI;AAED,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,GAClD,CAAC,CAqBH;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,gBAAgB,CAOzE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAenE"}