@mcp-web/core 0.1.0

package/dist/utils.js

@@ -0,0 +1,108 @@
+import Ajv from 'ajv';
+import { z } from 'zod';
+const ajv = new Ajv({ strict: false });
+// Type guard to check if a schema is a Zod schema
+export function isZodSchema(schema) {
+    return typeof schema === 'object' && 'safeParse' in schema;
+}
+export function toJSONSchema(schema) {
+    if (schema && typeof schema === 'object' && 'safeParse' in schema) {
+        const jsonSchema = z.toJSONSchema(schema);
+        // Remove $schema property to avoid AJV Draft 2020-12 validation errors
+        // Our AJV instance only supports Draft 7
+        if (typeof jsonSchema === 'object' && '$schema' in jsonSchema) {
+            const { $schema: _unused, ...rest } = jsonSchema;
+            return rest;
+        }
+        return jsonSchema;
+    }
+    return schema;
+}
+export function toToolZodSchema(schema) {
+    // If it's already an object schema, use as-is
+    if (schema instanceof z.ZodObject) {
+        return schema;
+    }
+    // For non-objects, wrap in a value property for consistent tool interface
+    return z.object({ value: schema });
+}
+// Convert schema to appropriate format for tools
+export function toToolSchema(schema) {
+    if (!schema) {
+        return z.object({});
+    }
+    if (isZodSchema(schema)) {
+        return toToolZodSchema(schema);
+    }
+    // Handle JSON Schema case
+    return schema;
+}
+export function validateInput(input, schema) {
+    if (!schema) {
+        return input;
+    }
+    if (isZodSchema(schema)) {
+        const result = schema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`Invalid input: ${result.error.message}`);
+        }
+        return result.data;
+    }
+    // JSON Schema validation
+    const validate = ajv.compile(schema);
+    const isValid = validate(input);
+    if (!isValid) {
+        throw new Error(`Invalid input: ${ajv.errorsText(validate.errors)}`);
+    }
+    return input;
+}
+/**
+ * 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 function toToolMetadataJson(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema ? toJSONSchema(tool.inputSchema) : undefined,
+        outputSchema: tool.outputSchema ? toJSONSchema(tool.outputSchema) : undefined,
+    };
+}
+/**
+ * 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;
+}