@mcp-web/core 0.1.0 → 0.1.2

package/dist/web.d.ts

@@ -40,7 +40,7 @@ import type { QueryRequest } from './types.js';
  *   name: 'Checkers Game',
  *   description: 'Interactive checkers game controllable by AI agents',
  *   bridgeUrl: 'localhost:3001',
- *   icon: 'https://example.com/icon.png',
+ *   icon: 'https://example.com/icon.svg',
  *   agentUrl: 'localhost:3003',
  *   autoConnect: true,
  * });

package/dist/web.js

@@ -42,7 +42,7 @@ import { toJSONSchema, toToolMetadataJson } from './utils.js';
  *   name: 'Checkers Game',
  *   description: 'Interactive checkers game controllable by AI agents',
  *   bridgeUrl: 'localhost:3001',
- *   icon: 'https://example.com/icon.png',
+ *   icon: 'https://example.com/icon.svg',
  *   agentUrl: 'localhost:3003',
  *   autoConnect: true,
  * });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-web/core",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -37,9 +37,9 @@
   "dependencies": {
     "ajv": "^8.17.1",
     "zod": "~4.1.12",
-    "@mcp-web/bridge": "0.1.0",
-    "@mcp-web/decompose-zod-schema": "0.1.0",
-    "@mcp-web/types": "0.1.0"
+    "@mcp-web/bridge": "0.1.2",
+    "@mcp-web/types": "0.1.2",
+    "@mcp-web/decompose-zod-schema": "0.1.2"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
@@ -49,6 +49,11 @@
   "peerDependencies": {
     "react": ">=16.8.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flekschas/mcp-web",
+    "directory": "packages/core"
+  },
   "scripts": {
     "dev": "tsc --watch",
     "build": "tsc",

package/dist/expanded-schema-tools/generate-fixed-shape-tools.d.ts

@@ -1,8 +0,0 @@
-import type { ToolDefinition } from '@mcp-web/types';
-import type { SchemaShape, ToolGenerationOptions } from './types.js';
-/**
- * Generates getter and setter tools for fixed-shape schemas.
- * Fixed-shape includes: primitives, tuples, and objects with only fixed props.
- */
-export declare function generateFixedShapeTools(options: ToolGenerationOptions, shape: SchemaShape): ToolDefinition[];
-//# sourceMappingURL=generate-fixed-shape-tools.d.ts.map

package/dist/expanded-schema-tools/generate-fixed-shape-tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-fixed-shape-tools.d.ts","sourceRoot":"","sources":["../../src/expanded-schema-tools/generate-fixed-shape-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGrE;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,qBAAqB,EAC9B,KAAK,EAAE,WAAW,GACjB,cAAc,EAAE,CAgDlB"}

package/dist/expanded-schema-tools/generate-fixed-shape-tools.js

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { deriveSetInputSchema, unwrapSchema } from './schema-helpers.js';
-import { deepMerge } from './utils.js';
-/**
- * Generates getter and setter tools for fixed-shape schemas.
- * Fixed-shape includes: primitives, tuples, and objects with only fixed props.
- */
-export function generateFixedShapeTools(options, shape) {
-    const { name, description, get, set, schema } = options;
-    const tools = [];
-    const unwrapped = unwrapSchema(schema);
-    // Getter tool
-    tools.push({
-        name: `get_${name}`,
-        description: `Get the current ${description}`,
-        inputSchema: z.object({}),
-        handler: async () => {
-            return get();
-        },
-    });
-    // Setter tool - behavior depends on subtype
-    if (shape.subtype === 'primitive' || shape.subtype === 'tuple') {
-        // Full replacement for primitives and tuples
-        tools.push({
-            name: `set_${name}`,
-            description: `Set the ${description}`,
-            inputSchema: z.object({ value: schema }),
-            handler: async (input) => {
-                const validated = schema.parse(input.value);
-                set(validated);
-                return { success: true, value: validated };
-            },
-        });
-    }
-    else if (shape.subtype === 'object') {
-        // Partial update with deep merge for objects
-        const objectSchema = unwrapped;
-        const setInputSchema = deriveSetInputSchema(objectSchema);
-        tools.push({
-            name: `set_${name}`,
-            description: `Update the ${description} (partial update with deep merge)`,
-            inputSchema: setInputSchema,
-            handler: async (input) => {
-                const current = get();
-                const merged = deepMerge(current, input);
-                const validated = schema.parse(merged);
-                set(validated);
-                return { success: true, value: validated };
-            },
-        });
-    }
-    return tools;
-}

package/dist/expanded-schema-tools/generate-fixed-shape-tools.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=generate-fixed-shape-tools.test.d.ts.map

package/dist/expanded-schema-tools/generate-fixed-shape-tools.test.d.ts.map

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

package/dist/expanded-schema-tools/generate-fixed-shape-tools.test.js

@@ -1,331 +0,0 @@
-import { expect, test } from 'bun:test';
-import { z } from 'zod';
-import { generateFixedShapeTools } from './generate-fixed-shape-tools.js';
-import { analyzeSchemaShape } from './schema-analysis.js';
-import { system } from './schema-helpers.js';
-// ============================================================================
-// Primitive Tools
-// ============================================================================
-test('generateFixedShapeTools() - generates get + set for string', () => {
-    let state = 'initial';
-    const schema = z.string();
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'text',
-        description: 'text value',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    expect(tools).toHaveLength(2);
-    expect(tools[0].name).toBe('get_text');
-    expect(tools[1].name).toBe('set_text');
-});
-test('generateFixedShapeTools() - get returns current value', async () => {
-    let state = 'hello';
-    const schema = z.string();
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'text',
-        description: 'text value',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const getter = tools[0];
-    const result = await getter.handler({});
-    expect(result).toBe('hello');
-});
-test('generateFixedShapeTools() - set uses full replacement for primitives', async () => {
-    let state = 'initial';
-    const schema = z.string();
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'text',
-        description: 'text value',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    const result = await setter.handler({ value: 'updated' });
-    expect(result).toEqual({ success: true, value: 'updated' });
-    expect(state).toBe('updated');
-});
-test('generateFixedShapeTools() - set validates with schema', async () => {
-    let state = 5;
-    const schema = z.number().min(0).max(10);
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'count',
-        description: 'count value',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    // Valid value
-    await setter.handler({ value: 7 });
-    expect(state).toBe(7);
-    // Invalid value (out of range) should throw
-    try {
-        await setter.handler({ value: 15 });
-        expect(true).toBe(false); // Should not reach here
-    }
-    catch (error) {
-        expect(error).toBeDefined();
-    }
-});
-test('generateFixedShapeTools() - generates get + set for number', () => {
-    let state = 42;
-    const schema = z.number();
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'count',
-        description: 'count value',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    expect(tools).toHaveLength(2);
-    expect(tools[0].name).toBe('get_count');
-    expect(tools[1].name).toBe('set_count');
-});
-test('generateFixedShapeTools() - generates get + set for boolean', () => {
-    let state = true;
-    const schema = z.boolean();
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'active',
-        description: 'active flag',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    expect(tools).toHaveLength(2);
-    expect(tools[0].name).toBe('get_active');
-    expect(tools[1].name).toBe('set_active');
-});
-// ============================================================================
-// Tuple Tools
-// ============================================================================
-test('generateFixedShapeTools() - generates get + set for tuple', () => {
-    let state = ['hello', 42, true];
-    const schema = z.tuple([z.string(), z.number(), z.boolean()]);
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'coords',
-        description: 'coordinates',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    expect(tools).toHaveLength(2);
-    expect(tools[0].name).toBe('get_coords');
-    expect(tools[1].name).toBe('set_coords');
-});
-test('generateFixedShapeTools() - set uses full replacement for tuples', async () => {
-    let state = [10, 20];
-    const schema = z.tuple([z.number(), z.number()]);
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'coords',
-        description: 'coordinates',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    const result = await setter.handler({ value: [30, 40] });
-    expect(result).toEqual({ success: true, value: [30, 40] });
-    expect(state).toEqual([30, 40]);
-});
-// ============================================================================
-// Fixed Object Tools
-// ============================================================================
-test('generateFixedShapeTools() - generates get + set for fixed-shape object', () => {
-    let state = { name: 'Alice', age: 30 };
-    const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-    });
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'user',
-        description: 'user data',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    expect(tools).toHaveLength(2);
-    expect(tools[0].name).toBe('get_user');
-    expect(tools[1].name).toBe('set_user');
-});
-test('generateFixedShapeTools() - set uses partial update with deep merge', async () => {
-    let state = {
-        name: 'Alice',
-        age: 30,
-        settings: { theme: 'dark', notifications: true },
-    };
-    const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-        settings: z.object({
-            theme: z.string(),
-            notifications: z.boolean(),
-        }),
-    });
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'user',
-        description: 'user data',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    // Partial update - only change age
-    await setter.handler({ age: 31 });
-    expect(state.age).toBe(31);
-    expect(state.name).toBe('Alice'); // Unchanged
-    expect(state.settings).toEqual({ theme: 'dark', notifications: true }); // Unchanged
-    // Partial update - nested object
-    await setter.handler({ settings: { theme: 'light' } });
-    expect(state.settings.theme).toBe('light');
-    expect(state.settings.notifications).toBe(true); // Preserved via deep merge
-});
-test('generateFixedShapeTools() - set excludes system fields from input schema', () => {
-    let state = { id: 'abc', name: 'Alice', created_at: 123456 };
-    const schema = z.object({
-        id: system(z.string().default(() => crypto.randomUUID())),
-        name: z.string(),
-        created_at: system(z.number().default(() => Date.now())),
-    });
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'user',
-        description: 'user data',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    const inputSchema = setter.inputSchema;
-    // System fields should not be in input schema
-    expect('id' in inputSchema.shape).toBe(false);
-    expect('created_at' in inputSchema.shape).toBe(false);
-    expect('name' in inputSchema.shape).toBe(true);
-});
-test('generateFixedShapeTools() - set makes all fields optional', () => {
-    let state = { name: 'Alice', age: 30, email: 'alice@example.com' };
-    const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-        email: z.string(),
-    });
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'user',
-        description: 'user data',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    const inputSchema = setter.inputSchema;
-    // All fields should be optional
-    const emptyResult = inputSchema.safeParse({});
-    expect(emptyResult.success).toBe(true);
-    const partialResult = inputSchema.safeParse({ name: 'Bob' });
-    expect(partialResult.success).toBe(true);
-});
-test('generateFixedShapeTools() - deep merge preserves unspecified fields', async () => {
-    let state = {
-        user: {
-            name: 'Alice',
-            email: 'alice@example.com',
-            profile: {
-                bio: 'Hello',
-                avatar: 'avatar.png',
-            },
-        },
-    };
-    const schema = z.object({
-        user: z.object({
-            name: z.string(),
-            email: z.string(),
-            profile: z.object({
-                bio: z.string(),
-                avatar: z.string(),
-            }),
-        }),
-    });
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'data',
-        description: 'data',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    // Update only deeply nested field
-    await setter.handler({
-        user: { profile: { bio: 'Updated bio' } },
-    });
-    expect(state.user.name).toBe('Alice'); // Preserved
-    expect(state.user.email).toBe('alice@example.com'); // Preserved
-    expect(state.user.profile.bio).toBe('Updated bio'); // Updated
-    expect(state.user.profile.avatar).toBe('avatar.png'); // Preserved
-});
-test('generateFixedShapeTools() - set returns success response with value', async () => {
-    let state = { name: 'Alice', age: 30 };
-    const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-    });
-    const shape = analyzeSchemaShape(schema);
-    const tools = generateFixedShapeTools({
-        name: 'user',
-        description: 'user data',
-        get: () => state,
-        set: (value) => {
-            state = value;
-        },
-        schema,
-    }, shape);
-    const setter = tools[1];
-    const result = await setter.handler({ age: 31 });
-    expect(result).toHaveProperty('success', true);
-    expect(result).toHaveProperty('value');
-    expect(result.value).toEqual({
-        name: 'Alice',
-        age: 31,
-    });
-});

package/dist/expanded-schema-tools/index.d.ts

@@ -1,4 +0,0 @@
-export { id, system } from './schema-helpers.js';
-export { generateToolsForSchema } from './tool-generator.js';
-export type { GeneratedTools, KeyFieldResult, SchemaShape, ToolGenerationOptions } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/expanded-schema-tools/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/expanded-schema-tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC"}

package/dist/expanded-schema-tools/index.js

@@ -1,2 +0,0 @@
-export { id, system } from './schema-helpers.js';
-export { generateToolsForSchema } from './tool-generator.js';

package/dist/expanded-schema-tools/integration.test.d.ts

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

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

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