@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/tools/admin/hook-disable.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Hook Disable Tool - Disables a hook
+ * Wraps the SDK's hook.disable() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookDisableTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const hook_1 = __importDefault(require("../../modules/hook"));
+class HookDisableToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await hook_1.default.disable(this.params.hook_id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error disabling hook: ${errorMsg}`,
+                    returnDisplay: `Error disabling hook: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const hookData = response.data;
+            const hookName = (hookData === null || hookData === void 0 ? void 0 : hookData.name) || this.params.hook_id;
+            return {
+                llmContent: `Successfully disabled hook "${hookName}" (ID: ${this.params.hook_id})`,
+                returnDisplay: `Successfully disabled hook "${hookName}"`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error disabling hook: ${errorMessage}`,
+                returnDisplay: `Error disabling hook: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the HookDisable tool logic
+ */
+class HookDisableTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(HookDisableTool.Name, 'HookDisable', `Disables a hook by its ID. Once disabled, the hook will no longer trigger actions when its configured trigger events occur.`, types_1.Kind.Edit, {
+            properties: {
+                hook_id: {
+                    description: 'The unique identifier of the hook to disable',
+                    type: 'string',
+                },
+            },
+            required: ['hook_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.hook_id || params.hook_id.trim() === '') {
+            return "The 'hook_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new HookDisableToolInvocation(params);
+    }
+}
+exports.HookDisableTool = HookDisableTool;
+HookDisableTool.Name = 'hook_disable';

package/dist/tools/admin/hook-enable.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hook Enable Tool - Enables a hook
+ * Wraps the SDK's hook.enable() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the HookEnable tool
+ */
+export interface HookEnableToolParams {
+    /**
+     * The ID of the hook to enable
+     */
+    hook_id: string;
+}
+/**
+ * Implementation of the HookEnable tool logic
+ */
+export declare class HookEnableTool extends BaseDeclarativeTool<HookEnableToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: HookEnableToolParams): string | null;
+    protected createInvocation(params: HookEnableToolParams): ToolInvocation<HookEnableToolParams, ToolResult>;
+}

package/dist/tools/admin/hook-enable.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Hook Enable Tool - Enables a hook
+ * Wraps the SDK's hook.enable() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookEnableTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const hook_1 = __importDefault(require("../../modules/hook"));
+class HookEnableToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await hook_1.default.enable(this.params.hook_id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error enabling hook: ${errorMsg}`,
+                    returnDisplay: `Error enabling hook: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const hookData = response.data;
+            const hookName = (hookData === null || hookData === void 0 ? void 0 : hookData.name) || this.params.hook_id;
+            return {
+                llmContent: `Successfully enabled hook "${hookName}" (ID: ${this.params.hook_id})`,
+                returnDisplay: `Successfully enabled hook "${hookName}"`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error enabling hook: ${errorMessage}`,
+                returnDisplay: `Error enabling hook: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the HookEnable tool logic
+ */
+class HookEnableTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(HookEnableTool.Name, 'HookEnable', `Enables a hook by its ID. Once enabled, the hook will start triggering actions when its configured trigger events occur.`, types_1.Kind.Edit, {
+            properties: {
+                hook_id: {
+                    description: 'The unique identifier of the hook to enable',
+                    type: 'string',
+                },
+            },
+            required: ['hook_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.hook_id || params.hook_id.trim() === '') {
+            return "The 'hook_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new HookEnableToolInvocation(params);
+    }
+}
+exports.HookEnableTool = HookEnableTool;
+HookEnableTool.Name = 'hook_enable';

package/dist/tools/admin/hook-get.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hook Get Tool - Gets a hook by ID
+ * Wraps the SDK's hook.get() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the HookGet tool
+ */
+export interface HookGetToolParams {
+    /**
+     * The ID of the hook to retrieve
+     */
+    hook_id: string;
+}
+/**
+ * Implementation of the HookGet tool logic
+ */
+export declare class HookGetTool extends BaseDeclarativeTool<HookGetToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: HookGetToolParams): string | null;
+    protected createInvocation(params: HookGetToolParams): ToolInvocation<HookGetToolParams, ToolResult>;
+}

package/dist/tools/admin/hook-get.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Hook Get Tool - Gets a hook by ID
+ * Wraps the SDK's hook.get() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const hook_1 = __importDefault(require("../../modules/hook"));
+class HookGetToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await hook_1.default.get(this.params.hook_id);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error getting hook: ${errorMsg}`,
+                    returnDisplay: `Error getting hook: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const hookData = response.data;
+            if (!hookData) {
+                return {
+                    llmContent: `Hook with ID "${this.params.hook_id}" not found.`,
+                    returnDisplay: `Hook not found`,
+                    error: {
+                        message: `Hook with ID "${this.params.hook_id}" not found`,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const llmContent = `Hook Details:
+- ID: ${hookData.id}
+- Name: ${hookData.name}
+- Description: ${hookData.description || 'N/A'}
+- Trigger: ${hookData.trigger}
+- Trigger Config: ${hookData.triggerConfig ? JSON.stringify(hookData.triggerConfig, null, 2) : 'N/A'}
+- Action: ${hookData.action}
+- Action Config: ${hookData.actionConfig ? JSON.stringify(hookData.actionConfig, null, 2) : 'N/A'}
+- Enabled: ${hookData.enabled}
+- Priority: ${(_a = hookData.priority) !== null && _a !== void 0 ? _a : 'N/A'}
+- Created At: ${hookData.createdAt}
+- Updated At: ${hookData.updatedAt}
+- Last Triggered At: ${hookData.lastTriggeredAt || 'Never'}
+- Trigger Count: ${hookData.triggerCount}`;
+            return {
+                llmContent,
+                returnDisplay: `Successfully retrieved hook "${hookData.name}"`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting hook: ${errorMessage}`,
+                returnDisplay: `Error getting hook: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the HookGet tool logic
+ */
+class HookGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(HookGetTool.Name, 'HookGet', `Gets detailed information about a specific hook by its ID. Returns the hook's configuration, status, and statistics.`, types_1.Kind.Read, {
+            properties: {
+                hook_id: {
+                    description: 'The unique identifier of the hook to retrieve',
+                    type: 'string',
+                },
+            },
+            required: ['hook_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.hook_id || params.hook_id.trim() === '') {
+            return "The 'hook_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new HookGetToolInvocation(params);
+    }
+}
+exports.HookGetTool = HookGetTool;
+HookGetTool.Name = 'hook_get';

package/dist/tools/admin/hook-list.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hook List Tool - Lists all hooks
+ * Wraps the SDK's hook.list() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the HookList tool
+ */
+export interface HookListToolParams {
+}
+/**
+ * Implementation of the HookList tool logic
+ */
+export declare class HookListTool extends BaseDeclarativeTool<HookListToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: HookListToolParams): ToolInvocation<HookListToolParams, ToolResult>;
+}

package/dist/tools/admin/hook-list.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Hook List Tool - Lists all hooks
+ * Wraps the SDK's hook.list() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const hook_1 = __importDefault(require("../../modules/hook"));
+class HookListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await hook_1.default.list();
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error listing hooks: ${errorMsg}`,
+                    returnDisplay: `Error listing hooks: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const hooks = response.data || [];
+            if (hooks.length === 0) {
+                return {
+                    llmContent: 'No hooks found.',
+                    returnDisplay: 'No hooks found.',
+                };
+            }
+            const hooksList = hooks.map((h, index) => {
+                return `${index + 1}. ${h.name} (ID: ${h.id})
+   - Trigger: ${h.trigger}
+   - Action: ${h.action}
+   - Enabled: ${h.enabled}
+   - Trigger Count: ${h.triggerCount}`;
+            }).join('\n\n');
+            const llmContent = `Found ${hooks.length} hook(s):\n\n${hooksList}`;
+            return {
+                llmContent,
+                returnDisplay: `Successfully listed ${hooks.length} hook(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing hooks: ${errorMessage}`,
+                returnDisplay: `Error listing hooks: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the HookList tool logic
+ */
+class HookListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(HookListTool.Name, 'HookList', `Lists all hooks configured in the system. Returns information about each hook including its name, ID, trigger type, action type, enabled status, and trigger count.`, types_1.Kind.Read, {
+            properties: {},
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new HookListToolInvocation(params);
+    }
+}
+exports.HookListTool = HookListTool;
+HookListTool.Name = 'hook_list';

package/dist/tools/admin/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Admin tools - Orchestrator, Codemap, Hook, and EventLog management tools
+ */
+export { OrchestratorListTool, type OrchestratorListToolParams } from './orchestrator-list';
+export { OrchestratorGetTool, type OrchestratorGetToolParams } from './orchestrator-get';
+export { OrchestratorCreateTool, type OrchestratorCreateToolParams } from './orchestrator-create';
+export { OrchestratorUpdateTool, type OrchestratorUpdateToolParams } from './orchestrator-update';
+export { CodemapListTool, type CodemapListToolParams } from './codemap-list';
+export { CodemapGetTool, type CodemapGetToolParams } from './codemap-get';
+export { CodemapCreateTool, type CodemapCreateToolParams } from './codemap-create';
+export { CodemapUpdateTool, type CodemapUpdateToolParams } from './codemap-update';
+export { HookCreateTool, type HookCreateToolParams } from './hook-create';
+export { HookListTool, type HookListToolParams } from './hook-list';
+export { HookGetTool, type HookGetToolParams } from './hook-get';
+export { HookEnableTool, type HookEnableToolParams } from './hook-enable';
+export { HookDisableTool, type HookDisableToolParams } from './hook-disable';
+export { EventLogCreateInstanceTool, type EventLogCreateInstanceToolParams } from './eventlog-create-instance';
+export { EventLogGetInstanceTool, type EventLogGetInstanceToolParams } from './eventlog-get-instance';
+export { EventLogListInstancesTool, type EventLogListInstancesToolParams } from './eventlog-list-instances';
+export { EventLogAppendEventTool, type EventLogAppendEventToolParams } from './eventlog-append-event';
+export { EventLogQueryEventsTool, type EventLogQueryEventsToolParams } from './eventlog-query-events';
+export { EventLogGetStatsTool, type EventLogGetStatsToolParams } from './eventlog-get-stats';
+import { OrchestratorListTool } from './orchestrator-list';
+import { OrchestratorGetTool } from './orchestrator-get';
+import { OrchestratorCreateTool } from './orchestrator-create';
+import { OrchestratorUpdateTool } from './orchestrator-update';
+import { CodemapListTool } from './codemap-list';
+import { CodemapGetTool } from './codemap-get';
+import { CodemapCreateTool } from './codemap-create';
+import { CodemapUpdateTool } from './codemap-update';
+import { HookCreateTool } from './hook-create';
+import { HookListTool } from './hook-list';
+import { HookGetTool } from './hook-get';
+import { HookEnableTool } from './hook-enable';
+import { HookDisableTool } from './hook-disable';
+import { EventLogCreateInstanceTool } from './eventlog-create-instance';
+import { EventLogGetInstanceTool } from './eventlog-get-instance';
+import { EventLogListInstancesTool } from './eventlog-list-instances';
+import { EventLogAppendEventTool } from './eventlog-append-event';
+import { EventLogQueryEventsTool } from './eventlog-query-events';
+import { EventLogGetStatsTool } from './eventlog-get-stats';
+/**
+ * All admin tools
+ */
+export declare const adminTools: (OrchestratorListTool | OrchestratorGetTool | OrchestratorCreateTool | OrchestratorUpdateTool | CodemapListTool | CodemapGetTool | CodemapCreateTool | CodemapUpdateTool | HookCreateTool | HookListTool | HookGetTool | HookEnableTool | HookDisableTool | EventLogCreateInstanceTool | EventLogGetInstanceTool | EventLogListInstancesTool | EventLogAppendEventTool | EventLogQueryEventsTool | EventLogGetStatsTool)[];

package/dist/tools/admin/index.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Admin tools - Orchestrator, Codemap, Hook, and EventLog management tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminTools = exports.EventLogGetStatsTool = exports.EventLogQueryEventsTool = exports.EventLogAppendEventTool = exports.EventLogListInstancesTool = exports.EventLogGetInstanceTool = exports.EventLogCreateInstanceTool = exports.HookDisableTool = exports.HookEnableTool = exports.HookGetTool = exports.HookListTool = exports.HookCreateTool = exports.CodemapUpdateTool = exports.CodemapCreateTool = exports.CodemapGetTool = exports.CodemapListTool = exports.OrchestratorUpdateTool = exports.OrchestratorCreateTool = exports.OrchestratorGetTool = exports.OrchestratorListTool = void 0;
+var orchestrator_list_1 = require("./orchestrator-list");
+Object.defineProperty(exports, "OrchestratorListTool", { enumerable: true, get: function () { return orchestrator_list_1.OrchestratorListTool; } });
+var orchestrator_get_1 = require("./orchestrator-get");
+Object.defineProperty(exports, "OrchestratorGetTool", { enumerable: true, get: function () { return orchestrator_get_1.OrchestratorGetTool; } });
+var orchestrator_create_1 = require("./orchestrator-create");
+Object.defineProperty(exports, "OrchestratorCreateTool", { enumerable: true, get: function () { return orchestrator_create_1.OrchestratorCreateTool; } });
+var orchestrator_update_1 = require("./orchestrator-update");
+Object.defineProperty(exports, "OrchestratorUpdateTool", { enumerable: true, get: function () { return orchestrator_update_1.OrchestratorUpdateTool; } });
+var codemap_list_1 = require("./codemap-list");
+Object.defineProperty(exports, "CodemapListTool", { enumerable: true, get: function () { return codemap_list_1.CodemapListTool; } });
+var codemap_get_1 = require("./codemap-get");
+Object.defineProperty(exports, "CodemapGetTool", { enumerable: true, get: function () { return codemap_get_1.CodemapGetTool; } });
+var codemap_create_1 = require("./codemap-create");
+Object.defineProperty(exports, "CodemapCreateTool", { enumerable: true, get: function () { return codemap_create_1.CodemapCreateTool; } });
+var codemap_update_1 = require("./codemap-update");
+Object.defineProperty(exports, "CodemapUpdateTool", { enumerable: true, get: function () { return codemap_update_1.CodemapUpdateTool; } });
+var hook_create_1 = require("./hook-create");
+Object.defineProperty(exports, "HookCreateTool", { enumerable: true, get: function () { return hook_create_1.HookCreateTool; } });
+var hook_list_1 = require("./hook-list");
+Object.defineProperty(exports, "HookListTool", { enumerable: true, get: function () { return hook_list_1.HookListTool; } });
+var hook_get_1 = require("./hook-get");
+Object.defineProperty(exports, "HookGetTool", { enumerable: true, get: function () { return hook_get_1.HookGetTool; } });
+var hook_enable_1 = require("./hook-enable");
+Object.defineProperty(exports, "HookEnableTool", { enumerable: true, get: function () { return hook_enable_1.HookEnableTool; } });
+var hook_disable_1 = require("./hook-disable");
+Object.defineProperty(exports, "HookDisableTool", { enumerable: true, get: function () { return hook_disable_1.HookDisableTool; } });
+var eventlog_create_instance_1 = require("./eventlog-create-instance");
+Object.defineProperty(exports, "EventLogCreateInstanceTool", { enumerable: true, get: function () { return eventlog_create_instance_1.EventLogCreateInstanceTool; } });
+var eventlog_get_instance_1 = require("./eventlog-get-instance");
+Object.defineProperty(exports, "EventLogGetInstanceTool", { enumerable: true, get: function () { return eventlog_get_instance_1.EventLogGetInstanceTool; } });
+var eventlog_list_instances_1 = require("./eventlog-list-instances");
+Object.defineProperty(exports, "EventLogListInstancesTool", { enumerable: true, get: function () { return eventlog_list_instances_1.EventLogListInstancesTool; } });
+var eventlog_append_event_1 = require("./eventlog-append-event");
+Object.defineProperty(exports, "EventLogAppendEventTool", { enumerable: true, get: function () { return eventlog_append_event_1.EventLogAppendEventTool; } });
+var eventlog_query_events_1 = require("./eventlog-query-events");
+Object.defineProperty(exports, "EventLogQueryEventsTool", { enumerable: true, get: function () { return eventlog_query_events_1.EventLogQueryEventsTool; } });
+var eventlog_get_stats_1 = require("./eventlog-get-stats");
+Object.defineProperty(exports, "EventLogGetStatsTool", { enumerable: true, get: function () { return eventlog_get_stats_1.EventLogGetStatsTool; } });
+// Create instances for convenience
+const orchestrator_list_2 = require("./orchestrator-list");
+const orchestrator_get_2 = require("./orchestrator-get");
+const orchestrator_create_2 = require("./orchestrator-create");
+const orchestrator_update_2 = require("./orchestrator-update");
+const codemap_list_2 = require("./codemap-list");
+const codemap_get_2 = require("./codemap-get");
+const codemap_create_2 = require("./codemap-create");
+const codemap_update_2 = require("./codemap-update");
+const hook_create_2 = require("./hook-create");
+const hook_list_2 = require("./hook-list");
+const hook_get_2 = require("./hook-get");
+const hook_enable_2 = require("./hook-enable");
+const hook_disable_2 = require("./hook-disable");
+const eventlog_create_instance_2 = require("./eventlog-create-instance");
+const eventlog_get_instance_2 = require("./eventlog-get-instance");
+const eventlog_list_instances_2 = require("./eventlog-list-instances");
+const eventlog_append_event_2 = require("./eventlog-append-event");
+const eventlog_query_events_2 = require("./eventlog-query-events");
+const eventlog_get_stats_2 = require("./eventlog-get-stats");
+/**
+ * All admin tools
+ */
+exports.adminTools = [
+    new orchestrator_list_2.OrchestratorListTool(),
+    new orchestrator_get_2.OrchestratorGetTool(),
+    new orchestrator_create_2.OrchestratorCreateTool(),
+    new orchestrator_update_2.OrchestratorUpdateTool(),
+    new codemap_list_2.CodemapListTool(),
+    new codemap_get_2.CodemapGetTool(),
+    new codemap_create_2.CodemapCreateTool(),
+    new codemap_update_2.CodemapUpdateTool(),
+    new hook_create_2.HookCreateTool(),
+    new hook_list_2.HookListTool(),
+    new hook_get_2.HookGetTool(),
+    new hook_enable_2.HookEnableTool(),
+    new hook_disable_2.HookDisableTool(),
+    new eventlog_create_instance_2.EventLogCreateInstanceTool(),
+    new eventlog_get_instance_2.EventLogGetInstanceTool(),
+    new eventlog_list_instances_2.EventLogListInstancesTool(),
+    new eventlog_append_event_2.EventLogAppendEventTool(),
+    new eventlog_query_events_2.EventLogQueryEventsTool(),
+    new eventlog_get_stats_2.EventLogGetStatsTool(),
+];

package/dist/tools/admin/orchestrator-create.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Orchestrator Create Tool - Creates a new orchestrator
+ * Wraps the SDK's orchestrator.createOrchestrator() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the OrchestratorCreate tool
+ */
+export interface OrchestratorCreateToolParams {
+    /**
+     * The name of the orchestrator
+     */
+    name: string;
+    /**
+     * A description of the orchestrator
+     */
+    description: string;
+    /**
+     * The ID of the agent to associate with this orchestrator
+     */
+    agent_id: string;
+    /**
+     * The ID of the default worker agent (optional)
+     */
+    default_worker_agent_id?: string;
+    /**
+     * Additional metadata for the orchestrator (optional)
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Implementation of the OrchestratorCreate tool logic
+ */
+export declare class OrchestratorCreateTool extends BaseDeclarativeTool<OrchestratorCreateToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: OrchestratorCreateToolParams): string | null;
+    protected createInvocation(params: OrchestratorCreateToolParams): ToolInvocation<OrchestratorCreateToolParams, ToolResult>;
+}