@lifesi/genesis-mcp 0.1.0 → 0.1.1

package/dist/hives-node-transport.d.ts

@@ -0,0 +1,6 @@
+import { type GenesisOptions } from '@lifesi/genesis';
+export declare function closeHivesNodeTransport(): Promise<void>;
+export declare function hivesOperationBudget(id: string): number;
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export declare function createHivesNodeTransport(opts: GenesisOptions, callerSignal?: AbortSignal): typeof fetch;

package/dist/hives-node-transport.js

@@ -0,0 +1,145 @@
+import { Agent } from 'undici';
+import { Genesis, operationTable } from '@lifesi/genesis';
+// Node's native fetch accepts a compatible per-request dispatcher. Never change
+// the global dispatcher or the portable SDK: other products retain their transport.
+const agentOptions = { headersTimeout: 340_000, bodyTimeout: 340_000, connect: { timeout: 5_000 }, connections: 4, pipelining: 1 };
+let agent;
+const nativeAgent = () => agent ??= new Agent(agentOptions);
+export async function closeHivesNodeTransport() {
+    const current = agent;
+    agent = undefined;
+    await current?.destroy();
+}
+export function hivesOperationBudget(id) {
+    if (id === 'hives_cancel_deployment' || id === 'hives_delete_deployment')
+        return 330_000;
+    if (['hives_create_deployment', 'hives_upload_deployment', 'hives_invoke_deployment', 'hives_invoke_function', 'hives_invoke_function_async'].includes(id))
+        return 40_000;
+    if (['hives_create_function', 'hives_update_function', 'hives_delete_function'].includes(id))
+        return 100_000;
+    return 20_000;
+}
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const templatePattern = (value) => new RegExp('^' + value.split(/(\{[^}]+\})/).map((part) => part.startsWith('{') ? '[^/]+' : escape(part)).join('') + '$');
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export function createHivesNodeTransport(opts, callerSignal) {
+    const supplied = opts.fetch ?? globalThis.fetch;
+    const underlying = supplied.bind(globalThis);
+    const useNative = supplied === globalThis.fetch;
+    const resolver = new Genesis(opts);
+    const routes = Object.entries(operationTable)
+        .filter(([, op]) => op.service === 'hives' && !op.internal)
+        .flatMap(([id, op]) => {
+        const direct = resolver.routing === 'direct';
+        let base;
+        try {
+            base = new URL(direct ? (opts.upstreams?.hives ?? op.upstream.base) : resolver.baseUrl);
+        }
+        catch {
+            throw new Error('Invalid Hives service address.');
+        }
+        const path = direct ? op.upstream.path : op.path;
+        const prefix = base.pathname.replace(/\/+$/, '');
+        const paths = [path];
+        if (!direct && path.startsWith('/v1/hives/'))
+            paths.push(path.replace('/v1/hives/', '/hives/v1/'));
+        return paths.map((p) => ({ id, origin: base.origin, method: direct ? op.upstream.method : op.method, pattern: templatePattern(prefix + p) }));
+    });
+    return (async (input, init = {}) => {
+        let url;
+        try {
+            url = new URL(input instanceof Request ? input.url : String(input));
+        }
+        catch {
+            throw new Error('Invalid Hives request address.');
+        }
+        const method = (init.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase();
+        const route = routes.find((entry) => entry.origin === url.origin && entry.method === method && entry.pattern.test(url.pathname));
+        if (!route)
+            return underlying(input, init);
+        const controller = new AbortController();
+        let message = 'Hives transport failed. Refresh the resource and retry.';
+        const safeError = () => new Error(message);
+        const signals = [...new Set([callerSignal, init.signal, input instanceof Request ? input.signal : undefined].filter((signal) => !!signal))];
+        const canceled = () => {
+            message = 'Hives request canceled before completion. Refresh the resource before retrying.';
+            controller.abort();
+        };
+        for (const signal of signals)
+            signal.addEventListener('abort', canceled, { once: true });
+        const timer = setTimeout(() => {
+            message = 'Hives request deadline exceeded. Refresh the resource before retrying.';
+            controller.abort();
+        }, hivesOperationBudget(route.id));
+        timer.unref();
+        let abortReject = () => { };
+        let reader;
+        let bodyController;
+        const aborted = () => {
+            abortReject(safeError());
+            bodyController?.error(safeError());
+            void reader?.cancel().catch(() => { });
+            cleanup();
+        };
+        controller.signal.addEventListener('abort', aborted, { once: true });
+        const abortPromise = new Promise((_, reject) => { abortReject = reject; });
+        void abortPromise.catch(() => { });
+        const cleanup = () => {
+            clearTimeout(timer);
+            for (const signal of signals)
+                signal.removeEventListener('abort', canceled);
+            controller.signal.removeEventListener('abort', aborted);
+        };
+        if (signals.some((signal) => signal.aborted))
+            canceled();
+        try {
+            if (controller.signal.aborted)
+                throw safeError();
+            const requestInit = {
+                ...init, signal: controller.signal, cache: 'no-store',
+                redirect: init.redirect === 'manual' ? 'manual' : 'error',
+                ...(useNative ? { dispatcher: nativeAgent() } : {}),
+            };
+            const pending = underlying(input, requestInit);
+            // A caller transport may ignore AbortSignal. Reject on our budget anyway,
+            // and discard any late response rather than presenting an acknowledgement.
+            void pending.then((response) => { if (controller.signal.aborted)
+                void response.body?.cancel().catch(() => { }); }, () => { });
+            const response = await Promise.race([pending, abortPromise]);
+            if (controller.signal.aborted)
+                throw safeError();
+            if (!response.body) {
+                cleanup();
+                return response;
+            }
+            reader = response.body.getReader();
+            const body = new ReadableStream({
+                start(value) { bodyController = value; },
+                async pull(value) {
+                    try {
+                        const next = await reader.read();
+                        if (controller.signal.aborted)
+                            return;
+                        if (next.done) {
+                            cleanup();
+                            value.close();
+                        }
+                        else
+                            value.enqueue(next.value);
+                    }
+                    catch {
+                        cleanup();
+                        value.error(safeError());
+                    }
+                },
+                async cancel() { cleanup(); await reader.cancel().catch(() => { }); },
+            });
+            return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+        }
+        catch {
+            cleanup();
+            throw safeError();
+        }
+    });
+}

package/dist/server.js

@@ -5,12 +5,12 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import http from 'node:http';
 import { callTool, tools } from './tools.js';
 export function createServer(opts = {}) {
-    const server = new Server({ name: 'genesis', version: '0.1.0' }, {
+    const server = new Server({ name: 'genesis', version: '0.1.1' }, {
         capabilities: { tools: {} },
         instructions: 'Genesis: one API for Foundry (inference), Hives (compute), Relays (DNS) and LifeID keys. Use the named tools for common tasks; use genesis_search_tools + genesis_call for anything else.',
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools() }));
-    server.setRequestHandler(CallToolRequestSchema, async (req) => callTool(opts, req.params.name, (req.params.arguments ?? {})));
+    server.setRequestHandler(CallToolRequestSchema, async (req, extra) => callTool(opts, req.params.name, (req.params.arguments ?? {}), extra.signal));
     return server;
 }
 /** stdio: credential from GENESIS_API_KEY / GENESIS_TOKEN (or `credentials` provider). */

package/dist/tools.d.ts

@@ -24,7 +24,39 @@ export declare function searchTools(query: string, service?: string, limit?: num
     path: string;
     summary: string;
     status: string;
-    inputSchema: Record<string, unknown>;
+    inputSchema: Record<string, unknown> | {
+        type: string;
+        properties: {
+            project_id: {
+                type: string;
+                description: string;
+            };
+            wasm_base64: {
+                type: string;
+                maxLength: number;
+                description: string;
+            };
+            filename: {
+                type: string;
+                maxLength: number;
+            };
+            git_sha: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+            };
+            git_branch: {
+                type: string;
+                maxLength: number;
+            };
+            git_message: {
+                type: string;
+                maxLength: number;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
 }[];
 type Result = {
     content: {
@@ -34,5 +66,5 @@ type Result = {
     isError?: boolean;
     structuredContent?: Record<string, unknown>;
 };
-export declare function callTool(opts: GenesisOptions, name: string, args?: Record<string, unknown>): Promise<Result>;
+export declare function callTool(opts: GenesisOptions, name: string, args?: Record<string, unknown>, signal?: AbortSignal): Promise<Result>;
 export {};

package/dist/tools.js

@@ -1,4 +1,12 @@
-import { Genesis, GenesisError, operationTable } from '@lifesi/genesis';
+import { createHivesNodeTransport } from './hives-node-transport.js';
+import { Genesis, GenesisError, MAX_WASM_BYTES, hivesResponseBytes, operationTable } from '@lifesi/genesis';
+const uploadSchema = { type: 'object', properties: {
+        project_id: { type: 'string', description: 'Project owned by the caller’s verified org' },
+        wasm_base64: { type: 'string', maxLength: Math.ceil(MAX_WASM_BYTES / 3) * 4, description: 'Explicit standard-base64 content of a real WASM binary (decoded maximum 10 MiB)' },
+        filename: { type: 'string', maxLength: 255 },
+        git_sha: { type: 'string', minLength: 7, maxLength: 40 }, git_branch: { type: 'string', maxLength: 255 }, git_message: { type: 'string', maxLength: 1000 },
+    }, required: ['project_id', 'wasm_base64'], additionalProperties: false };
+const inputSchema = (id, op) => id === 'hives_upload_deployment' ? uploadSchema : op.inputSchema;
 const all = Object.entries(operationTable);
 /** Operations callable by agents (everything except gateway-internal ones like credential verify). */
 export const callable = all.filter(([, op]) => !op.internal);
@@ -12,7 +20,7 @@ const annotate = (op) => ({
 });
 /** Curated tools: one per operation tagged x-mcp in the merged spec. */
 export const specTools = callable.filter(([, op]) => op.mcp).map(([id, op]) => ({
-    name: id, title: op.summary, description: describe(id, op), inputSchema: op.inputSchema, annotations: annotate(op),
+    name: id, title: op.summary, description: describe(id, op), inputSchema: inputSchema(id, op), annotations: annotate(op),
 }));
 export const metaTools = [
     {
@@ -48,15 +56,43 @@ export function searchTools(query, service, limit = 10) {
         .filter((x) => x.score > 0)
         .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
         .slice(0, limit)
-        .map(({ id, op }) => ({ operation: id, service: op.service, method: op.method, path: op.path, summary: op.summary, status: op.upstream.status, inputSchema: op.inputSchema }));
+        .map(({ id, op }) => ({ operation: id, service: op.service, method: op.method, path: op.path, summary: op.summary, status: op.upstream.status, inputSchema: inputSchema(id, op) }));
 }
 const text = (v, isError = false) => ({ content: [{ type: 'text', text: typeof v === 'string' ? v : JSON.stringify(v, null, 2) }], ...(isError ? { isError } : {}) });
-async function invoke(genesis, id, args) {
+async function invoke(genesis, id, args, signal) {
     const op = operationTable[id];
     if (!op || op.internal)
         return text(`Unknown operation "${id}". Use genesis_search_tools to find one.`, true);
     try {
-        const r = await genesis.request(id, args);
+        let r;
+        if (op.service === 'hives' && op.rawResponse) {
+            const response = await genesis.raw(id, args, { signal });
+            const bytes = await hivesResponseBytes(response);
+            const payload = { status: response.status, headers: Object.fromEntries(response.headers), body_base64: Buffer.from(bytes).toString('base64') };
+            return { ...text(payload), structuredContent: payload };
+        }
+        else if (id === 'hives_upload_deployment') {
+            const encoded = args.wasm_base64;
+            if (typeof args.project_id !== 'string' || !args.project_id || typeof encoded !== 'string'
+                || encoded.length > Math.ceil(MAX_WASM_BYTES / 3) * 4 || encoded.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) {
+                return text({ error: { type: 'invalid_request', message: 'Provide a project ID and standard base64 of a real WASM file, up to 10 MiB decoded.' } }, true);
+            }
+            const bytes = Buffer.from(encoded, 'base64');
+            if (bytes.toString('base64') !== encoded || bytes.length > MAX_WASM_BYTES)
+                return text({ error: { type: 'invalid_request', message: 'WASM base64 is invalid or exceeds 10 MiB.' } }, true);
+            const optional = (key) => {
+                if (args[key] !== undefined && typeof args[key] !== 'string')
+                    throw new Error('WASM upload metadata must contain strings.');
+                return args[key];
+            };
+            r = await genesis.hives.deployments.upload(args.project_id, new Blob([Uint8Array.from(bytes)], { type: 'application/wasm' }), {
+                filename: optional('filename'), git_sha: optional('git_sha'), git_branch: optional('git_branch'), git_message: optional('git_message'),
+            });
+        }
+        else
+            r = op.service === 'hives'
+                ? await genesis.request(id, args, { signal })
+                : await genesis.request(id, args);
         return text(r === undefined ? { ok: true } : r);
     }
     catch (e) {
@@ -65,13 +101,17 @@ async function invoke(genesis, id, args) {
         return text({ error: { type: 'network', message: e.message, hint: `The ${op.service} service may be unreachable (status: ${op.upstream.status}).` } }, true);
     }
 }
-export async function callTool(opts, name, args = {}) {
+export async function callTool(opts, name, args = {}, signal) {
     if (name === 'genesis_search_tools')
         return text(searchTools(String(args.query ?? ''), args.service, Number(args.limit ?? 10)));
-    const genesis = new Genesis(opts);
-    if (name === 'genesis_call')
-        return invoke(genesis, String(args.operation ?? ''), args.arguments ?? {});
-    if (!specTools.some((t) => t.name === name))
+    if (name !== 'genesis_call' && !specTools.some((t) => t.name === name))
         return text(`Unknown tool "${name}".`, true);
-    return invoke(genesis, name, args);
+    const id = name === 'genesis_call' ? String(args.operation ?? '') : name;
+    const input = name === 'genesis_call' ? args.arguments ?? {} : args;
+    const op = operationTable[id];
+    if (!op || op.internal)
+        return text(`Unknown operation "${id}". Use genesis_search_tools to find one.`, true);
+    const hives = op.service === 'hives';
+    const genesis = new Genesis(hives ? { ...opts, fetch: createHivesNodeTransport(opts, signal) } : opts);
+    return invoke(genesis, id, input, hives ? signal : undefined);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifesi/genesis-mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Genesis MCP server (stdio + streamable HTTP): tools generated from the Genesis OpenAPI",
   "type": "module",
   "bin": {
@@ -12,7 +12,8 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",
-    "@lifesi/genesis": "0.1.0"
+    "undici": "6.29.0",
+    "@lifesi/genesis": "0.1.1"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json"