@hotmeshio/long-tail 0.1.6 → 0.1.8

package/build/api/mcp-runs.d.ts

@@ -0,0 +1,43 @@
+import type { LTApiResult } from '../types/sdk';
+/**
+ * List distinct entity types for an app (HotMesh namespace).
+ *
+ * @param input.app_id — HotMesh app ID (e.g. `"durable"`)
+ * @returns `{ status: 200, data: { entities: string[] } }`
+ */
+export declare function listEntities(input: {
+    app_id: string;
+}): Promise<LTApiResult>;
+/**
+ * List jobs (workflow executions) for an app, with optional filters.
+ *
+ * @param input.app_id — HotMesh app ID
+ * @param input.limit — max results
+ * @param input.offset — pagination offset
+ * @param input.entity — filter by entity type
+ * @param input.search — full-text search
+ * @param input.status — filter by job status
+ * @returns `{ status: 200, data: { jobs, total } }`
+ */
+export declare function listJobs(input: {
+    app_id: string;
+    limit?: number;
+    offset?: number;
+    entity?: string;
+    search?: string;
+    status?: string;
+}): Promise<LTApiResult>;
+/**
+ * Get the full execution history for a single job.
+ *
+ * Reconstructs the execution timeline from the HotMesh stream,
+ * including activity calls, signals, and state transitions.
+ *
+ * @param input.jobId — HotMesh job (workflow) ID
+ * @param input.app_id — HotMesh app ID
+ * @returns `{ status: 200, data: <execution timeline> }` or 404
+ */
+export declare function getJobExecution(input: {
+    jobId: string;
+    app_id: string;
+}): Promise<LTApiResult>;

package/build/api/mcp-runs.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listEntities = listEntities;
+exports.listJobs = listJobs;
+exports.getJobExecution = getJobExecution;
+const hotmesh_utils_1 = require("../services/hotmesh-utils");
+const mcp_runs_1 = require("../services/mcp-runs");
+/**
+ * List distinct entity types for an app (HotMesh namespace).
+ *
+ * @param input.app_id — HotMesh app ID (e.g. `"durable"`)
+ * @returns `{ status: 200, data: { entities: string[] } }`
+ */
+async function listEntities(input) {
+    try {
+        if (!input.app_id) {
+            return { status: 400, error: 'app_id query parameter is required' };
+        }
+        const entities = await (0, mcp_runs_1.listEntities)(input.app_id);
+        return { status: 200, data: { entities } };
+    }
+    catch (err) {
+        if (err.message?.includes('does not exist')) {
+            return { status: 200, data: { entities: [] } };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * List jobs (workflow executions) for an app, with optional filters.
+ *
+ * @param input.app_id — HotMesh app ID
+ * @param input.limit — max results
+ * @param input.offset — pagination offset
+ * @param input.entity — filter by entity type
+ * @param input.search — full-text search
+ * @param input.status — filter by job status
+ * @returns `{ status: 200, data: { jobs, total } }`
+ */
+async function listJobs(input) {
+    try {
+        if (!input.app_id) {
+            return { status: 400, error: 'app_id query parameter is required' };
+        }
+        const result = await (0, mcp_runs_1.listJobs)({
+            rawAppId: input.app_id,
+            limit: input.limit,
+            offset: input.offset,
+            entity: input.entity,
+            search: input.search,
+            status: input.status,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        if (err.message?.includes('does not exist')) {
+            return { status: 200, data: { jobs: [], total: 0 } };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Get the full execution history for a single job.
+ *
+ * Reconstructs the execution timeline from the HotMesh stream,
+ * including activity calls, signals, and state transitions.
+ *
+ * @param input.jobId — HotMesh job (workflow) ID
+ * @param input.app_id — HotMesh app ID
+ * @returns `{ status: 200, data: <execution timeline> }` or 404
+ */
+async function getJobExecution(input) {
+    try {
+        if (!input.app_id) {
+            return { status: 400, error: 'app_id query parameter is required' };
+        }
+        const appId = (0, hotmesh_utils_1.sanitizeAppId)(input.app_id);
+        const schema = (0, hotmesh_utils_1.quoteSchema)(appId);
+        const execution = await (0, mcp_runs_1.buildExecution)(input.jobId, appId, schema);
+        return { status: 200, data: execution };
+    }
+    catch (err) {
+        const msg = err.message ?? '';
+        if (err.status === 404 || msg.includes('not found') || msg.includes('does not exist')) {
+            return { status: 404, error: msg };
+        }
+        return { status: 500, error: msg };
+    }
+}

package/build/api/mcp.d.ts

@@ -0,0 +1,160 @@
+import type { LTApiResult, LTApiAuth } from '../types/sdk';
+/**
+ * List registered MCP servers with optional filtering and pagination.
+ *
+ * @param input.status — filter by server status (e.g. 'active', 'inactive')
+ * @param input.auto_connect — filter by auto-connect setting
+ * @param input.search — free-text search across server names and descriptions
+ * @param input.tags — filter to servers matching any of these tags
+ * @param input.limit — maximum number of results to return
+ * @param input.offset — pagination offset
+ * @returns `{ status: 200, data: { ... } }` paginated list of MCP server records
+ */
+export declare function listMcpServers(input: {
+    status?: string;
+    auto_connect?: boolean;
+    search?: string;
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+}): Promise<LTApiResult>;
+/**
+ * Register a new MCP server.
+ *
+ * Returns 409 if a server with the same name already exists.
+ *
+ * @param input.name — unique display name for the server (required)
+ * @param input.description — optional human-readable description
+ * @param input.transport_type — transport protocol, e.g. 'sse', 'stdio' (required)
+ * @param input.transport_config — transport-specific connection settings (required)
+ * @param input.auto_connect — whether to connect automatically on startup
+ * @param input.metadata — arbitrary key-value metadata
+ * @param input.tags — tags for categorization and filtering
+ * @param input.compile_hints — optional hints used during tool compilation
+ * @param input.credential_providers — OAuth/credential provider identifiers required by this server
+ * @returns `{ status: 201, data: { ... } }` the created MCP server record
+ */
+export declare function createMcpServer(input: {
+    name: string;
+    description?: string;
+    transport_type: string;
+    transport_config: Record<string, any>;
+    auto_connect?: boolean;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    compile_hints?: any;
+    credential_providers?: string[];
+}): Promise<LTApiResult>;
+/**
+ * Test connectivity to an MCP server without persisting it.
+ *
+ * Attempts to establish a connection using the provided transport
+ * configuration and returns the result. On failure, returns a
+ * successful (200) response with `success: false` and the error message.
+ *
+ * @param input.transport_type — transport protocol to test (required)
+ * @param input.transport_config — transport-specific connection settings (required)
+ * @returns `{ status: 200, data: { success, error?, tools } }` connection test result
+ */
+export declare function testConnection(input: {
+    transport_type: string;
+    transport_config: Record<string, any>;
+}): Promise<LTApiResult>;
+/**
+ * Retrieve a single MCP server by ID.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { ... } }` the MCP server record, or 404 if not found
+ */
+export declare function getMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Update fields on an existing MCP server.
+ *
+ * Accepts any subset of mutable server fields alongside the required ID.
+ *
+ * @param input.id — the MCP server identifier (required)
+ * @param input.[key] — any mutable server field to update (name, description, transport_config, etc.)
+ * @returns `{ status: 200, data: { ... } }` the updated server record, or 404 if not found
+ */
+export declare function updateMcpServer(input: {
+    id: string;
+    [key: string]: any;
+}): Promise<LTApiResult>;
+/**
+ * Delete an MCP server by ID.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { deleted: true } }` on success, or 404 if not found
+ */
+export declare function deleteMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Establish a live connection to a registered MCP server.
+ *
+ * Requires the MCP adapter to be registered in the registry.
+ *
+ * @param input.id — the MCP server identifier to connect
+ * @returns `{ status: 200, data: { connected, serverId } }` confirmation of the connection
+ */
+export declare function connectMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Disconnect a live MCP server connection.
+ *
+ * Requires the MCP adapter to be registered in the registry.
+ *
+ * @param input.id — the MCP server identifier to disconnect
+ * @returns `{ status: 200, data: { disconnected, serverId } }` confirmation of the disconnection
+ */
+export declare function disconnectMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Check which credential providers are registered vs missing for an MCP server.
+ *
+ * Resolves each credential provider required by the server against the
+ * authenticated user's stored credentials.
+ *
+ * @param input.id — the MCP server identifier
+ * @param auth — authenticated user context used to resolve credentials
+ * @returns `{ status: 200, data: { required, registered, missing } }` credential status arrays
+ */
+export declare function getCredentialStatus(input: {
+    id: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+/**
+ * List all tools exposed by a connected MCP server.
+ *
+ * Requires the MCP adapter to be registered and the server to be connected.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { tools } }` array of tool descriptors
+ */
+export declare function listMcpServerTools(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Invoke a specific tool on a connected MCP server.
+ *
+ * Passes the tool arguments and an optional auth context (derived from
+ * `execute_as` or the authenticated user) to the MCP adapter. Returns
+ * 422 with `missing_credential` if the tool requires a credential the
+ * user has not registered.
+ *
+ * @param input.id — the MCP server identifier
+ * @param input.toolName — name of the tool to invoke
+ * @param input.arguments — key-value arguments to pass to the tool
+ * @param input.execute_as — optional user ID to impersonate for the tool call
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { result } }` the tool execution result
+ */
+export declare function callMcpTool(input: {
+    id: string;
+    toolName: string;
+    arguments?: Record<string, any>;
+    execute_as?: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;

package/build/api/mcp.js

@@ -0,0 +1,320 @@
+"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.listMcpServers = listMcpServers;
+exports.createMcpServer = createMcpServer;
+exports.testConnection = testConnection;
+exports.getMcpServer = getMcpServer;
+exports.updateMcpServer = updateMcpServer;
+exports.deleteMcpServer = deleteMcpServer;
+exports.connectMcpServer = connectMcpServer;
+exports.disconnectMcpServer = disconnectMcpServer;
+exports.getCredentialStatus = getCredentialStatus;
+exports.listMcpServerTools = listMcpServerTools;
+exports.callMcpTool = callMcpTool;
+const mcpDbService = __importStar(require("../services/mcp/db"));
+const mcp_1 = require("../services/mcp");
+/**
+ * List registered MCP servers with optional filtering and pagination.
+ *
+ * @param input.status — filter by server status (e.g. 'active', 'inactive')
+ * @param input.auto_connect — filter by auto-connect setting
+ * @param input.search — free-text search across server names and descriptions
+ * @param input.tags — filter to servers matching any of these tags
+ * @param input.limit — maximum number of results to return
+ * @param input.offset — pagination offset
+ * @returns `{ status: 200, data: { ... } }` paginated list of MCP server records
+ */
+async function listMcpServers(input) {
+    try {
+        const result = await mcpDbService.listMcpServers(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Register a new MCP server.
+ *
+ * Returns 409 if a server with the same name already exists.
+ *
+ * @param input.name — unique display name for the server (required)
+ * @param input.description — optional human-readable description
+ * @param input.transport_type — transport protocol, e.g. 'sse', 'stdio' (required)
+ * @param input.transport_config — transport-specific connection settings (required)
+ * @param input.auto_connect — whether to connect automatically on startup
+ * @param input.metadata — arbitrary key-value metadata
+ * @param input.tags — tags for categorization and filtering
+ * @param input.compile_hints — optional hints used during tool compilation
+ * @param input.credential_providers — OAuth/credential provider identifiers required by this server
+ * @returns `{ status: 201, data: { ... } }` the created MCP server record
+ */
+async function createMcpServer(input) {
+    try {
+        if (!input.name || !input.transport_type || !input.transport_config) {
+            return { status: 400, error: 'name, transport_type, and transport_config are required' };
+        }
+        const server = await mcpDbService.createMcpServer(input);
+        return { status: 201, data: server };
+    }
+    catch (err) {
+        if (err.message?.includes('duplicate key') || err.code === '23505') {
+            return { status: 409, error: 'MCP server with that name already exists' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Test connectivity to an MCP server without persisting it.
+ *
+ * Attempts to establish a connection using the provided transport
+ * configuration and returns the result. On failure, returns a
+ * successful (200) response with `success: false` and the error message.
+ *
+ * @param input.transport_type — transport protocol to test (required)
+ * @param input.transport_config — transport-specific connection settings (required)
+ * @returns `{ status: 200, data: { success, error?, tools } }` connection test result
+ */
+async function testConnection(input) {
+    try {
+        if (!input.transport_type || !input.transport_config) {
+            return { status: 400, error: 'transport_type and transport_config are required' };
+        }
+        const { testConnection: testConn } = await Promise.resolve().then(() => __importStar(require('../services/mcp/client/connection')));
+        const result = await testConn(input.transport_type, input.transport_config);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 200, data: { success: false, error: err.message, tools: [] } };
+    }
+}
+/**
+ * Retrieve a single MCP server by ID.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { ... } }` the MCP server record, or 404 if not found
+ */
+async function getMcpServer(input) {
+    try {
+        const server = await mcpDbService.getMcpServer(input.id);
+        if (!server) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        return { status: 200, data: server };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Update fields on an existing MCP server.
+ *
+ * Accepts any subset of mutable server fields alongside the required ID.
+ *
+ * @param input.id — the MCP server identifier (required)
+ * @param input.[key] — any mutable server field to update (name, description, transport_config, etc.)
+ * @returns `{ status: 200, data: { ... } }` the updated server record, or 404 if not found
+ */
+async function updateMcpServer(input) {
+    try {
+        const { id, ...fields } = input;
+        const server = await mcpDbService.updateMcpServer(id, fields);
+        if (!server) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        return { status: 200, data: server };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Delete an MCP server by ID.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { deleted: true } }` on success, or 404 if not found
+ */
+async function deleteMcpServer(input) {
+    try {
+        const deleted = await mcpDbService.deleteMcpServer(input.id);
+        if (!deleted) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        return { status: 200, data: { deleted: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Establish a live connection to a registered MCP server.
+ *
+ * Requires the MCP adapter to be registered in the registry.
+ *
+ * @param input.id — the MCP server identifier to connect
+ * @returns `{ status: 200, data: { connected, serverId } }` confirmation of the connection
+ */
+async function connectMcpServer(input) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        await adapter.connectClient(input.id);
+        return { status: 200, data: { connected: true, serverId: input.id } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Disconnect a live MCP server connection.
+ *
+ * Requires the MCP adapter to be registered in the registry.
+ *
+ * @param input.id — the MCP server identifier to disconnect
+ * @returns `{ status: 200, data: { disconnected, serverId } }` confirmation of the disconnection
+ */
+async function disconnectMcpServer(input) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        await adapter.disconnectClient(input.id);
+        return { status: 200, data: { disconnected: true, serverId: input.id } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Check which credential providers are registered vs missing for an MCP server.
+ *
+ * Resolves each credential provider required by the server against the
+ * authenticated user's stored credentials.
+ *
+ * @param input.id — the MCP server identifier
+ * @param auth — authenticated user context used to resolve credentials
+ * @returns `{ status: 200, data: { required, registered, missing } }` credential status arrays
+ */
+async function getCredentialStatus(input, auth) {
+    try {
+        const server = await mcpDbService.getMcpServer(input.id);
+        if (!server) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        const required = server.credential_providers ?? [];
+        const registered = [];
+        const missing = [];
+        if (auth?.userId && required.length > 0) {
+            const { resolveCredential } = await Promise.resolve().then(() => __importStar(require('../services/iam/credentials')));
+            for (const provider of required) {
+                const cred = await resolveCredential({ id: auth.userId, type: 'user', roles: [] }, provider);
+                if (cred)
+                    registered.push(provider);
+                else
+                    missing.push(provider);
+            }
+        }
+        else {
+            missing.push(...required);
+        }
+        return { status: 200, data: { required, registered, missing } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * List all tools exposed by a connected MCP server.
+ *
+ * Requires the MCP adapter to be registered and the server to be connected.
+ *
+ * @param input.id — the MCP server identifier
+ * @returns `{ status: 200, data: { tools } }` array of tool descriptors
+ */
+async function listMcpServerTools(input) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        const tools = await adapter.listTools(input.id);
+        return { status: 200, data: { tools } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Invoke a specific tool on a connected MCP server.
+ *
+ * Passes the tool arguments and an optional auth context (derived from
+ * `execute_as` or the authenticated user) to the MCP adapter. Returns
+ * 422 with `missing_credential` if the tool requires a credential the
+ * user has not registered.
+ *
+ * @param input.id — the MCP server identifier
+ * @param input.toolName — name of the tool to invoke
+ * @param input.arguments — key-value arguments to pass to the tool
+ * @param input.execute_as — optional user ID to impersonate for the tool call
+ * @param auth — authenticated user context
+ * @returns `{ status: 200, data: { result } }` the tool execution result
+ */
+async function callMcpTool(input, auth) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        const authContext = (input.execute_as || auth?.userId)
+            ? { userId: input.execute_as || auth?.userId }
+            : undefined;
+        const result = await adapter.callTool(input.id, input.toolName, input.arguments || {}, authContext);
+        return { status: 200, data: { result } };
+    }
+    catch (err) {
+        if (err.name === 'MissingCredentialError') {
+            return {
+                status: 422,
+                error: 'missing_credential',
+                ...{ provider: err.provider, message: err.message },
+            };
+        }
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/namespaces.d.ts

@@ -0,0 +1,20 @@
+import type { LTApiResult } from '../types/sdk';
+/**
+ * List all registered namespaces.
+ *
+ * @returns `{ status: 200, data: { namespaces: LTNamespace[] } }`
+ */
+export declare function listNamespaces(): Promise<LTApiResult>;
+/**
+ * Register a new namespace.
+ *
+ * @param input.name — unique namespace identifier
+ * @param input.description — human-readable description
+ * @param input.metadata — arbitrary key-value metadata
+ * @returns `{ status: 200, data: <namespace record> }`
+ */
+export declare function registerNamespace(input: {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}): Promise<LTApiResult>;

package/build/{routes/escalations/helpers.js → api/namespaces.js}

@@ -33,16 +33,41 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVisibleRoles = getVisibleRoles;
-const userService = __importStar(require("../../services/user"));
+exports.listNamespaces = listNamespaces;
+exports.registerNamespace = registerNamespace;
+const namespaceService = __importStar(require("../services/namespace"));
 /**
- * Return the role names visible to a user, or undefined if superadmin (no filter).
- * Returns an empty array when the user holds no roles at all.
+ * List all registered namespaces.
+ *
+ * @returns `{ status: 200, data: { namespaces: LTNamespace[] } }`
  */
-async function getVisibleRoles(userId) {
-    const isSuperAdminUser = await userService.isSuperAdmin(userId);
-    if (isSuperAdminUser)
-        return undefined;
-    const userRoles = await userService.getUserRoles(userId);
-    return userRoles.map((r) => r.role);
+async function listNamespaces() {
+    try {
+        const namespaces = await namespaceService.listNamespaces();
+        return { status: 200, data: { namespaces } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Register a new namespace.
+ *
+ * @param input.name — unique namespace identifier
+ * @param input.description — human-readable description
+ * @param input.metadata — arbitrary key-value metadata
+ * @returns `{ status: 200, data: <namespace record> }`
+ */
+async function registerNamespace(input) {
+    try {
+        const { name, description, metadata } = input;
+        if (!name || typeof name !== 'string') {
+            return { status: 400, error: 'name is required' };
+        }
+        const namespace = await namespaceService.registerNamespace(name, description, metadata);
+        return { status: 200, data: namespace };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
 }