@lifesi/genesis 0.1.2 → 0.1.4

package/dist/client.js

@@ -65,6 +65,10 @@ export class GenesisClient {
         const res = await this.raw(operationId, (input ?? {}), init);
         if (operationTable[operationId].rawResponse)
             return res;
+        if (operationId === 'hives_stop_deployment' && res.status !== 200) {
+            void res.body?.cancel().catch(() => { });
+            throw new GenesisError({ status: 0, type: 'invalid_response', operationId, message: 'Hives did not confirm this deployment stopped. Read its current state before explicitly reconciling stop.' });
+        }
         if (res.status === 204)
             return undefined;
         const ct = res.headers.get('content-type') ?? '';
@@ -79,6 +83,12 @@ export class GenesisClient {
                 throw new Error('Hives returned invalid function metadata.');
             throw error;
         }
+        if (operationId === 'hives_stop_deployment') {
+            const requested = input;
+            if (!value || value.id !== requested.deployment_id || value.project_id !== requested.project_id || value.status !== 'cancelled') {
+                throw new GenesisError({ status: 0, type: 'invalid_response', operationId, message: 'Hives did not confirm this deployment stopped. Read its current state before explicitly reconciling stop.' });
+            }
+        }
         if (operationId === 'hives_list_functions') {
             if (!value || !Array.isArray(value.data) || !value.pagination)
                 throw new Error('Hives returned invalid function list metadata.');
@@ -86,7 +96,7 @@ export class GenesisClient {
             return { data: value.data.map((row) => hivesFunctionMetadata(row, input?.project_id)), pagination };
         }
         if (['hives_get_function', 'hives_create_function', 'hives_update_function'].includes(operationId)) {
-            return hivesFunctionMetadata(value, input?.project_id);
+            return hivesFunctionMetadata(value, input?.project_id, operationId === 'hives_create_function' ? undefined : input?.function_id);
         }
         if (operationId === 'hives_list_project_environment' || operationId === 'hives_update_project_environment') {
             return hivesEnvironmentMetadata(value, input?.project_id, operationId === 'hives_update_project_environment');
@@ -113,7 +123,7 @@ export class GenesisClient {
         const url = this.url(operationId, input);
         const headers = {
             accept: 'application/json',
-            'user-agent': this.opts.userAgent ?? '@lifesi/genesis/0.1.0',
+            'user-agent': this.opts.userAgent ?? '@lifesi/genesis/0.1.4',
             ...this.opts.headers, ...init.headers,
         };
         if (runnerGrant) {

package/dist/fleets.d.ts

@@ -1,12 +1,68 @@
 import type { GenesisClient } from './client.js';
 import type { OperationInput } from './types.js';
 type TaskInput = NonNullable<OperationInput<'fleets_submitTask'>['body']>;
+type AgentLaunchInput = NonNullable<OperationInput<'fleets_launchAgent'>['body']>;
+type AgentCommandInput = NonNullable<OperationInput<'fleets_commandAgent'>['body']>;
 export interface FleetsInstanceOptions {
     idempotencyKey?: string;
     signal?: AbortSignal;
 }
 /** Managed Henry instances and tasks scoped to the credential's verified org. */
 export declare function fleetsModule(client: GenesisClient): {
+    agents: {
+        list: () => Promise<{
+            agents: import("./index.js").components["schemas"]["Fleets.Agent"][];
+        }>;
+        launch: (body: AgentLaunchInput) => Promise<{
+            id: string;
+            name: string;
+            state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+            memory: import("./index.js").components["schemas"]["Fleets.Memory"];
+            model?: string | null;
+            inference: {
+                provider: "foundry";
+                mode: "managed";
+            };
+            created_at_ms: number;
+            updated_at_ms: number;
+            last_operation_id?: string | null;
+        }>;
+        get: (agent_id: string) => Promise<{
+            id: string;
+            name: string;
+            state: "launching" | "running" | "stopping" | "stopped" | "recovering" | "recovery_required";
+            memory: import("./index.js").components["schemas"]["Fleets.Memory"];
+            model?: string | null;
+            inference: {
+                provider: "foundry";
+                mode: "managed";
+            };
+            created_at_ms: number;
+            updated_at_ms: number;
+            last_operation_id?: string | null;
+        }>;
+        command: (agent_id: string, body: AgentCommandInput) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        stop: (agent_id: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+        recover: (agent_id: string) => Promise<{
+            agent: import("./index.js").components["schemas"]["Fleets.Agent"];
+            operation_id: string;
+            result?: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
     instances: {
         list: (query?: OperationInput<"fleets_listInstances">) => Promise<{
             instances: import("./index.js").components["schemas"]["Fleets.Instance"][];

package/dist/fleets.js

@@ -31,9 +31,63 @@ const instanceId = (value, operation) => {
         throw invalid(operation, 'Invalid Fleets instance ID.');
     }
 };
+const agentId = (value, operation) => {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+        throw invalid(operation, 'Invalid Fleets agent ID.');
+    }
+};
+function validateAgentLaunch(body) {
+    if (!body || typeof body.name !== 'string' || !body.name.trim() || byteLength(body.name) > 128) {
+        throw invalid('fleets_launchAgent', 'Agent name must contain 1–128 UTF-8 bytes.');
+    }
+    if (body.instructions !== undefined && (byteLength(body.instructions) > 65536 || body.instructions.includes('\0'))) {
+        throw invalid('fleets_launchAgent', 'Agent instructions must contain at most 65536 UTF-8 bytes without NUL.');
+    }
+    if (body.model !== undefined && (!body.model || byteLength(body.model) > 128)) {
+        throw invalid('fleets_launchAgent', 'Agent model must contain 1–128 UTF-8 bytes.');
+    }
+    if (body.memory !== undefined) {
+        if (!['minds', 'files', 'custom'].includes(body.memory.provider))
+            throw invalid('fleets_launchAgent', 'Memory provider must be minds, files, or custom.');
+        if (body.memory.provider === 'custom' && !body.memory.endpoint)
+            throw invalid('fleets_launchAgent', 'Custom memory requires an endpoint.');
+    }
+    if (body.idempotency_key !== undefined && (typeof body.idempotency_key !== 'string' || !/^[!-~]{1,128}$/.test(body.idempotency_key))) {
+        throw invalid('fleets_launchAgent', 'Idempotency key must contain 1–128 visible ASCII characters.');
+    }
+}
+function validateAgentCommand(body) {
+    if (!body || typeof body.input !== 'string' || !body.input.trim() || byteLength(body.input) > 65536 || body.input.includes('\0')) {
+        throw invalid('fleets_commandAgent', 'Agent input must contain 1–65536 UTF-8 bytes without NUL.');
+    }
+}
 /** Managed Henry instances and tasks scoped to the credential's verified org. */
 export function fleetsModule(client) {
     return {
+        agents: {
+            list: () => client.request('fleets_listAgents'),
+            launch: async (body) => {
+                validateAgentLaunch(body);
+                return client.request('fleets_launchAgent', { body });
+            },
+            get: async (agent_id) => {
+                agentId(agent_id, 'fleets_getAgent');
+                return client.request('fleets_getAgent', { agent_id });
+            },
+            command: async (agent_id, body) => {
+                agentId(agent_id, 'fleets_commandAgent');
+                validateAgentCommand(body);
+                return client.request('fleets_commandAgent', { agent_id, body });
+            },
+            stop: async (agent_id) => {
+                agentId(agent_id, 'fleets_stopAgent');
+                return client.request('fleets_stopAgent', { agent_id });
+            },
+            recover: async (agent_id) => {
+                agentId(agent_id, 'fleets_recoverAgent');
+                return client.request('fleets_recoverAgent', { agent_id });
+            },
+        },
         instances: {
             list: async (query = {}) => {
                 if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 50)) {