@hotmeshio/long-tail 0.1.13 → 0.1.15

package/build/system/mcp-servers/knowledge.js

@@ -39,10 +39,11 @@ const zod_1 = require("zod");
 const logger_1 = require("../../lib/logger");
 const knowledge = __importStar(require("../activities/knowledge"));
 const storeSchema = zod_1.z.object({
-    domain: zod_1.z.string().describe('Knowledge domain (namespace)'),
-    key: zod_1.z.string().describe('Unique key within domain'),
-    data: zod_1.z.record(zod_1.z.any()).describe('JSONB object payload to store (must be an object, not a string — wrap text as { "description": "..." })'),
-    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Categorization tags'),
+    domain: zod_1.z.string().describe('Namespace grouping related entries (e.g. "screenshots", "config", "analysis").'),
+    key: zod_1.z.string().describe('Unique identifier within the domain (e.g. "google", "user_profile").'),
+    field: zod_1.z.string().optional().describe('RECOMMENDED. Names a specific field to set within the entry (e.g. "2026-05-09", "url", "score"). Using field is additive — it merges into existing data without clobbering other fields. Without field, the entire data object is merged at the top level, which can overwrite existing fields with the same keys. Always use field when adding to an entry that may already have data.'),
+    data: zod_1.z.any().describe('The value to store. When field is provided, this can be any type (string, number, boolean, object, array) and is stored as { [field]: data }. When field is omitted, data must be a JSON object whose keys merge into existing data.'),
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Categorization tags (unioned on upsert)'),
 });
 const getSchema = zod_1.z.object({
     domain: zod_1.z.string().describe('Knowledge domain'),
@@ -53,9 +54,11 @@ const searchSchema = zod_1.z.object({
     query: zod_1.z.record(zod_1.z.any()).describe('JSONB containment query (e.g. {"type":"screenshot"})'),
     tags: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by tags (any match)'),
     limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
+    offset: zod_1.z.number().optional().describe('Pagination offset'),
 });
 const listSchema = zod_1.z.object({
     domain: zod_1.z.string().describe('Knowledge domain'),
+    search: zod_1.z.string().optional().describe('Search by key name or tag (partial match)'),
     tags: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by tags (any match)'),
     limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
     offset: zod_1.z.number().optional().describe('Pagination offset'),
@@ -64,6 +67,18 @@ const deleteSchema = zod_1.z.object({
     domain: zod_1.z.string().describe('Knowledge domain'),
     key: zod_1.z.string().describe('Document key to delete'),
 });
+const setFieldSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    key: zod_1.z.string().describe('Document key'),
+    path: zod_1.z.string().describe('Dot-notation path to the field (e.g. "google.holiday", "config.retries"). Sets the value at this exact path without overwriting sibling fields.'),
+    value: zod_1.z.any().refine((v) => v !== undefined, 'value is required').describe('Value to set — any JSON type (string, number, boolean, object, array)'),
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Tags to union with existing tags'),
+});
+const removeFieldSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    key: zod_1.z.string().describe('Document key'),
+    path: zod_1.z.string().describe('Dot-notation path to remove (e.g. "google.legacy_data", "temp.cache")'),
+});
 const appendSchema = zod_1.z.object({
     domain: zod_1.z.string().describe('Knowledge domain'),
     key: zod_1.z.string().describe('Document key'),
@@ -73,10 +88,38 @@ const appendSchema = zod_1.z.object({
 function registerTools(server) {
     server.registerTool('store_knowledge', {
         title: 'Store Knowledge',
-        description: 'Store or update a knowledge entry. Upserts by domain+key: merges data and unions tags if the entry already exists.',
+        description: 'Store a value in the knowledge base using a 3-level hierarchy: domain > key > field. ' +
+            'IMPORTANT: Always use the field parameter when adding data to an existing entry — ' +
+            'it merges additively without clobbering other fields. Without field, top-level keys ' +
+            'in data overwrite existing keys with the same name. ' +
+            'Example: domain="screenshots", key="google", field="2026-05-10", data="description text".',
         inputSchema: storeSchema,
     }, async (args) => {
-        const result = await knowledge.storeKnowledge(args);
+        // When field is provided, wrap the data value as { [field]: data }
+        // so it merges into the JSONB column at the field level.
+        // When field is omitted, data must be a plain object — reject strings,
+        // arrays, and primitives that would corrupt the JSONB merge
+        // (Postgres `object || string` produces an array, not a merge).
+        let dataObj;
+        if (args.field != null) {
+            dataObj = { [args.field]: args.data };
+        }
+        else {
+            if (args.data == null || typeof args.data !== 'object' || Array.isArray(args.data)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'When field is omitted, data must be a JSON object. Use the field parameter to store strings and other primitives.',
+                            }),
+                        }],
+                };
+            }
+            dataObj = args.data;
+        }
+        const result = await knowledge.storeKnowledge({
+            domain: args.domain, key: args.key, data: dataObj, tags: args.tags,
+        });
         return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     });
     server.registerTool('get_knowledge', {
@@ -127,6 +170,26 @@ function registerTools(server) {
         const result = await knowledge.appendKnowledge(args);
         return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     });
+    server.registerTool('set_knowledge_field', {
+        title: 'Set Knowledge Field',
+        description: 'RECOMMENDED for updating existing entries. Set a value at a specific path within a knowledge entry ' +
+            'without overwriting sibling fields. Use dot-notation for nested paths (e.g. "google.holiday" sets ' +
+            'data.google.holiday while preserving data.google.description). Creates the entry if it does not exist. ' +
+            'Use this instead of store_knowledge when the entry may already have data you want to preserve.',
+        inputSchema: setFieldSchema,
+    }, async (args) => {
+        const result = await knowledge.setKnowledgeField(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('remove_knowledge_field', {
+        title: 'Remove Knowledge Field',
+        description: 'Remove a specific field from a knowledge entry by dot-path. The entry survives — only the targeted ' +
+            'path is deleted. Use this for intentional cleanup of obsolete or incorrect fields.',
+        inputSchema: removeFieldSchema,
+    }, async (args) => {
+        const result = await knowledge.removeKnowledgeField(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
 }
 async function createKnowledgeServer(options) {
     const name = options?.name || 'long-tail-knowledge';

package/build/system/mcp-servers/schema-exchange.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createSchemaExchangeServer(options?: {
+    name?: string;
+}): Promise<McpServer>;

package/build/system/mcp-servers/schema-exchange.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchemaExchangeServer = createSchemaExchangeServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../../lib/logger");
+const schemaExchange = __importStar(require("../activities/schema-exchange"));
+const exchangeSchema = zod_1.z.object({
+    endpoint: zod_1.z.string().optional().describe('Service endpoint URL. Supports template variables resolved by the caller (e.g. /Patient/{id}).'),
+    url: zod_1.z.string().optional().describe('Alias for endpoint (either endpoint or url is required).'),
+    method: zod_1.z.string().describe('HTTP method: GET, POST, PUT, DELETE, PATCH.'),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe('Request headers (e.g. Authorization, Accept, Content-Type).'),
+    query: zod_1.z.record(zod_1.z.string()).optional().describe('Query parameters appended to the URL.'),
+    body: zod_1.z.any().optional().describe('Request body. Validated against request_schema before sending (if provided).'),
+    request_schema: zod_1.z.record(zod_1.z.any()).optional().describe('JSON Schema for the request body. When provided, the body is validated before the request is sent. Validation failure returns immediately — the request is never made.'),
+    response_schema: zod_1.z.record(zod_1.z.any()).optional().describe('JSON Schema for the expected response body. When provided, the response is validated after receiving. The validated flag and validation_errors in the output indicate whether the response matched.'),
+    timeout_ms: zod_1.z.number().optional().describe('Request timeout in milliseconds (default: 30000).'),
+    credential_provider: zod_1.z.string().optional().describe('Credential provider name (e.g. "stripe", "epic", "google"). When set, resolves authentication from the connection store using the calling principal\'s identity. No manual token input needed.'),
+    credential_label: zod_1.z.string().optional().describe('Credential label for multi-credential accounts (default: "default").'),
+    auth_scheme: zod_1.z.string().optional().describe('Authentication scheme (default: "Bearer"). Used with credential_provider to build the auth header value.'),
+    auth_header: zod_1.z.string().optional().describe('Header name for the credential (default: "Authorization"). Some APIs use X-API-Key instead.'),
+});
+const validateSchema = zod_1.z.object({
+    data: zod_1.z.any().describe('The value to validate against the schema.'),
+    schema: zod_1.z.record(zod_1.z.any()).describe('JSON Schema to validate against.'),
+});
+async function createSchemaExchangeServer(options) {
+    const name = options?.name || 'long-tail-schema-exchange';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    instance.registerTool('exchange', {
+        title: 'Schema Exchange',
+        description: 'Exchange data with an external service endpoint under schema enforcement. ' +
+            'Validates the request body against request_schema before sending and the response ' +
+            'body against response_schema after receiving. Transport is an implementation detail — ' +
+            'the principle is endpoint + schema + validated data exchange. ' +
+            'Use response_schema to detect API drift: schedule on cron and the validated flag ' +
+            'tells you immediately when the API shape changes.',
+        inputSchema: exchangeSchema,
+    }, async (args) => {
+        try {
+            const result = await schemaExchange.exchange(args);
+            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }], isError: true };
+        }
+    });
+    instance.registerTool('validate_schema', {
+        title: 'Validate Schema',
+        description: 'Validate any value against a JSON Schema without making a network call. ' +
+            'Useful for pre-validating data before storage, checking API response shapes in tests, ' +
+            'or verifying that transforms produce correct output.',
+        inputSchema: validateSchema,
+    }, async (args) => {
+        const result = schemaExchange.validateSchema(args.data, args.schema);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    logger_1.loggerRegistry.info(`[lt-mcp:schema-exchange] ${name} ready (2 tools registered)`);
+    return instance;
+}

package/build/system/mcp-servers/workflow-compiler.js

@@ -40,6 +40,7 @@ const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
 const logger_1 = require("../../lib/logger");
 const yamlGenerator = __importStar(require("../../services/yaml-workflow/generator"));
+const durable_compiler_1 = require("../../services/yaml-workflow/durable-compiler");
 const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
 const yamlDeployer = __importStar(require("../../services/yaml-workflow/deployer"));
 const yamlWorkers = __importStar(require("../../services/yaml-workflow/workers"));
@@ -65,6 +66,13 @@ const listSchema = zod_1.z.object({
     offset: zod_1.z.number().int().min(0).optional().default(0)
         .describe('Pagination offset'),
 });
+const compileDurableSchema = zod_1.z.object({
+    source: zod_1.z.string().describe('TypeScript source code of the durable workflow function (inline source, not a file path)'),
+    workflow_name: zod_1.z.string().describe('Name of the exported workflow function to compile (e.g., "assemblyLine", "basicSignal")'),
+    yaml_name: zod_1.z.string().describe('Name for the generated YAML workflow (becomes graph topic)'),
+    description: zod_1.z.string().optional().describe('Optional description of what the workflow does'),
+    app_id: zod_1.z.string().optional().describe('Target namespace (defaults to "longtail")'),
+});
 /**
  * Create the Workflow Compiler MCP server.
  *
@@ -216,6 +224,52 @@ async function createWorkflowCompilerServer(options) {
                 }],
         };
     });
+    // ── compile_durable_to_yaml ────────────────────────────────────────
+    server.registerTool('compile_durable_to_yaml', {
+        title: 'Compile Durable Workflow to YAML',
+        description: 'Convert a procedural durable TypeScript workflow (Temporal-like API) into an equivalent ' +
+            'HotMesh YAML DAG. The generated YAML runs without replay overhead and achieves the same ' +
+            'orchestration behavior. Handles proxyActivities, sleep, condition/signal, escalation, ' +
+            'startChild composition, parallel execution, and loop patterns.',
+        inputSchema: compileDurableSchema,
+    }, async (args) => {
+        const result = await (0, durable_compiler_1.compileDurableToYaml)({
+            source: args.source,
+            isFilePath: false,
+            workflowName: args.workflow_name,
+            name: args.yaml_name,
+            description: args.description,
+            appId: args.app_id,
+        });
+        const record = await yamlDb.createYamlWorkflow({
+            name: args.yaml_name,
+            description: args.description,
+            app_id: result.appId,
+            yaml_content: result.yaml,
+            graph_topic: result.graphTopic,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: result.activityManifest,
+            tags: result.tags,
+            source_workflow_type: 'durable',
+            original_prompt: args.description,
+            category: result.category,
+            metadata: { durable_source: args.source },
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        yaml_workflow_id: record.id,
+                        app_id: record.app_id,
+                        graph_topic: result.graphTopic,
+                        activity_count: result.activityManifest.filter((a) => a.type === 'worker').length,
+                        input_schema: result.inputSchema,
+                        yaml_preview: result.yaml.slice(0, 500),
+                    }),
+                }],
+        };
+    });
     logger_1.loggerRegistry.info(`[lt-mcp] workflow compiler server created: ${name}`);
     return server;
 }

package/build/system/seed/server-definitions.d.ts

@@ -2931,10 +2931,13 @@ export declare const SEED_MCP_SERVERS: ({
                     type: string;
                     description: string;
                 };
-                data: {
+                field: {
                     type: string;
                     description: string;
                 };
+                data: {
+                    description: string;
+                };
                 tags: {
                     type: string;
                     items: {
@@ -2964,6 +2967,7 @@ export declare const SEED_MCP_SERVERS: ({
                     type: string;
                     description: string;
                 };
+                field?: undefined;
                 data?: undefined;
                 tags?: undefined;
                 query?: undefined;
@@ -3000,6 +3004,7 @@ export declare const SEED_MCP_SERVERS: ({
                     description: string;
                 };
                 key?: undefined;
+                field?: undefined;
                 data?: undefined;
                 offset?: undefined;
                 path?: undefined;
@@ -3033,6 +3038,7 @@ export declare const SEED_MCP_SERVERS: ({
                     description: string;
                 };
                 key?: undefined;
+                field?: undefined;
                 data?: undefined;
                 query?: undefined;
                 path?: undefined;
@@ -3048,6 +3054,7 @@ export declare const SEED_MCP_SERVERS: ({
             properties: {
                 domain?: undefined;
                 key?: undefined;
+                field?: undefined;
                 data?: undefined;
                 tags?: undefined;
                 query?: undefined;
@@ -3079,6 +3086,7 @@ export declare const SEED_MCP_SERVERS: ({
                 value: {
                     description: string;
                 };
+                field?: undefined;
                 data?: undefined;
                 tags?: undefined;
                 query?: undefined;
@@ -3096,4 +3104,107 @@ export declare const SEED_MCP_SERVERS: ({
     tags: string[];
     compile_hints: string;
     credential_providers: never[];
+} | {
+    name: string;
+    description: string;
+    transport_type: string;
+    transport_config: {
+        builtin: boolean;
+        process: string;
+    };
+    tool_manifest: ({
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                endpoint: {
+                    type: string;
+                    description: string;
+                };
+                method: {
+                    type: string;
+                    description: string;
+                };
+                headers: {
+                    type: string;
+                    description: string;
+                };
+                query: {
+                    type: string;
+                    description: string;
+                };
+                body: {
+                    description: string;
+                };
+                request_schema: {
+                    type: string;
+                    description: string;
+                };
+                response_schema: {
+                    type: string;
+                    description: string;
+                };
+                timeout_ms: {
+                    type: string;
+                    description: string;
+                };
+                credential_provider: {
+                    type: string;
+                    description: string;
+                };
+                credential_label: {
+                    type: string;
+                    description: string;
+                };
+                auth_scheme: {
+                    type: string;
+                    description: string;
+                };
+                auth_header: {
+                    type: string;
+                    description: string;
+                };
+                data?: undefined;
+                schema?: undefined;
+            };
+            required: string[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                data: {
+                    description: string;
+                };
+                schema: {
+                    type: string;
+                    description: string;
+                };
+                endpoint?: undefined;
+                method?: undefined;
+                headers?: undefined;
+                query?: undefined;
+                body?: undefined;
+                request_schema?: undefined;
+                response_schema?: undefined;
+                timeout_ms?: undefined;
+                credential_provider?: undefined;
+                credential_label?: undefined;
+                auth_scheme?: undefined;
+                auth_header?: undefined;
+            };
+            required: string[];
+        };
+    })[];
+    metadata: {
+        builtin: boolean;
+        category: string;
+        level?: undefined;
+    };
+    tags: string[];
+    compile_hints: string;
+    credential_providers: never[];
 })[];

package/build/system/seed/server-definitions.js

@@ -192,4 +192,41 @@ exports.SEED_MCP_SERVERS = [
             'list_domains returns all domains with counts, useful for discovering what knowledge exists.',
         credential_providers: [],
     },
+    {
+        name: 'long-tail-schema-exchange',
+        description: 'Schema-driven data exchange with external service endpoints. Validates requests and responses ' +
+            'against JSON Schema. Transport is an implementation detail — the principle is endpoint + schema + ' +
+            'validated exchange. Use this as the building block for wrapping any external API.',
+        transport_type: 'stdio',
+        transport_config: { builtin: true, process: 'in-memory' },
+        tool_manifest: tool_manifests_data_1.SCHEMA_EXCHANGE_TOOLS,
+        metadata: { builtin: true, category: 'data' },
+        tags: ['api', 'schema', 'exchange', 'validation', 'fetch'],
+        compile_hints: 'Schema-driven data exchange for external API endpoints. Validates requests before sending and responses after receiving against JSON Schema. ' +
+            'When building a workflow that calls an external API endpoint, use exchange as the worker activity. ' +
+            'Embed request_schema and response_schema as STATIC values in input.maps (not dynamic inputs — schemas are fixed per endpoint). ' +
+            'Build the endpoint URL using @pipe concat for template variables. Use "url" for the endpoint field name. ' +
+            'CRITICAL — Authorization headers: when the trigger provides a token and you need to build "Bearer {token}", use this EXACT YAML structure for the headers field in input.maps:\n' +
+            '  headers:\n' +
+            '    Authorization:\n' +
+            '      \'@pipe\':\n' +
+            '        - [\'Bearer \', \'{trigger_XXXX.output.data.token}\']\n' +
+            '        - [\'{@string.concat}\']\n' +
+            'NEVER nest @pipe inside @pipe for headers. NEVER use @object.fromEntries for headers. The headers field is a plain object — each header name is a key, and its value can be a static string or a single @pipe expression. ' +
+            'The trigger input_schema should reflect the endpoint\'s dynamic parameters (IDs, search terms, pagination) plus base_url and credentials. ' +
+            'CRITICAL — exchange output structure: the exchange tool returns { status, data, headers, elapsed_ms, validated, validation_errors }. ' +
+            'The actual API response body is inside the "data" field. So to reference a response field like "token", ' +
+            'use {activity.output.data.data.token} (NOT {activity.output.data.token}). ' +
+            'The double .data is because HotMesh wraps activity output in .output.data, and the exchange tool puts the API response in its own .data field. ' +
+            'For job.maps on the last activity: job.maps.token: \'{exchange_xxxx.output.data.data.token}\'. ' +
+            'Also surface validated and status: job.maps.validated: \'{exchange_xxxx.output.data.validated}\', job.maps.status: \'{exchange_xxxx.output.data.status}\'. ' +
+            'response_schema enables self-testing: schedule the compiled tool on cron against a dev/staging server — if validation fails, the API schema changed. ' +
+            'request_schema prevents malformed requests from ever leaving the system. ' +
+            'Both schemas are optional — use response_schema alone for read endpoints, both for write endpoints, neither for exploratory calls. ' +
+            'For authentication, prefer credential_provider over manually wiring tokens in headers. ' +
+            'Set credential_provider to the provider name registered in the connection store (e.g. "stripe", "epic", "google"). ' +
+            'The tool resolves the credential from the calling principal\'s stored connections at the last mile — no token input needed, auto-refreshes expired tokens. ' +
+            'Use auth_scheme for non-Bearer schemes (e.g. "Basic", "Token") and auth_header for APIs that use X-API-Key instead of Authorization.',
+        credential_providers: [],
+    },
 ];

package/build/system/seed/tool-manifests-data.d.ts

@@ -284,6 +284,93 @@ export declare const HTTP_FETCH_TOOLS: ({
         required: string[];
     };
 })[];
+export declare const SCHEMA_EXCHANGE_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            endpoint: {
+                type: string;
+                description: string;
+            };
+            method: {
+                type: string;
+                description: string;
+            };
+            headers: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+            body: {
+                description: string;
+            };
+            request_schema: {
+                type: string;
+                description: string;
+            };
+            response_schema: {
+                type: string;
+                description: string;
+            };
+            timeout_ms: {
+                type: string;
+                description: string;
+            };
+            credential_provider: {
+                type: string;
+                description: string;
+            };
+            credential_label: {
+                type: string;
+                description: string;
+            };
+            auth_scheme: {
+                type: string;
+                description: string;
+            };
+            auth_header: {
+                type: string;
+                description: string;
+            };
+            data?: undefined;
+            schema?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            data: {
+                description: string;
+            };
+            schema: {
+                type: string;
+                description: string;
+            };
+            endpoint?: undefined;
+            method?: undefined;
+            headers?: undefined;
+            query?: undefined;
+            body?: undefined;
+            request_schema?: undefined;
+            response_schema?: undefined;
+            timeout_ms?: undefined;
+            credential_provider?: undefined;
+            credential_label?: undefined;
+            auth_scheme?: undefined;
+            auth_header?: undefined;
+        };
+        required: string[];
+    };
+})[];
 export declare const DOCS_TOOLS: ({
     name: string;
     description: string;

package/build/system/seed/tool-manifests-data.js

@@ -1,7 +1,7 @@
 "use strict";
 // ── Data, storage, HTTP, and OAuth tool manifests ───────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OAUTH_TOOLS = exports.DOCS_TOOLS = exports.HTTP_FETCH_TOOLS = exports.FILE_STORAGE_TOOLS = exports.DB_QUERY_TOOLS = exports.VISION_ANALYSIS_TOOLS = exports.TRANSLATION_TOOLS = void 0;
+exports.OAUTH_TOOLS = exports.DOCS_TOOLS = exports.SCHEMA_EXCHANGE_TOOLS = exports.HTTP_FETCH_TOOLS = exports.FILE_STORAGE_TOOLS = exports.DB_QUERY_TOOLS = exports.VISION_ANALYSIS_TOOLS = exports.TRANSLATION_TOOLS = void 0;
 exports.TRANSLATION_TOOLS = [
     {
         name: 'translate_content',
@@ -141,6 +141,42 @@ exports.HTTP_FETCH_TOOLS = [
         },
     },
 ];
+exports.SCHEMA_EXCHANGE_TOOLS = [
+    {
+        name: 'exchange',
+        description: 'Exchange data with an external service endpoint under schema enforcement. Validates request body against request_schema before sending and response body against response_schema after receiving. Transport is hidden — the principle is endpoint + schema + validated exchange.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                endpoint: { type: 'string', description: 'Service endpoint URL' },
+                method: { type: 'string', description: 'HTTP method: GET, POST, PUT, DELETE, PATCH' },
+                headers: { type: 'object', description: 'Request headers' },
+                query: { type: 'object', description: 'Query parameters' },
+                body: { description: 'Request body (validated against request_schema if provided)' },
+                request_schema: { type: 'object', description: 'JSON Schema for request body validation' },
+                response_schema: { type: 'object', description: 'JSON Schema for response body validation' },
+                timeout_ms: { type: 'number', description: 'Request timeout in milliseconds' },
+                credential_provider: { type: 'string', description: 'Credential provider name — resolves auth from the connection store automatically' },
+                credential_label: { type: 'string', description: 'Credential label for multi-credential accounts' },
+                auth_scheme: { type: 'string', description: 'Auth scheme (default: Bearer)' },
+                auth_header: { type: 'string', description: 'Header name for credential (default: Authorization)' },
+            },
+            required: ['endpoint', 'method'],
+        },
+    },
+    {
+        name: 'validate_schema',
+        description: 'Validate any value against a JSON Schema without making a network call. Useful for pre-validation, testing, and transform verification.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                data: { description: 'The value to validate' },
+                schema: { type: 'object', description: 'JSON Schema to validate against' },
+            },
+            required: ['data', 'schema'],
+        },
+    },
+];
 exports.DOCS_TOOLS = [
     {
         name: 'list_docs',