@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/tools/state/state-get-project.d.ts

@@ -0,0 +1,20 @@
+/**
+ * State Get Project Tool - Retrieves the current project state
+ * Wraps the SDK's cbstate.getProjectState() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the StateGetProject tool
+ */
+export interface StateGetProjectToolParams {
+}
+/**
+ * Implementation of the StateGetProject tool logic
+ */
+export declare class StateGetProjectTool extends BaseDeclarativeTool<StateGetProjectToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(_params: StateGetProjectToolParams): string | null;
+    protected createInvocation(params: StateGetProjectToolParams): ToolInvocation<StateGetProjectToolParams, ToolResult>;
+}

package/dist/tools/state/state-get-project.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * State Get Project Tool - Retrieves the current project state
+ * Wraps the SDK's cbstate.getProjectState() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateGetProjectTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const state_1 = __importDefault(require("../../modules/state"));
+class StateGetProjectToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await state_1.default.getProjectState();
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: 'Successfully retrieved project state',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error retrieving project state: ${errorMessage}`,
+                returnDisplay: `Error retrieving project state: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the StateGetProject tool logic
+ */
+class StateGetProjectTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(StateGetProjectTool.Name, 'StateGetProject', 'Retrieves the current project state from the server. Returns project-specific configuration and data.', types_1.Kind.Read, {
+            properties: {},
+            required: [],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(_params) {
+        return null;
+    }
+    createInvocation(params) {
+        return new StateGetProjectToolInvocation(params);
+    }
+}
+exports.StateGetProjectTool = StateGetProjectTool;
+StateGetProjectTool.Name = 'state_get_project';

package/dist/tools/state/state-update-project.d.ts

@@ -0,0 +1,28 @@
+/**
+ * State Update Project Tool - Updates a key-value pair in the project state
+ * Wraps the SDK's cbstate.updateProjectState(key, value) method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the StateUpdateProject tool
+ */
+export interface StateUpdateProjectToolParams {
+    /**
+     * The key to update in the project state
+     */
+    key: string;
+    /**
+     * The value to set for the key (can be any type)
+     */
+    value: any;
+}
+/**
+ * Implementation of the StateUpdateProject tool logic
+ */
+export declare class StateUpdateProjectTool extends BaseDeclarativeTool<StateUpdateProjectToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: StateUpdateProjectToolParams): string | null;
+    protected createInvocation(params: StateUpdateProjectToolParams): ToolInvocation<StateUpdateProjectToolParams, ToolResult>;
+}

package/dist/tools/state/state-update-project.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * State Update Project Tool - Updates a key-value pair in the project state
+ * Wraps the SDK's cbstate.updateProjectState(key, value) method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateUpdateProjectTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const state_1 = __importDefault(require("../../modules/state"));
+class StateUpdateProjectToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await state_1.default.updateProjectState(this.params.key, this.params.value);
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: `Successfully updated project state key "${this.params.key}"`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error updating project state: ${errorMessage}`,
+                returnDisplay: `Error updating project state: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the StateUpdateProject tool logic
+ */
+class StateUpdateProjectTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(StateUpdateProjectTool.Name, 'StateUpdateProject', 'Updates a key-value pair in the project state. Use this to store or modify project-specific data that persists across sessions.', types_1.Kind.Edit, {
+            properties: {
+                key: {
+                    description: 'The key to update in the project state',
+                    type: 'string',
+                },
+                value: {
+                    description: 'The value to set for the key (can be any JSON-serializable type)',
+                },
+            },
+            required: ['key', 'value'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.key || params.key.trim() === '') {
+            return "The 'key' parameter must be non-empty.";
+        }
+        if (params.value === undefined) {
+            return "The 'value' parameter is required.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new StateUpdateProjectToolInvocation(params);
+    }
+}
+exports.StateUpdateProjectTool = StateUpdateProjectTool;
+StateUpdateProjectTool.Name = 'state_update_project';

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

@@ -0,0 +1,59 @@
+/**
+ * Swarm operations tools
+ */
+export { SwarmCreateTool, type SwarmCreateToolParams } from './swarm-create';
+export { SwarmListTool, type SwarmListToolParams } from './swarm-list';
+export { SwarmGetTool, type SwarmGetToolParams } from './swarm-get';
+export { SwarmGetAgentsTool, type SwarmGetAgentsToolParams } from './swarm-get-agents';
+export { SwarmRegisterAgentTool, type SwarmRegisterAgentToolParams } from './swarm-register-agent';
+export { SwarmUnregisterAgentTool, type SwarmUnregisterAgentToolParams } from './swarm-unregister-agent';
+export { SwarmCreateTeamTool, type SwarmCreateTeamToolParams } from './swarm-create-team';
+export { SwarmListTeamsTool, type SwarmListTeamsToolParams } from './swarm-list-teams';
+export { SwarmGetTeamTool, type SwarmGetTeamToolParams } from './swarm-get-team';
+export { SwarmJoinTeamTool, type SwarmJoinTeamToolParams } from './swarm-join-team';
+export { SwarmLeaveTeamTool, type SwarmLeaveTeamToolParams } from './swarm-leave-team';
+export { SwarmDeleteTeamTool, type SwarmDeleteTeamToolParams } from './swarm-delete-team';
+export { SwarmCreateRoleTool, type SwarmCreateRoleToolParams } from './swarm-create-role';
+export { SwarmListRolesTool, type SwarmListRolesToolParams } from './swarm-list-roles';
+export { SwarmGetRoleTool, type SwarmGetRoleToolParams } from './swarm-get-role';
+export { SwarmAssignRoleTool, type SwarmAssignRoleToolParams } from './swarm-assign-role';
+export { SwarmUnassignRoleTool, type SwarmUnassignRoleToolParams } from './swarm-unassign-role';
+export { SwarmGetAgentsByRoleTool, type SwarmGetAgentsByRoleToolParams } from './swarm-get-agents-by-role';
+export { SwarmDeleteRoleTool, type SwarmDeleteRoleToolParams } from './swarm-delete-role';
+export { SwarmCreateVacancyTool, type SwarmCreateVacancyToolParams } from './swarm-create-vacancy';
+export { SwarmListVacanciesTool, type SwarmListVacanciesToolParams } from './swarm-list-vacancies';
+export { SwarmApplyVacancyTool, type SwarmApplyVacancyToolParams } from './swarm-apply-vacancy';
+export { SwarmCloseVacancyTool, type SwarmCloseVacancyToolParams } from './swarm-close-vacancy';
+export { SwarmUpdateStatusTool, type SwarmUpdateStatusToolParams } from './swarm-update-status';
+export { SwarmGetStatusSummaryTool, type SwarmGetStatusSummaryToolParams } from './swarm-get-status-summary';
+export { SwarmGetDefaultJobGroupTool, type SwarmGetDefaultJobGroupToolParams } from './swarm-get-default-job-group';
+import { SwarmCreateTool } from './swarm-create';
+import { SwarmListTool } from './swarm-list';
+import { SwarmGetTool } from './swarm-get';
+import { SwarmGetAgentsTool } from './swarm-get-agents';
+import { SwarmRegisterAgentTool } from './swarm-register-agent';
+import { SwarmUnregisterAgentTool } from './swarm-unregister-agent';
+import { SwarmCreateTeamTool } from './swarm-create-team';
+import { SwarmListTeamsTool } from './swarm-list-teams';
+import { SwarmGetTeamTool } from './swarm-get-team';
+import { SwarmJoinTeamTool } from './swarm-join-team';
+import { SwarmLeaveTeamTool } from './swarm-leave-team';
+import { SwarmDeleteTeamTool } from './swarm-delete-team';
+import { SwarmCreateRoleTool } from './swarm-create-role';
+import { SwarmListRolesTool } from './swarm-list-roles';
+import { SwarmGetRoleTool } from './swarm-get-role';
+import { SwarmAssignRoleTool } from './swarm-assign-role';
+import { SwarmUnassignRoleTool } from './swarm-unassign-role';
+import { SwarmGetAgentsByRoleTool } from './swarm-get-agents-by-role';
+import { SwarmDeleteRoleTool } from './swarm-delete-role';
+import { SwarmCreateVacancyTool } from './swarm-create-vacancy';
+import { SwarmListVacanciesTool } from './swarm-list-vacancies';
+import { SwarmApplyVacancyTool } from './swarm-apply-vacancy';
+import { SwarmCloseVacancyTool } from './swarm-close-vacancy';
+import { SwarmUpdateStatusTool } from './swarm-update-status';
+import { SwarmGetStatusSummaryTool } from './swarm-get-status-summary';
+import { SwarmGetDefaultJobGroupTool } from './swarm-get-default-job-group';
+/**
+ * All swarm operation tools
+ */
+export declare const swarmTools: (SwarmCreateTool | SwarmListTool | SwarmGetTool | SwarmGetAgentsTool | SwarmRegisterAgentTool | SwarmUnregisterAgentTool | SwarmCreateTeamTool | SwarmListTeamsTool | SwarmGetTeamTool | SwarmJoinTeamTool | SwarmLeaveTeamTool | SwarmDeleteTeamTool | SwarmCreateRoleTool | SwarmListRolesTool | SwarmGetRoleTool | SwarmAssignRoleTool | SwarmUnassignRoleTool | SwarmGetAgentsByRoleTool | SwarmDeleteRoleTool | SwarmCreateVacancyTool | SwarmListVacanciesTool | SwarmApplyVacancyTool | SwarmCloseVacancyTool | SwarmUpdateStatusTool | SwarmGetStatusSummaryTool | SwarmGetDefaultJobGroupTool)[];

package/dist/tools/swarm/index.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Swarm operations tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swarmTools = exports.SwarmGetDefaultJobGroupTool = exports.SwarmGetStatusSummaryTool = exports.SwarmUpdateStatusTool = exports.SwarmCloseVacancyTool = exports.SwarmApplyVacancyTool = exports.SwarmListVacanciesTool = exports.SwarmCreateVacancyTool = exports.SwarmDeleteRoleTool = exports.SwarmGetAgentsByRoleTool = exports.SwarmUnassignRoleTool = exports.SwarmAssignRoleTool = exports.SwarmGetRoleTool = exports.SwarmListRolesTool = exports.SwarmCreateRoleTool = exports.SwarmDeleteTeamTool = exports.SwarmLeaveTeamTool = exports.SwarmJoinTeamTool = exports.SwarmGetTeamTool = exports.SwarmListTeamsTool = exports.SwarmCreateTeamTool = exports.SwarmUnregisterAgentTool = exports.SwarmRegisterAgentTool = exports.SwarmGetAgentsTool = exports.SwarmGetTool = exports.SwarmListTool = exports.SwarmCreateTool = void 0;
+// Export tool classes and parameter types
+var swarm_create_1 = require("./swarm-create");
+Object.defineProperty(exports, "SwarmCreateTool", { enumerable: true, get: function () { return swarm_create_1.SwarmCreateTool; } });
+var swarm_list_1 = require("./swarm-list");
+Object.defineProperty(exports, "SwarmListTool", { enumerable: true, get: function () { return swarm_list_1.SwarmListTool; } });
+var swarm_get_1 = require("./swarm-get");
+Object.defineProperty(exports, "SwarmGetTool", { enumerable: true, get: function () { return swarm_get_1.SwarmGetTool; } });
+var swarm_get_agents_1 = require("./swarm-get-agents");
+Object.defineProperty(exports, "SwarmGetAgentsTool", { enumerable: true, get: function () { return swarm_get_agents_1.SwarmGetAgentsTool; } });
+var swarm_register_agent_1 = require("./swarm-register-agent");
+Object.defineProperty(exports, "SwarmRegisterAgentTool", { enumerable: true, get: function () { return swarm_register_agent_1.SwarmRegisterAgentTool; } });
+var swarm_unregister_agent_1 = require("./swarm-unregister-agent");
+Object.defineProperty(exports, "SwarmUnregisterAgentTool", { enumerable: true, get: function () { return swarm_unregister_agent_1.SwarmUnregisterAgentTool; } });
+var swarm_create_team_1 = require("./swarm-create-team");
+Object.defineProperty(exports, "SwarmCreateTeamTool", { enumerable: true, get: function () { return swarm_create_team_1.SwarmCreateTeamTool; } });
+var swarm_list_teams_1 = require("./swarm-list-teams");
+Object.defineProperty(exports, "SwarmListTeamsTool", { enumerable: true, get: function () { return swarm_list_teams_1.SwarmListTeamsTool; } });
+var swarm_get_team_1 = require("./swarm-get-team");
+Object.defineProperty(exports, "SwarmGetTeamTool", { enumerable: true, get: function () { return swarm_get_team_1.SwarmGetTeamTool; } });
+var swarm_join_team_1 = require("./swarm-join-team");
+Object.defineProperty(exports, "SwarmJoinTeamTool", { enumerable: true, get: function () { return swarm_join_team_1.SwarmJoinTeamTool; } });
+var swarm_leave_team_1 = require("./swarm-leave-team");
+Object.defineProperty(exports, "SwarmLeaveTeamTool", { enumerable: true, get: function () { return swarm_leave_team_1.SwarmLeaveTeamTool; } });
+var swarm_delete_team_1 = require("./swarm-delete-team");
+Object.defineProperty(exports, "SwarmDeleteTeamTool", { enumerable: true, get: function () { return swarm_delete_team_1.SwarmDeleteTeamTool; } });
+var swarm_create_role_1 = require("./swarm-create-role");
+Object.defineProperty(exports, "SwarmCreateRoleTool", { enumerable: true, get: function () { return swarm_create_role_1.SwarmCreateRoleTool; } });
+var swarm_list_roles_1 = require("./swarm-list-roles");
+Object.defineProperty(exports, "SwarmListRolesTool", { enumerable: true, get: function () { return swarm_list_roles_1.SwarmListRolesTool; } });
+var swarm_get_role_1 = require("./swarm-get-role");
+Object.defineProperty(exports, "SwarmGetRoleTool", { enumerable: true, get: function () { return swarm_get_role_1.SwarmGetRoleTool; } });
+var swarm_assign_role_1 = require("./swarm-assign-role");
+Object.defineProperty(exports, "SwarmAssignRoleTool", { enumerable: true, get: function () { return swarm_assign_role_1.SwarmAssignRoleTool; } });
+var swarm_unassign_role_1 = require("./swarm-unassign-role");
+Object.defineProperty(exports, "SwarmUnassignRoleTool", { enumerable: true, get: function () { return swarm_unassign_role_1.SwarmUnassignRoleTool; } });
+var swarm_get_agents_by_role_1 = require("./swarm-get-agents-by-role");
+Object.defineProperty(exports, "SwarmGetAgentsByRoleTool", { enumerable: true, get: function () { return swarm_get_agents_by_role_1.SwarmGetAgentsByRoleTool; } });
+var swarm_delete_role_1 = require("./swarm-delete-role");
+Object.defineProperty(exports, "SwarmDeleteRoleTool", { enumerable: true, get: function () { return swarm_delete_role_1.SwarmDeleteRoleTool; } });
+var swarm_create_vacancy_1 = require("./swarm-create-vacancy");
+Object.defineProperty(exports, "SwarmCreateVacancyTool", { enumerable: true, get: function () { return swarm_create_vacancy_1.SwarmCreateVacancyTool; } });
+var swarm_list_vacancies_1 = require("./swarm-list-vacancies");
+Object.defineProperty(exports, "SwarmListVacanciesTool", { enumerable: true, get: function () { return swarm_list_vacancies_1.SwarmListVacanciesTool; } });
+var swarm_apply_vacancy_1 = require("./swarm-apply-vacancy");
+Object.defineProperty(exports, "SwarmApplyVacancyTool", { enumerable: true, get: function () { return swarm_apply_vacancy_1.SwarmApplyVacancyTool; } });
+var swarm_close_vacancy_1 = require("./swarm-close-vacancy");
+Object.defineProperty(exports, "SwarmCloseVacancyTool", { enumerable: true, get: function () { return swarm_close_vacancy_1.SwarmCloseVacancyTool; } });
+var swarm_update_status_1 = require("./swarm-update-status");
+Object.defineProperty(exports, "SwarmUpdateStatusTool", { enumerable: true, get: function () { return swarm_update_status_1.SwarmUpdateStatusTool; } });
+var swarm_get_status_summary_1 = require("./swarm-get-status-summary");
+Object.defineProperty(exports, "SwarmGetStatusSummaryTool", { enumerable: true, get: function () { return swarm_get_status_summary_1.SwarmGetStatusSummaryTool; } });
+var swarm_get_default_job_group_1 = require("./swarm-get-default-job-group");
+Object.defineProperty(exports, "SwarmGetDefaultJobGroupTool", { enumerable: true, get: function () { return swarm_get_default_job_group_1.SwarmGetDefaultJobGroupTool; } });
+// Import tool classes for creating instances
+const swarm_create_2 = require("./swarm-create");
+const swarm_list_2 = require("./swarm-list");
+const swarm_get_2 = require("./swarm-get");
+const swarm_get_agents_2 = require("./swarm-get-agents");
+const swarm_register_agent_2 = require("./swarm-register-agent");
+const swarm_unregister_agent_2 = require("./swarm-unregister-agent");
+const swarm_create_team_2 = require("./swarm-create-team");
+const swarm_list_teams_2 = require("./swarm-list-teams");
+const swarm_get_team_2 = require("./swarm-get-team");
+const swarm_join_team_2 = require("./swarm-join-team");
+const swarm_leave_team_2 = require("./swarm-leave-team");
+const swarm_delete_team_2 = require("./swarm-delete-team");
+const swarm_create_role_2 = require("./swarm-create-role");
+const swarm_list_roles_2 = require("./swarm-list-roles");
+const swarm_get_role_2 = require("./swarm-get-role");
+const swarm_assign_role_2 = require("./swarm-assign-role");
+const swarm_unassign_role_2 = require("./swarm-unassign-role");
+const swarm_get_agents_by_role_2 = require("./swarm-get-agents-by-role");
+const swarm_delete_role_2 = require("./swarm-delete-role");
+const swarm_create_vacancy_2 = require("./swarm-create-vacancy");
+const swarm_list_vacancies_2 = require("./swarm-list-vacancies");
+const swarm_apply_vacancy_2 = require("./swarm-apply-vacancy");
+const swarm_close_vacancy_2 = require("./swarm-close-vacancy");
+const swarm_update_status_2 = require("./swarm-update-status");
+const swarm_get_status_summary_2 = require("./swarm-get-status-summary");
+const swarm_get_default_job_group_2 = require("./swarm-get-default-job-group");
+/**
+ * All swarm operation tools
+ */
+exports.swarmTools = [
+    // Swarm Management
+    new swarm_create_2.SwarmCreateTool(),
+    new swarm_list_2.SwarmListTool(),
+    new swarm_get_2.SwarmGetTool(),
+    new swarm_get_agents_2.SwarmGetAgentsTool(),
+    // Agent Registration
+    new swarm_register_agent_2.SwarmRegisterAgentTool(),
+    new swarm_unregister_agent_2.SwarmUnregisterAgentTool(),
+    // Team Management
+    new swarm_create_team_2.SwarmCreateTeamTool(),
+    new swarm_list_teams_2.SwarmListTeamsTool(),
+    new swarm_get_team_2.SwarmGetTeamTool(),
+    new swarm_join_team_2.SwarmJoinTeamTool(),
+    new swarm_leave_team_2.SwarmLeaveTeamTool(),
+    new swarm_delete_team_2.SwarmDeleteTeamTool(),
+    // Role Management
+    new swarm_create_role_2.SwarmCreateRoleTool(),
+    new swarm_list_roles_2.SwarmListRolesTool(),
+    new swarm_get_role_2.SwarmGetRoleTool(),
+    new swarm_assign_role_2.SwarmAssignRoleTool(),
+    new swarm_unassign_role_2.SwarmUnassignRoleTool(),
+    new swarm_get_agents_by_role_2.SwarmGetAgentsByRoleTool(),
+    new swarm_delete_role_2.SwarmDeleteRoleTool(),
+    // Vacancy Management
+    new swarm_create_vacancy_2.SwarmCreateVacancyTool(),
+    new swarm_list_vacancies_2.SwarmListVacanciesTool(),
+    new swarm_apply_vacancy_2.SwarmApplyVacancyTool(),
+    new swarm_close_vacancy_2.SwarmCloseVacancyTool(),
+    // Status Management
+    new swarm_update_status_2.SwarmUpdateStatusTool(),
+    new swarm_get_status_summary_2.SwarmGetStatusSummaryTool(),
+    // Job Group Management
+    new swarm_get_default_job_group_2.SwarmGetDefaultJobGroupTool(),
+];

package/dist/tools/swarm/swarm-apply-vacancy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Swarm Apply Vacancy Tool - Apply for a vacancy
+ * Wraps the SDK's swarmService.applyForVacancy() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the SwarmApplyVacancy tool
+ */
+export interface SwarmApplyVacancyToolParams {
+    /**
+     * The ID of the swarm
+     */
+    swarm_id: string;
+    /**
+     * The ID of the vacancy to apply for
+     */
+    vacancy_id: string;
+    /**
+     * The ID of the agent applying
+     */
+    agent_id: string;
+    /**
+     * Optional application message
+     */
+    message?: string;
+}
+/**
+ * Implementation of the SwarmApplyVacancy tool
+ */
+export declare class SwarmApplyVacancyTool extends BaseDeclarativeTool<SwarmApplyVacancyToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: SwarmApplyVacancyToolParams): string | null;
+    protected createInvocation(params: SwarmApplyVacancyToolParams): ToolInvocation<SwarmApplyVacancyToolParams, ToolResult>;
+}

package/dist/tools/swarm/swarm-apply-vacancy.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Swarm Apply Vacancy Tool - Apply for a vacancy
+ * Wraps the SDK's swarmService.applyForVacancy() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwarmApplyVacancyTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const swarm_1 = __importDefault(require("../../modules/swarm"));
+class SwarmApplyVacancyToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await swarm_1.default.applyForVacancy(this.params.swarm_id, this.params.vacancy_id, this.params.agent_id, this.params.message);
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: 'Successfully applied for vacancy',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error applying for vacancy: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the SwarmApplyVacancy tool
+ */
+class SwarmApplyVacancyTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(SwarmApplyVacancyTool.Name, 'SwarmApplyVacancy', 'Allows an agent to apply for a vacancy in a swarm.', types_1.Kind.Edit, {
+            properties: {
+                swarm_id: {
+                    description: 'The ID of the swarm',
+                    type: 'string',
+                },
+                vacancy_id: {
+                    description: 'The ID of the vacancy to apply for',
+                    type: 'string',
+                },
+                agent_id: {
+                    description: 'The ID of the agent applying',
+                    type: 'string',
+                },
+                message: {
+                    description: 'Optional application message',
+                    type: 'string',
+                },
+            },
+            required: ['swarm_id', 'vacancy_id', 'agent_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.swarm_id || params.swarm_id.trim() === '') {
+            return "The 'swarm_id' parameter must be non-empty.";
+        }
+        if (!params.vacancy_id || params.vacancy_id.trim() === '') {
+            return "The 'vacancy_id' parameter must be non-empty.";
+        }
+        if (!params.agent_id || params.agent_id.trim() === '') {
+            return "The 'agent_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new SwarmApplyVacancyToolInvocation(params);
+    }
+}
+exports.SwarmApplyVacancyTool = SwarmApplyVacancyTool;
+SwarmApplyVacancyTool.Name = 'swarm_apply_vacancy';

package/dist/tools/swarm/swarm-assign-role.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Swarm Assign Role Tool - Assigns a role to an agent
+ * Wraps the SDK's swarmService.assignRole() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the SwarmAssignRole tool
+ */
+export interface SwarmAssignRoleToolParams {
+    /**
+     * The ID of the swarm
+     */
+    swarm_id: string;
+    /**
+     * The ID of the role to assign
+     */
+    role_id: string;
+    /**
+     * The ID of the agent to assign the role to
+     */
+    agent_id: string;
+}
+/**
+ * Implementation of the SwarmAssignRole tool
+ */
+export declare class SwarmAssignRoleTool extends BaseDeclarativeTool<SwarmAssignRoleToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: SwarmAssignRoleToolParams): string | null;
+    protected createInvocation(params: SwarmAssignRoleToolParams): ToolInvocation<SwarmAssignRoleToolParams, ToolResult>;
+}

package/dist/tools/swarm/swarm-assign-role.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Swarm Assign Role Tool - Assigns a role to an agent
+ * Wraps the SDK's swarmService.assignRole() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwarmAssignRoleTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const swarm_1 = __importDefault(require("../../modules/swarm"));
+class SwarmAssignRoleToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await swarm_1.default.assignRole(this.params.swarm_id, this.params.role_id, this.params.agent_id);
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: 'Successfully assigned role to agent',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error assigning role: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the SwarmAssignRole tool
+ */
+class SwarmAssignRoleTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(SwarmAssignRoleTool.Name, 'SwarmAssignRole', 'Assigns a role to an agent within a swarm.', types_1.Kind.Edit, {
+            properties: {
+                swarm_id: {
+                    description: 'The ID of the swarm',
+                    type: 'string',
+                },
+                role_id: {
+                    description: 'The ID of the role to assign',
+                    type: 'string',
+                },
+                agent_id: {
+                    description: 'The ID of the agent to assign the role to',
+                    type: 'string',
+                },
+            },
+            required: ['swarm_id', 'role_id', 'agent_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.swarm_id || params.swarm_id.trim() === '') {
+            return "The 'swarm_id' parameter must be non-empty.";
+        }
+        if (!params.role_id || params.role_id.trim() === '') {
+            return "The 'role_id' parameter must be non-empty.";
+        }
+        if (!params.agent_id || params.agent_id.trim() === '') {
+            return "The 'agent_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new SwarmAssignRoleToolInvocation(params);
+    }
+}
+exports.SwarmAssignRoleTool = SwarmAssignRoleTool;
+SwarmAssignRoleTool.Name = 'swarm_assign_role';

package/dist/tools/swarm/swarm-close-vacancy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Swarm Close Vacancy Tool - Closes a vacancy
+ * Wraps the SDK's swarmService.closeVacancy() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the SwarmCloseVacancy tool
+ */
+export interface SwarmCloseVacancyToolParams {
+    /**
+     * The ID of the swarm
+     */
+    swarm_id: string;
+    /**
+     * The ID of the vacancy to close
+     */
+    vacancy_id: string;
+    /**
+     * The reason for closing the vacancy
+     */
+    reason: string;
+}
+/**
+ * Implementation of the SwarmCloseVacancy tool
+ */
+export declare class SwarmCloseVacancyTool extends BaseDeclarativeTool<SwarmCloseVacancyToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: SwarmCloseVacancyToolParams): string | null;
+    protected createInvocation(params: SwarmCloseVacancyToolParams): ToolInvocation<SwarmCloseVacancyToolParams, ToolResult>;
+}