@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/agentEventQueue/eventqueue-send-message.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * EventQueue Send Message Tool
+ * Wraps the SDK's agentEventQueue.sendAgentMessage() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueueSendMessageTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const agentEventQueue_1 = __importDefault(require("../../modules/agentEventQueue"));
+const agentEventQueue_2 = require("../../types/agentEventQueue");
+class EventQueueSendMessageInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            const response = await agentEventQueue_1.default.sendAgentMessage({
+                targetAgentId: this.params.targetAgentId,
+                targetThreadId: this.params.targetThreadId,
+                content: this.params.content,
+                messageType: this.params.messageType || 'text',
+                priority: this.params.priority || agentEventQueue_2.AgentEventPriority.NORMAL,
+                replyTo: this.params.replyTo
+            });
+            if (!response.success) {
+                return {
+                    llmContent: `Failed to send message: ${response.message}`,
+                    returnDisplay: `Error: ${response.message}`,
+                    error: {
+                        message: response.message,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            let llmContent = `Message sent successfully.\n\n`;
+            llmContent += `Event ID: ${(_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.event) === null || _b === void 0 ? void 0 : _b.eventId}\n`;
+            llmContent += `Target Agent: ${this.params.targetAgentId}\n`;
+            llmContent += `Content: ${this.params.content.substring(0, 100)}${this.params.content.length > 100 ? '...' : ''}`;
+            return {
+                llmContent,
+                returnDisplay: `Sent message to ${this.params.targetAgentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error sending message: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for sending an inter-agent message
+ */
+class EventQueueSendMessageTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EventQueueSendMessageTool.Name, 'Send Agent Message', 'Send a message to another agent via the event queue. This is a convenience wrapper for inter-agent communication.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                targetAgentId: {
+                    type: 'string',
+                    description: 'The ID of the target agent to receive the message'
+                },
+                targetThreadId: {
+                    type: 'string',
+                    description: 'Optional thread ID for the target agent'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The message content to send'
+                },
+                messageType: {
+                    type: 'string',
+                    enum: ['text', 'json', 'command'],
+                    description: 'Type of message content (default: text)'
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['low', 'normal', 'high', 'urgent'],
+                    description: 'Message priority (default: normal)'
+                },
+                replyTo: {
+                    type: 'string',
+                    description: 'Optional event ID this message is replying to'
+                }
+            },
+            required: ['targetAgentId', 'content']
+        });
+    }
+    createInvocation(params) {
+        return new EventQueueSendMessageInvocation(params);
+    }
+}
+exports.EventQueueSendMessageTool = EventQueueSendMessageTool;
+EventQueueSendMessageTool.Name = 'eventqueue_send_message';

package/dist/tools/agentEventQueue/eventqueue-wait-next.d.ts

@@ -0,0 +1,21 @@
+/**
+ * EventQueue Wait Next Tool
+ * Wraps the SDK's agentEventQueue.waitForNextQueueEvent() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the EventQueue Wait Next tool
+ */
+export interface EventQueueWaitNextParams {
+    /** Maximum number of events to return */
+    maxDepth?: number;
+}
+/**
+ * Tool for waiting for the next queue event
+ */
+export declare class EventQueueWaitNextTool extends BaseDeclarativeTool<EventQueueWaitNextParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EventQueueWaitNextParams): ToolInvocation<EventQueueWaitNextParams, ToolResult>;
+}

package/dist/tools/agentEventQueue/eventqueue-wait-next.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * EventQueue Wait Next Tool
+ * Wraps the SDK's agentEventQueue.waitForNextQueueEvent() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueueWaitNextTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const agentEventQueue_1 = __importDefault(require("../../modules/agentEventQueue"));
+class EventQueueWaitNextInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const result = await agentEventQueue_1.default.waitForNextQueueEvent(this.params.maxDepth || 1);
+            // Normalize to array for consistent handling
+            const events = Array.isArray(result) ? result : [result];
+            let llmContent = `Received ${events.length} event(s):\n\n`;
+            for (const event of events) {
+                llmContent += `---\n`;
+                llmContent += `Event ID: ${event.eventId}\n`;
+                llmContent += `Type: ${event.eventType}\n`;
+                llmContent += `Priority: ${event.priority}\n`;
+                llmContent += `From: ${event.sourceAgentId || 'Unknown'}\n`;
+                llmContent += `Created: ${event.createdAt}\n`;
+                llmContent += `Payload: ${JSON.stringify(event.payload, null, 2)}\n`;
+            }
+            llmContent += `\nNote: These events have been acknowledged and removed from the queue.`;
+            return {
+                llmContent,
+                returnDisplay: `Received ${events.length} event(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error waiting for events: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for waiting for the next queue event
+ */
+class EventQueueWaitNextTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EventQueueWaitNextTool.Name, 'Wait for Next Event', 'Wait for the next event(s) to arrive in the queue. This is a blocking call that resolves when an event is received. Events are automatically acknowledged.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                maxDepth: {
+                    type: 'number',
+                    description: 'Maximum number of events to return (default: 1). If more than 1, will try to batch events from the cache after receiving the first.'
+                }
+            },
+            required: []
+        });
+    }
+    createInvocation(params) {
+        return new EventQueueWaitNextInvocation(params);
+    }
+}
+exports.EventQueueWaitNextTool = EventQueueWaitNextTool;
+EventQueueWaitNextTool.Name = 'eventqueue_wait_next';

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

@@ -0,0 +1,19 @@
+/**
+ * Agent Event Queue tools
+ */
+export { EventQueueAddEventTool, type EventQueueAddEventParams } from './eventqueue-add-event';
+export { EventQueueSendMessageTool, type EventQueueSendMessageParams } from './eventqueue-send-message';
+export { EventQueueGetStatsTool, type EventQueueGetStatsParams } from './eventqueue-get-stats';
+export { EventQueueGetPendingTool, type EventQueueGetPendingParams } from './eventqueue-get-pending';
+export { EventQueueWaitNextTool, type EventQueueWaitNextParams } from './eventqueue-wait-next';
+export { EventQueueAcknowledgeTool, type EventQueueAcknowledgeParams } from './eventqueue-acknowledge';
+import { EventQueueAddEventTool } from './eventqueue-add-event';
+import { EventQueueSendMessageTool } from './eventqueue-send-message';
+import { EventQueueGetStatsTool } from './eventqueue-get-stats';
+import { EventQueueGetPendingTool } from './eventqueue-get-pending';
+import { EventQueueWaitNextTool } from './eventqueue-wait-next';
+import { EventQueueAcknowledgeTool } from './eventqueue-acknowledge';
+/**
+ * All agent event queue tools
+ */
+export declare const agentEventQueueTools: (EventQueueAddEventTool | EventQueueSendMessageTool | EventQueueGetStatsTool | EventQueueGetPendingTool | EventQueueWaitNextTool | EventQueueAcknowledgeTool)[];

package/dist/tools/agentEventQueue/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Agent Event Queue tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentEventQueueTools = exports.EventQueueAcknowledgeTool = exports.EventQueueWaitNextTool = exports.EventQueueGetPendingTool = exports.EventQueueGetStatsTool = exports.EventQueueSendMessageTool = exports.EventQueueAddEventTool = void 0;
+var eventqueue_add_event_1 = require("./eventqueue-add-event");
+Object.defineProperty(exports, "EventQueueAddEventTool", { enumerable: true, get: function () { return eventqueue_add_event_1.EventQueueAddEventTool; } });
+var eventqueue_send_message_1 = require("./eventqueue-send-message");
+Object.defineProperty(exports, "EventQueueSendMessageTool", { enumerable: true, get: function () { return eventqueue_send_message_1.EventQueueSendMessageTool; } });
+var eventqueue_get_stats_1 = require("./eventqueue-get-stats");
+Object.defineProperty(exports, "EventQueueGetStatsTool", { enumerable: true, get: function () { return eventqueue_get_stats_1.EventQueueGetStatsTool; } });
+var eventqueue_get_pending_1 = require("./eventqueue-get-pending");
+Object.defineProperty(exports, "EventQueueGetPendingTool", { enumerable: true, get: function () { return eventqueue_get_pending_1.EventQueueGetPendingTool; } });
+var eventqueue_wait_next_1 = require("./eventqueue-wait-next");
+Object.defineProperty(exports, "EventQueueWaitNextTool", { enumerable: true, get: function () { return eventqueue_wait_next_1.EventQueueWaitNextTool; } });
+var eventqueue_acknowledge_1 = require("./eventqueue-acknowledge");
+Object.defineProperty(exports, "EventQueueAcknowledgeTool", { enumerable: true, get: function () { return eventqueue_acknowledge_1.EventQueueAcknowledgeTool; } });
+// Create instances for convenience
+const eventqueue_add_event_2 = require("./eventqueue-add-event");
+const eventqueue_send_message_2 = require("./eventqueue-send-message");
+const eventqueue_get_stats_2 = require("./eventqueue-get-stats");
+const eventqueue_get_pending_2 = require("./eventqueue-get-pending");
+const eventqueue_wait_next_2 = require("./eventqueue-wait-next");
+const eventqueue_acknowledge_2 = require("./eventqueue-acknowledge");
+/**
+ * All agent event queue tools
+ */
+exports.agentEventQueueTools = [
+    new eventqueue_add_event_2.EventQueueAddEventTool(),
+    new eventqueue_send_message_2.EventQueueSendMessageTool(),
+    new eventqueue_get_stats_2.EventQueueGetStatsTool(),
+    new eventqueue_get_pending_2.EventQueueGetPendingTool(),
+    new eventqueue_wait_next_2.EventQueueWaitNextTool(),
+    new eventqueue_acknowledge_2.EventQueueAcknowledgeTool(),
+];

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

@@ -0,0 +1,37 @@
+/**
+ * Agent Portfolio Tools
+ *
+ * Tools for managing agent portfolios, karma, talents, testimonials, and appreciations.
+ */
+export { PortfolioGetTool } from './portfolio-get';
+export { PortfolioGetConversationsTool } from './portfolio-get-conversations';
+export { PortfolioAddTestimonialTool } from './portfolio-add-testimonial';
+export { PortfolioUpdateTestimonialTool } from './portfolio-update-testimonial';
+export { PortfolioDeleteTestimonialTool } from './portfolio-delete-testimonial';
+export { PortfolioAddKarmaTool } from './portfolio-add-karma';
+export { PortfolioGetKarmaHistoryTool } from './portfolio-get-karma-history';
+export { PortfolioAddAppreciationTool } from './portfolio-add-appreciation';
+export { PortfolioAddTalentTool } from './portfolio-add-talent';
+export { PortfolioEndorseTalentTool } from './portfolio-endorse-talent';
+export { PortfolioGetTalentsTool } from './portfolio-get-talents';
+export { PortfolioGetRankingTool } from './portfolio-get-ranking';
+export { PortfolioGetByProjectTool } from './portfolio-get-by-project';
+export { PortfolioUpdateProfileTool } from './portfolio-update-profile';
+import { PortfolioGetTool } from './portfolio-get';
+import { PortfolioGetConversationsTool } from './portfolio-get-conversations';
+import { PortfolioAddTestimonialTool } from './portfolio-add-testimonial';
+import { PortfolioUpdateTestimonialTool } from './portfolio-update-testimonial';
+import { PortfolioDeleteTestimonialTool } from './portfolio-delete-testimonial';
+import { PortfolioAddKarmaTool } from './portfolio-add-karma';
+import { PortfolioGetKarmaHistoryTool } from './portfolio-get-karma-history';
+import { PortfolioAddAppreciationTool } from './portfolio-add-appreciation';
+import { PortfolioAddTalentTool } from './portfolio-add-talent';
+import { PortfolioEndorseTalentTool } from './portfolio-endorse-talent';
+import { PortfolioGetTalentsTool } from './portfolio-get-talents';
+import { PortfolioGetRankingTool } from './portfolio-get-ranking';
+import { PortfolioGetByProjectTool } from './portfolio-get-by-project';
+import { PortfolioUpdateProfileTool } from './portfolio-update-profile';
+/**
+ * Array of all agent portfolio tools
+ */
+export declare const agentPortfolioTools: (PortfolioGetTool | PortfolioGetConversationsTool | PortfolioAddTestimonialTool | PortfolioUpdateTestimonialTool | PortfolioDeleteTestimonialTool | PortfolioAddKarmaTool | PortfolioGetKarmaHistoryTool | PortfolioAddAppreciationTool | PortfolioAddTalentTool | PortfolioEndorseTalentTool | PortfolioGetTalentsTool | PortfolioGetRankingTool | PortfolioGetByProjectTool | PortfolioUpdateProfileTool)[];

package/dist/tools/agentPortfolio/index.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Agent Portfolio Tools
+ *
+ * Tools for managing agent portfolios, karma, talents, testimonials, and appreciations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentPortfolioTools = exports.PortfolioUpdateProfileTool = exports.PortfolioGetByProjectTool = exports.PortfolioGetRankingTool = exports.PortfolioGetTalentsTool = exports.PortfolioEndorseTalentTool = exports.PortfolioAddTalentTool = exports.PortfolioAddAppreciationTool = exports.PortfolioGetKarmaHistoryTool = exports.PortfolioAddKarmaTool = exports.PortfolioDeleteTestimonialTool = exports.PortfolioUpdateTestimonialTool = exports.PortfolioAddTestimonialTool = exports.PortfolioGetConversationsTool = exports.PortfolioGetTool = void 0;
+var portfolio_get_1 = require("./portfolio-get");
+Object.defineProperty(exports, "PortfolioGetTool", { enumerable: true, get: function () { return portfolio_get_1.PortfolioGetTool; } });
+var portfolio_get_conversations_1 = require("./portfolio-get-conversations");
+Object.defineProperty(exports, "PortfolioGetConversationsTool", { enumerable: true, get: function () { return portfolio_get_conversations_1.PortfolioGetConversationsTool; } });
+var portfolio_add_testimonial_1 = require("./portfolio-add-testimonial");
+Object.defineProperty(exports, "PortfolioAddTestimonialTool", { enumerable: true, get: function () { return portfolio_add_testimonial_1.PortfolioAddTestimonialTool; } });
+var portfolio_update_testimonial_1 = require("./portfolio-update-testimonial");
+Object.defineProperty(exports, "PortfolioUpdateTestimonialTool", { enumerable: true, get: function () { return portfolio_update_testimonial_1.PortfolioUpdateTestimonialTool; } });
+var portfolio_delete_testimonial_1 = require("./portfolio-delete-testimonial");
+Object.defineProperty(exports, "PortfolioDeleteTestimonialTool", { enumerable: true, get: function () { return portfolio_delete_testimonial_1.PortfolioDeleteTestimonialTool; } });
+var portfolio_add_karma_1 = require("./portfolio-add-karma");
+Object.defineProperty(exports, "PortfolioAddKarmaTool", { enumerable: true, get: function () { return portfolio_add_karma_1.PortfolioAddKarmaTool; } });
+var portfolio_get_karma_history_1 = require("./portfolio-get-karma-history");
+Object.defineProperty(exports, "PortfolioGetKarmaHistoryTool", { enumerable: true, get: function () { return portfolio_get_karma_history_1.PortfolioGetKarmaHistoryTool; } });
+var portfolio_add_appreciation_1 = require("./portfolio-add-appreciation");
+Object.defineProperty(exports, "PortfolioAddAppreciationTool", { enumerable: true, get: function () { return portfolio_add_appreciation_1.PortfolioAddAppreciationTool; } });
+var portfolio_add_talent_1 = require("./portfolio-add-talent");
+Object.defineProperty(exports, "PortfolioAddTalentTool", { enumerable: true, get: function () { return portfolio_add_talent_1.PortfolioAddTalentTool; } });
+var portfolio_endorse_talent_1 = require("./portfolio-endorse-talent");
+Object.defineProperty(exports, "PortfolioEndorseTalentTool", { enumerable: true, get: function () { return portfolio_endorse_talent_1.PortfolioEndorseTalentTool; } });
+var portfolio_get_talents_1 = require("./portfolio-get-talents");
+Object.defineProperty(exports, "PortfolioGetTalentsTool", { enumerable: true, get: function () { return portfolio_get_talents_1.PortfolioGetTalentsTool; } });
+var portfolio_get_ranking_1 = require("./portfolio-get-ranking");
+Object.defineProperty(exports, "PortfolioGetRankingTool", { enumerable: true, get: function () { return portfolio_get_ranking_1.PortfolioGetRankingTool; } });
+var portfolio_get_by_project_1 = require("./portfolio-get-by-project");
+Object.defineProperty(exports, "PortfolioGetByProjectTool", { enumerable: true, get: function () { return portfolio_get_by_project_1.PortfolioGetByProjectTool; } });
+var portfolio_update_profile_1 = require("./portfolio-update-profile");
+Object.defineProperty(exports, "PortfolioUpdateProfileTool", { enumerable: true, get: function () { return portfolio_update_profile_1.PortfolioUpdateProfileTool; } });
+const portfolio_get_2 = require("./portfolio-get");
+const portfolio_get_conversations_2 = require("./portfolio-get-conversations");
+const portfolio_add_testimonial_2 = require("./portfolio-add-testimonial");
+const portfolio_update_testimonial_2 = require("./portfolio-update-testimonial");
+const portfolio_delete_testimonial_2 = require("./portfolio-delete-testimonial");
+const portfolio_add_karma_2 = require("./portfolio-add-karma");
+const portfolio_get_karma_history_2 = require("./portfolio-get-karma-history");
+const portfolio_add_appreciation_2 = require("./portfolio-add-appreciation");
+const portfolio_add_talent_2 = require("./portfolio-add-talent");
+const portfolio_endorse_talent_2 = require("./portfolio-endorse-talent");
+const portfolio_get_talents_2 = require("./portfolio-get-talents");
+const portfolio_get_ranking_2 = require("./portfolio-get-ranking");
+const portfolio_get_by_project_2 = require("./portfolio-get-by-project");
+const portfolio_update_profile_2 = require("./portfolio-update-profile");
+/**
+ * Array of all agent portfolio tools
+ */
+exports.agentPortfolioTools = [
+    new portfolio_get_2.PortfolioGetTool(),
+    new portfolio_get_conversations_2.PortfolioGetConversationsTool(),
+    new portfolio_add_testimonial_2.PortfolioAddTestimonialTool(),
+    new portfolio_update_testimonial_2.PortfolioUpdateTestimonialTool(),
+    new portfolio_delete_testimonial_2.PortfolioDeleteTestimonialTool(),
+    new portfolio_add_karma_2.PortfolioAddKarmaTool(),
+    new portfolio_get_karma_history_2.PortfolioGetKarmaHistoryTool(),
+    new portfolio_add_appreciation_2.PortfolioAddAppreciationTool(),
+    new portfolio_add_talent_2.PortfolioAddTalentTool(),
+    new portfolio_endorse_talent_2.PortfolioEndorseTalentTool(),
+    new portfolio_get_talents_2.PortfolioGetTalentsTool(),
+    new portfolio_get_ranking_2.PortfolioGetRankingTool(),
+    new portfolio_get_by_project_2.PortfolioGetByProjectTool(),
+    new portfolio_update_profile_2.PortfolioUpdateProfileTool(),
+];

package/dist/tools/agentPortfolio/portfolio-add-appreciation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Portfolio Add Appreciation Tool
+ *
+ * Adds an appreciation for an agent.
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for adding an appreciation
+ */
+export interface PortfolioAddAppreciationParams {
+    /** The ID of the agent receiving appreciation */
+    toAgentId: string;
+    /** The appreciation message */
+    message: string;
+}
+/**
+ * Tool for adding an appreciation
+ */
+export declare class PortfolioAddAppreciationTool extends BaseDeclarativeTool<PortfolioAddAppreciationParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: PortfolioAddAppreciationParams): ToolInvocation<PortfolioAddAppreciationParams, ToolResult>;
+}

package/dist/tools/agentPortfolio/portfolio-add-appreciation.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Portfolio Add Appreciation Tool
+ *
+ * Adds an appreciation for an agent.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortfolioAddAppreciationTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const agentPortfolio_1 = __importDefault(require("../../modules/agentPortfolio"));
+class PortfolioAddAppreciationInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await agentPortfolio_1.default.addAppreciation(this.params.toAgentId, this.params.message);
+            if (!response.success && response.error) {
+                return {
+                    llmContent: `Error: Failed to add appreciation - ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: {
+                        message: response.error,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const appreciation = response.data;
+            const appreciationId = appreciation === null || appreciation === void 0 ? void 0 : appreciation.id;
+            return {
+                llmContent: `Successfully added appreciation for agent ${this.params.toAgentId}${appreciationId ? ` (ID: ${appreciationId})` : ''}`,
+                returnDisplay: `Added appreciation for agent ${this.params.toAgentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for adding an appreciation
+ */
+class PortfolioAddAppreciationTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('portfolio_add_appreciation', 'Add Portfolio Appreciation', 'Adds an appreciation message for an agent.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                toAgentId: {
+                    type: 'string',
+                    description: 'The ID of the agent receiving appreciation',
+                },
+                message: {
+                    type: 'string',
+                    description: 'The appreciation message',
+                },
+            },
+            required: ['toAgentId', 'message'],
+        });
+    }
+    createInvocation(params) {
+        return new PortfolioAddAppreciationInvocation(params);
+    }
+}
+exports.PortfolioAddAppreciationTool = PortfolioAddAppreciationTool;

package/dist/tools/agentPortfolio/portfolio-add-karma.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Portfolio Add Karma Tool
+ *
+ * Adds karma to an agent.
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for adding karma
+ */
+export interface PortfolioAddKarmaParams {
+    /** The ID of the agent receiving karma */
+    toAgentId: string;
+    /** The amount of karma to add (can be negative) */
+    amount: number;
+    /** Optional reason for the karma change */
+    reason?: string;
+}
+/**
+ * Tool for adding karma to an agent
+ */
+export declare class PortfolioAddKarmaTool extends BaseDeclarativeTool<PortfolioAddKarmaParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: PortfolioAddKarmaParams): ToolInvocation<PortfolioAddKarmaParams, ToolResult>;
+}

package/dist/tools/agentPortfolio/portfolio-add-karma.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Portfolio Add Karma Tool
+ *
+ * Adds karma to an agent.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortfolioAddKarmaTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const agentPortfolio_1 = __importDefault(require("../../modules/agentPortfolio"));
+class PortfolioAddKarmaInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        var _a;
+        try {
+            const response = await agentPortfolio_1.default.addKarma(this.params.toAgentId, this.params.amount, this.params.reason);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error: Failed to add karma - ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const newTotal = (_a = response.data) === null || _a === void 0 ? void 0 : _a.newTotal;
+            return {
+                llmContent: `Successfully added ${this.params.amount} karma to agent ${this.params.toAgentId}${newTotal !== undefined ? `. New total: ${newTotal}` : ''}${this.params.reason ? `. Reason: ${this.params.reason}` : ''}`,
+                returnDisplay: `Added ${this.params.amount} karma to agent ${this.params.toAgentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for adding karma to an agent
+ */
+class PortfolioAddKarmaTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('portfolio_add_karma', 'Add Portfolio Karma', 'Adds karma to an agent. Amount can be positive or negative.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                toAgentId: {
+                    type: 'string',
+                    description: 'The ID of the agent receiving karma',
+                },
+                amount: {
+                    type: 'number',
+                    description: 'The amount of karma to add (can be negative)',
+                },
+                reason: {
+                    type: 'string',
+                    description: 'Optional reason for the karma change',
+                },
+            },
+            required: ['toAgentId', 'amount'],
+        });
+    }
+    createInvocation(params) {
+        return new PortfolioAddKarmaInvocation(params);
+    }
+}
+exports.PortfolioAddKarmaTool = PortfolioAddKarmaTool;

package/dist/tools/agentPortfolio/portfolio-add-talent.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Portfolio Add Talent Tool
+ *
+ * Adds a talent skill.
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for adding a talent
+ */
+export interface PortfolioAddTalentParams {
+    /** The name of the talent */
+    name: string;
+    /** Optional description of the talent */
+    description?: string;
+}
+/**
+ * Tool for adding a talent
+ */
+export declare class PortfolioAddTalentTool extends BaseDeclarativeTool<PortfolioAddTalentParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: PortfolioAddTalentParams): ToolInvocation<PortfolioAddTalentParams, ToolResult>;
+}