@lifesi/genesis-mcp 0.1.1 → 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.js

@@ -11,6 +11,8 @@ export async function closeHivesNodeTransport() {
     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))

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,7 +5,7 @@ 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.1' }, {
+    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.',
     });

package/dist/tools.js

@@ -1,4 +1,7 @@
+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' },
@@ -6,7 +9,7 @@ const uploadSchema = { type: 'object', properties: {
         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 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);
@@ -14,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: inputSchema(id, op), annotations: annotate(op),
+    name: id, title: op.summary, description: describe(id, op), inputSchema: inputSchema(id, op), annotations: annotate(op, id),
 }));
 export const metaTools = [
     {
@@ -65,7 +68,16 @@ async function invoke(genesis, id, args, signal) {
         return text(`Unknown operation "${id}". Use genesis_search_tools to find one.`, true);
     try {
         let r;
-        if (op.service === 'hives' && op.rawResponse) {
+        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') };
@@ -113,5 +125,5 @@ export async function callTool(opts, name, args = {}, signal) {
         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);
+    return invoke(genesis, id, input, hives || isFleetsLifecycleTool(id) ? signal : undefined);
 }

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@lifesi/genesis-mcp",
-  "version": "0.1.1",
+  "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": {
@@ -13,7 +18,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",
     "undici": "6.29.0",
-    "@lifesi/genesis": "0.1.1"
+    "@lifesi/genesis": "0.1.2"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json"