@lifesi/genesis-mcp 0.1.0 → 0.1.2

package/dist/beacons.d.ts

@@ -0,0 +1,14 @@
+import type { Genesis } from '@lifesi/genesis';
+export declare const BEACONS_PROVISION_OPERATION = "beacons_provisionBridgeFleet";
+export declare function beaconsInputSchema(id: string, fallback: Record<string, unknown>): Record<string, unknown>;
+/** The request key is a header, never authority or a JSON field sent to the producer. */
+export declare function callBeaconsProvision(genesis: Genesis, args: Record<string, unknown>): Promise<{
+    data: {
+        fleet_id: string;
+        organization_id: string;
+        workspace_id: string;
+        project_id: string;
+        environment_id: string;
+        metadata_only: true;
+    };
+}>;

package/dist/beacons.js

@@ -0,0 +1,17 @@
+export const BEACONS_PROVISION_OPERATION = 'beacons_provisionBridgeFleet';
+export function beaconsInputSchema(id, fallback) {
+    if (id !== BEACONS_PROVISION_OPERATION)
+        return fallback;
+    return {
+        type: 'object', properties: {
+            request_id: { type: 'string', format: 'uuid', description: 'Nonzero UUID. Reuse this ID and the identical name after an interrupted response.' },
+            body: { type: 'object', properties: { name: { type: 'string', maxLength: 256 } }, additionalProperties: false },
+        }, required: ['request_id'], additionalProperties: false,
+    };
+}
+/** The request key is a header, never authority or a JSON field sent to the producer. */
+export function callBeaconsProvision(genesis, args) {
+    if (Object.keys(args).some(key => !['request_id', 'body'].includes(key)))
+        throw new Error('Unsupported Beacons provisioning argument.');
+    return genesis.beacons.fleets.provision(args.request_id, args.body === undefined ? {} : args.body);
+}

package/dist/fleets.d.ts

@@ -0,0 +1,27 @@
+import { type Genesis } from '@lifesi/genesis';
+export declare const isFleetsLifecycleTool: (id: string) => id is "fleets_startInstance" | "fleets_stopInstance";
+export declare function fleetsInputSchema(id: string, schema: Record<string, unknown>): Record<string, unknown>;
+export declare function callFleetsLifecycleTool(genesis: Genesis, id: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<{
+    id: string;
+    name: string;
+    organization_id: string;
+    workspace_id: string;
+    project_id: string;
+    admission_held: boolean | null;
+    physical_state: "created" | "running" | "held" | "stopped" | "recovery_required" | "released";
+    status_evidence: "live_controller" | "confirmed_release_receipt";
+    release_acknowledged_at_ms: number | null;
+    harness_ready: boolean;
+    observed_at_ms: number | null;
+    lease_expires: {
+        wall_ms: number;
+        logical: number;
+    } | null;
+} | {
+    id: string;
+    state: "released";
+    reaped: true;
+    data_retained: true;
+    status_evidence: "confirmed_release_receipt";
+    release_acknowledged_at_ms: number;
+}>;

package/dist/fleets.js

@@ -0,0 +1,20 @@
+import { GenesisError } from '@lifesi/genesis';
+export const isFleetsLifecycleTool = (id) => id === 'fleets_startInstance' || id === 'fleets_stopInstance';
+export function fleetsInputSchema(id, schema) {
+    if (!isFleetsLifecycleTool(id))
+        return schema;
+    return { ...schema, properties: { ...schema.properties, idempotency_key: {
+                type: 'string', pattern: '^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$',
+                description: 'Optional canonical UUID4 for this explicit operation; retain it after an uncertain reply. Carries no authority.',
+            } }, additionalProperties: false };
+}
+export async function callFleetsLifecycleTool(genesis, id, args, signal) {
+    if (!args || typeof args !== 'object' || Array.isArray(args)
+        || Object.keys(args).some(key => !['instance_id', 'idempotency_key'].includes(key))
+        || typeof args.instance_id !== 'string'
+        || (args.idempotency_key !== undefined && typeof args.idempotency_key !== 'string')) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId: id, message: 'Provide an instance ID and optional canonical UUID4 idempotency_key only.' });
+    }
+    const options = { idempotencyKey: args.idempotency_key, signal };
+    return id === 'fleets_startInstance' ? genesis.fleets.instances.start(args.instance_id, options) : genesis.fleets.instances.stop(args.instance_id, options);
+}

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,147 @@
+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 (['hives_list_buckets', 'hives_create_bucket', 'hives_get_bucket', 'hives_delete_bucket', 'hives_list_objects', 'hives_upload_object', 'hives_upload_object_by_key', 'hives_delete_object', 'hives_delete_object_by_key', 'hives_download_object_by_key', 'hives_get_cors_config', 'hives_set_cors_config', 'hives_generate_presigned_url', 'hives_reconcile'].includes(id))
+        return 100_000;
+    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/hives-resources.d.ts

@@ -0,0 +1,6 @@
+import type { Genesis } from '@lifesi/genesis';
+/** Binary data and plain keys are explicitly encoded for the actual native object API. */
+export declare function hivesResourceInputSchema(id: string, fallback: Record<string, unknown>): Record<string, unknown>;
+export declare const isHivesResourceTool: (id: string) => boolean;
+/** Called only by the reviewed Hives-only shared-dispatch proposal. No replay or external capability fetch. */
+export declare function callHivesResourceTool(g: Genesis, id: string, a: Record<string, unknown>, signal?: AbortSignal): Promise<unknown>;

package/dist/hives-resources.js

@@ -0,0 +1,72 @@
+const OBJECT_BYTES = 10 * 1024 * 1024;
+const keyProperties = { project_id: { type: 'string' }, bucket_id: { type: 'string' }, key: { type: 'string', minLength: 1, maxLength: 1024 } };
+/** Binary data and plain keys are explicitly encoded for the actual native object API. */
+export function hivesResourceInputSchema(id, fallback) {
+    if (!['hives_upload_object', 'hives_upload_object_by_key', 'hives_delete_object_by_key', 'hives_download_object_by_key'].includes(id))
+        return fallback;
+    const upload = id.startsWith('hives_upload_object');
+    return { type: 'object', properties: { ...keyProperties, ...(upload ? { body_base64: { type: 'string', maxLength: Math.ceil(OBJECT_BYTES / 3) * 4 }, content_type: { type: 'string', maxLength: 512 } } : {}) }, required: ['project_id', 'bucket_id', 'key', ...(upload ? ['body_base64'] : [])], additionalProperties: false };
+}
+export const isHivesResourceTool = (id) => /^(?:hives_.*_native_queue|hives_(?:list_buckets|create_bucket|get_bucket|delete_bucket|list_objects|upload_object(?:_by_key)?|delete_object(?:_by_key)?|download_object_by_key|get_cors_config|set_cors_config|generate_presigned_url|reconcile|list_runtimes|get_runtime|select_runtime|list_project_runtimes))$/.test(id);
+function text(value) { if (typeof value !== 'string')
+    throw new Error('Invalid Hives resource input.'); return value; }
+function decode(value) { const s = text(value); if (s.length > Math.ceil(OBJECT_BYTES / 3) * 4 || s.length % 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(s))
+    throw new Error('Invalid bounded object body.'); const bytes = Buffer.from(s, 'base64'); if (bytes.length > OBJECT_BYTES || bytes.toString('base64') !== s)
+    throw new Error('Invalid bounded object body.'); return Uint8Array.from(bytes); }
+/** Called only by the reviewed Hives-only shared-dispatch proposal. No replay or external capability fetch. */
+export async function callHivesResourceTool(g, id, a, signal) {
+    const options = { signal };
+    const project = () => text(a.project_id);
+    const bucket = () => text(a.bucket_id);
+    const queue = () => text(a.queue_id);
+    const body = () => a.body;
+    const cells = g.hives.cells;
+    const buzz = g.hives.queues;
+    switch (id) {
+        case 'hives_list_buckets': return cells.list(project(), { page: a.page, per_page: a.per_page }, options);
+        case 'hives_get_bucket': return cells.get(project(), bucket(), options);
+        case 'hives_create_bucket': return cells.create(project(), body(), options);
+        case 'hives_delete_bucket': return cells.remove(project(), bucket(), options);
+        case 'hives_reconcile': return cells.reconcile(project(), bucket(), options);
+        case 'hives_list_objects': return cells.objects.list(project(), bucket(), { prefix: a.prefix, delimiter: a.delimiter, continuation_token: a.continuation_token, max_keys: a.max_keys }, options);
+        case 'hives_get_cors_config': return cells.cors.get(project(), bucket(), options);
+        case 'hives_set_cors_config': return cells.cors.set(project(), bucket(), body()?.rules, options);
+        case 'hives_generate_presigned_url': return cells.presign(project(), bucket(), body(), options);
+        case 'hives_upload_object_by_key':
+        case 'hives_upload_object': return cells.objects[id === 'hives_upload_object' ? 'putFlat' : 'put'](project(), bucket(), text(a.key), decode(a.body_base64), { ...options, content_type: a.content_type });
+        case 'hives_delete_object_by_key':
+            await cells.objects.remove(project(), bucket(), text(a.key), options);
+            return { acknowledged: true };
+        case 'hives_delete_object':
+            await cells.objects.removeFlat(project(), bucket(), text(a.key), options);
+            return { acknowledged: true };
+        case 'hives_download_object_by_key': {
+            const response = await cells.objects.download(project(), bucket(), text(a.key), options);
+            return { status: response.status, content_type: response.headers.get('content-type'), body_base64: Buffer.from(await response.arrayBuffer()).toString('base64') };
+        }
+        case 'hives_list_runtimes': return g.hives.runtimes.list(options);
+        case 'hives_list_project_runtimes': return g.hives.runtimes.project(project(), options);
+        case 'hives_get_runtime': return g.hives.runtimes.get(text(a.name), options);
+        case 'hives_select_runtime': return g.hives.runtimes.select({ wasi: text(a.wasi), runner: text(a.runner), artifact: text(a.artifact) }, options);
+        case 'hives_list_native_queue': return buzz.list(project(), options);
+        case 'hives_inspect_native_queue': return buzz.get(project(), queue(), options);
+        case 'hives_create_native_queue': return buzz.create(project(), body(), options);
+        case 'hives_configure_native_queue': return buzz.configure(project(), queue(), body(), options);
+        case 'hives_delete_native_queue': return buzz.remove(project(), queue(), options);
+        case 'hives_stats_native_queue': return buzz.stats(project(), queue(), options);
+        case 'hives_consumers_native_queue': return buzz.consumers(project(), queue(), options);
+        case 'hives_pause_native_queue': return buzz.pause(project(), queue(), options);
+        case 'hives_resume_native_queue': return buzz.resume(project(), queue(), options);
+        case 'hives_purge_native_queue': return buzz.purge(project(), queue(), options);
+        case 'hives_send_native_queue': return buzz.send(project(), queue(), body(), options);
+        case 'hives_receive_native_queue': return buzz.receive(project(), queue(), body(), options);
+        case 'hives_ack_native_queue': return buzz.ack(project(), queue(), text(a.message_id), text(body()?.receiptHandle), options);
+        case 'hives_nack_native_queue': return buzz.nack(project(), queue(), text(a.message_id), text(body()?.receiptHandle), options);
+        case 'hives_dead_letters_native_queue': return buzz.deadLetters(project(), queue(), { limit: a.limit, offset: a.offset }, options);
+        case 'hives_dlq_stats_native_queue': return buzz.deadLetterStats(project(), queue(), options);
+        case 'hives_replay_native_queue': return buzz.replay(project(), queue(), text(body()?.message_id), options);
+        case 'hives_delete_dlq_native_queue': return buzz.deleteDeadLetter(project(), queue(), text(a.message_id), options);
+        case 'hives_purge_dlq_native_queue': return buzz.purgeDeadLetters(project(), queue(), options);
+        default: throw new Error('Unknown Hives resource operation.');
+    }
+}

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.2' }, {
         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,15 @@
-import { Genesis, GenesisError, operationTable } from '@lifesi/genesis';
+import { callHivesResourceTool, hivesResourceInputSchema, isHivesResourceTool } from './hives-resources.js';
+import { createHivesNodeTransport } from './hives-node-transport.js';
+import { BEACONS_PROVISION_OPERATION, beaconsInputSchema, callBeaconsProvision } from './beacons.js';
+import { fleetsInputSchema, isFleetsLifecycleTool, callFleetsLifecycleTool } from './fleets.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 : fleetsInputSchema(id, beaconsInputSchema(id, hivesResourceInputSchema(id, 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);
@@ -6,13 +17,13 @@ function describe(id, op) {
     const status = op.upstream.status === 'live' ? '' : ` [service status: ${op.upstream.status}]`;
     return `${op.summary} (${op.method} ${op.path})${status}`;
 }
-const annotate = (op) => ({
-    readOnlyHint: op.method === 'GET', destructiveHint: op.method === 'DELETE',
-    idempotentHint: ['GET', 'PUT', 'DELETE'].includes(op.method), openWorldHint: true,
+const annotate = (op, id) => ({
+    readOnlyHint: op.method === 'GET', destructiveHint: op.method === 'DELETE' || isHivesResourceTool(id) && /^hives_purge/.test(id),
+    idempotentHint: isHivesResourceTool(id) && op.method !== 'GET' ? false : ['GET', 'PUT', 'DELETE'].includes(op.method) || id === BEACONS_PROVISION_OPERATION || op.path === '/v1/iam/runner/self-execution-grant', openWorldHint: true,
 });
 /** 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, id),
 }));
 export const metaTools = [
     {
@@ -48,15 +59,52 @@ 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 (isFleetsLifecycleTool(id)) {
+            r = await callFleetsLifecycleTool(genesis, id, args, signal);
+        }
+        else if (id === BEACONS_PROVISION_OPERATION) {
+            r = await callBeaconsProvision(genesis, args);
+        }
+        else if (op.service === 'hives' && isHivesResourceTool(id)) {
+            r = await callHivesResourceTool(genesis, id, args, signal);
+        }
+        else 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 +113,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 || isFleetsLifecycleTool(id) ? signal : undefined);
 }

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@lifesi/genesis-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/l1felabs/genesis-api.git",
+    "directory": "packages/mcp"
+  },
   "description": "Genesis MCP server (stdio + streamable HTTP): tools generated from the Genesis OpenAPI",
   "type": "module",
   "bin": {
@@ -12,7 +17,8 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",
-    "@lifesi/genesis": "0.1.0"
+    "undici": "6.29.0",
+    "@lifesi/genesis": "0.1.2"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json"