@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/collaboration/feedback-get.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Feedback Get Tool - Gets a feedback by ID
+ * Wraps the SDK's cbgroupFeedback.get() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const groupFeedback_1 = __importDefault(require("../../modules/groupFeedback"));
+class FeedbackGetToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await groupFeedback_1.default.get(this.params);
+            const feedbackInfo = ((_a = response.payload) === null || _a === void 0 ? void 0 : _a.feedback)
+                ? `Retrieved feedback: ${response.payload.feedback.title}`
+                : 'Feedback retrieved successfully';
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: feedbackInfo,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting feedback: ${errorMessage}`,
+                returnDisplay: `Error getting feedback: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the FeedbackGet tool logic
+ */
+class FeedbackGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FeedbackGetTool.Name, 'FeedbackGet', `Gets a feedback by ID. You can optionally specify a view type to retrieve different aspects of the feedback.`, types_1.Kind.Read, {
+            properties: {
+                id: {
+                    description: 'The ID of the feedback to retrieve',
+                    type: 'string',
+                },
+                view: {
+                    description: "Optional view type: 'request' (feedback only), 'full' (feedback + responses), 'responses' (responses only), or 'summary' (summary only)",
+                    type: 'string',
+                    enum: ['request', 'full', 'responses', 'summary'],
+                },
+            },
+            required: ['id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.id || params.id.trim() === '') {
+            return "The 'id' parameter must be non-empty.";
+        }
+        if (params.view && !['request', 'full', 'responses', 'summary'].includes(params.view)) {
+            return "The 'view' parameter must be 'request', 'full', 'responses', or 'summary'.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FeedbackGetToolInvocation(params);
+    }
+}
+exports.FeedbackGetTool = FeedbackGetTool;
+FeedbackGetTool.Name = 'feedback_get';

package/dist/tools/collaboration/feedback-list.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Feedback List Tool - Lists all feedback requests
+ * Wraps the SDK's cbgroupFeedback.list() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the FeedbackList tool
+ */
+export interface FeedbackListToolParams {
+    /**
+     * Optional status filter: 'open' | 'in-progress' | 'resolved' | 'closed'
+     */
+    status?: 'open' | 'in-progress' | 'resolved' | 'closed';
+    /**
+     * Optional participant filter
+     */
+    participant?: string;
+    /**
+     * Optional search query
+     */
+    search?: string;
+    /**
+     * Optional limit for results
+     */
+    limit?: number;
+    /**
+     * Optional offset for pagination
+     */
+    offset?: number;
+}
+/**
+ * Implementation of the FeedbackList tool logic
+ */
+export declare class FeedbackListTool extends BaseDeclarativeTool<FeedbackListToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FeedbackListToolParams): string | null;
+    protected createInvocation(params: FeedbackListToolParams): ToolInvocation<FeedbackListToolParams, ToolResult>;
+}

package/dist/tools/collaboration/feedback-list.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Feedback List Tool - Lists all feedback requests
+ * Wraps the SDK's cbgroupFeedback.list() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const groupFeedback_1 = __importDefault(require("../../modules/groupFeedback"));
+class FeedbackListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b, _c;
+        try {
+            const response = await groupFeedback_1.default.list(this.params);
+            const feedbackCount = ((_b = (_a = response.payload) === null || _a === void 0 ? void 0 : _a.feedbacks) === null || _b === void 0 ? void 0 : _b.length) || 0;
+            const total = ((_c = response.payload) === null || _c === void 0 ? void 0 : _c.total) || feedbackCount;
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: `Retrieved ${feedbackCount} feedback(s) of ${total} total`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing feedbacks: ${errorMessage}`,
+                returnDisplay: `Error listing feedbacks: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the FeedbackList tool logic
+ */
+class FeedbackListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FeedbackListTool.Name, 'FeedbackList', `Lists all feedback requests. You can optionally filter by status, participant, search query, and paginate results using limit and offset.`, types_1.Kind.Read, {
+            properties: {
+                status: {
+                    description: "Optional status filter: 'open', 'in-progress', 'resolved', or 'closed'",
+                    type: 'string',
+                    enum: ['open', 'in-progress', 'resolved', 'closed'],
+                },
+                participant: {
+                    description: 'Optional participant ID to filter by',
+                    type: 'string',
+                },
+                search: {
+                    description: 'Optional search query to filter feedbacks',
+                    type: 'string',
+                },
+                limit: {
+                    description: 'Optional limit for number of results to return',
+                    type: 'number',
+                },
+                offset: {
+                    description: 'Optional offset for pagination',
+                    type: 'number',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (params.status && !['open', 'in-progress', 'resolved', 'closed'].includes(params.status)) {
+            return "The 'status' parameter must be 'open', 'in-progress', 'resolved', or 'closed'.";
+        }
+        if (params.limit !== undefined && params.limit <= 0) {
+            return "The 'limit' parameter must be a positive number.";
+        }
+        if (params.offset !== undefined && params.offset < 0) {
+            return "The 'offset' parameter must be a non-negative number.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FeedbackListToolInvocation(params);
+    }
+}
+exports.FeedbackListTool = FeedbackListTool;
+FeedbackListTool.Name = 'feedback_list';

package/dist/tools/collaboration/feedback-respond.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Feedback Respond Tool - Adds a response to a feedback request
+ * Wraps the SDK's cbgroupFeedback.respond() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the FeedbackRespond tool
+ */
+export interface FeedbackRespondToolParams {
+    /**
+     * The ID of the feedback to respond to
+     */
+    feedbackId: string;
+    /**
+     * The ID of the sender
+     */
+    senderId: string;
+    /**
+     * The name of the sender
+     */
+    senderName: string;
+    /**
+     * The body of the response
+     */
+    body: string;
+    /**
+     * Optional attachments
+     */
+    attachments?: Array<{
+        type: 'image' | 'link' | 'file';
+        path?: string;
+        url?: string;
+        name: string;
+        preview?: string;
+    }>;
+    /**
+     * Optional parent response ID for nested replies
+     */
+    parentId?: string;
+}
+/**
+ * Implementation of the FeedbackRespond tool logic
+ */
+export declare class FeedbackRespondTool extends BaseDeclarativeTool<FeedbackRespondToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: FeedbackRespondToolParams): string | null;
+    protected createInvocation(params: FeedbackRespondToolParams): ToolInvocation<FeedbackRespondToolParams, ToolResult>;
+}

package/dist/tools/collaboration/feedback-respond.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Feedback Respond Tool - Adds a response to a feedback request
+ * Wraps the SDK's cbgroupFeedback.respond() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackRespondTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const groupFeedback_1 = __importDefault(require("../../modules/groupFeedback"));
+class FeedbackRespondToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await groupFeedback_1.default.respond(this.params);
+            const responseInfo = ((_a = response.payload) === null || _a === void 0 ? void 0 : _a.response)
+                ? `Response added with ID: ${response.payload.response.id}`
+                : 'Response added successfully';
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: responseInfo,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding response to feedback: ${errorMessage}`,
+                returnDisplay: `Error adding response to feedback: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the FeedbackRespond tool logic
+ */
+class FeedbackRespondTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(FeedbackRespondTool.Name, 'FeedbackRespond', `Adds a response to a feedback request. You can specify the feedback ID, sender information, response body, optional attachments, and optionally a parent response ID for nested replies.`, types_1.Kind.Edit, {
+            properties: {
+                feedbackId: {
+                    description: 'The ID of the feedback to respond to',
+                    type: 'string',
+                },
+                senderId: {
+                    description: 'The ID of the sender',
+                    type: 'string',
+                },
+                senderName: {
+                    description: 'The name of the sender',
+                    type: 'string',
+                },
+                body: {
+                    description: 'The body of the response',
+                    type: 'string',
+                },
+                attachments: {
+                    description: 'Optional attachments for the response',
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                enum: ['image', 'link', 'file'],
+                            },
+                            path: { type: 'string' },
+                            url: { type: 'string' },
+                            name: { type: 'string' },
+                            preview: { type: 'string' },
+                        },
+                        required: ['type', 'name'],
+                    },
+                },
+                parentId: {
+                    description: 'Optional parent response ID for nested replies',
+                    type: 'string',
+                },
+            },
+            required: ['feedbackId', 'senderId', 'senderName', 'body'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.feedbackId || params.feedbackId.trim() === '') {
+            return "The 'feedbackId' parameter must be non-empty.";
+        }
+        if (!params.senderId || params.senderId.trim() === '') {
+            return "The 'senderId' parameter must be non-empty.";
+        }
+        if (!params.senderName || params.senderName.trim() === '') {
+            return "The 'senderName' parameter must be non-empty.";
+        }
+        if (!params.body || params.body.trim() === '') {
+            return "The 'body' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new FeedbackRespondToolInvocation(params);
+    }
+}
+exports.FeedbackRespondTool = FeedbackRespondTool;
+FeedbackRespondTool.Name = 'feedback_respond';

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

@@ -0,0 +1,37 @@
+/**
+ * Collaboration tools - Group feedback, agent deliberation, and portfolio operations
+ */
+export { FeedbackCreateTool, type FeedbackCreateToolParams } from './feedback-create';
+export { FeedbackGetTool, type FeedbackGetToolParams } from './feedback-get';
+export { FeedbackListTool, type FeedbackListToolParams } from './feedback-list';
+export { FeedbackRespondTool, type FeedbackRespondToolParams } from './feedback-respond';
+export { DeliberationCreateTool, type DeliberationCreateToolParams } from './deliberation-create';
+export { DeliberationGetTool, type DeliberationGetToolParams } from './deliberation-get';
+export { DeliberationListTool, type DeliberationListToolParams } from './deliberation-list';
+export { DeliberationRespondTool, type DeliberationRespondToolParams } from './deliberation-respond';
+export { DeliberationVoteTool, type DeliberationVoteToolParams } from './deliberation-vote';
+export { PortfolioGetTool, type PortfolioGetToolParams } from './portfolio-get';
+export { PortfolioAddTestimonialTool, type PortfolioAddTestimonialToolParams } from './portfolio-add-testimonial';
+export { PortfolioAddKarmaTool, type PortfolioAddKarmaToolParams } from './portfolio-add-karma';
+export { PortfolioAddTalentTool, type PortfolioAddTalentToolParams } from './portfolio-add-talent';
+export { PortfolioEndorseTalentTool, type PortfolioEndorseTalentToolParams } from './portfolio-endorse-talent';
+export { PortfolioGetRankingTool, type PortfolioGetRankingToolParams } from './portfolio-get-ranking';
+import { FeedbackCreateTool } from './feedback-create';
+import { FeedbackGetTool } from './feedback-get';
+import { FeedbackListTool } from './feedback-list';
+import { FeedbackRespondTool } from './feedback-respond';
+import { DeliberationCreateTool } from './deliberation-create';
+import { DeliberationGetTool } from './deliberation-get';
+import { DeliberationListTool } from './deliberation-list';
+import { DeliberationRespondTool } from './deliberation-respond';
+import { DeliberationVoteTool } from './deliberation-vote';
+import { PortfolioGetTool } from './portfolio-get';
+import { PortfolioAddTestimonialTool } from './portfolio-add-testimonial';
+import { PortfolioAddKarmaTool } from './portfolio-add-karma';
+import { PortfolioAddTalentTool } from './portfolio-add-talent';
+import { PortfolioEndorseTalentTool } from './portfolio-endorse-talent';
+import { PortfolioGetRankingTool } from './portfolio-get-ranking';
+/**
+ * All collaboration tools
+ */
+export declare const collaborationTools: (FeedbackCreateTool | FeedbackGetTool | FeedbackListTool | FeedbackRespondTool | DeliberationCreateTool | DeliberationGetTool | DeliberationListTool | DeliberationRespondTool | DeliberationVoteTool | PortfolioGetTool | PortfolioAddTestimonialTool | PortfolioAddKarmaTool | PortfolioAddTalentTool | PortfolioEndorseTalentTool | PortfolioGetRankingTool)[];

package/dist/tools/collaboration/index.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Collaboration tools - Group feedback, agent deliberation, and portfolio operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collaborationTools = exports.PortfolioGetRankingTool = exports.PortfolioEndorseTalentTool = exports.PortfolioAddTalentTool = exports.PortfolioAddKarmaTool = exports.PortfolioAddTestimonialTool = exports.PortfolioGetTool = exports.DeliberationVoteTool = exports.DeliberationRespondTool = exports.DeliberationListTool = exports.DeliberationGetTool = exports.DeliberationCreateTool = exports.FeedbackRespondTool = exports.FeedbackListTool = exports.FeedbackGetTool = exports.FeedbackCreateTool = void 0;
+var feedback_create_1 = require("./feedback-create");
+Object.defineProperty(exports, "FeedbackCreateTool", { enumerable: true, get: function () { return feedback_create_1.FeedbackCreateTool; } });
+var feedback_get_1 = require("./feedback-get");
+Object.defineProperty(exports, "FeedbackGetTool", { enumerable: true, get: function () { return feedback_get_1.FeedbackGetTool; } });
+var feedback_list_1 = require("./feedback-list");
+Object.defineProperty(exports, "FeedbackListTool", { enumerable: true, get: function () { return feedback_list_1.FeedbackListTool; } });
+var feedback_respond_1 = require("./feedback-respond");
+Object.defineProperty(exports, "FeedbackRespondTool", { enumerable: true, get: function () { return feedback_respond_1.FeedbackRespondTool; } });
+var deliberation_create_1 = require("./deliberation-create");
+Object.defineProperty(exports, "DeliberationCreateTool", { enumerable: true, get: function () { return deliberation_create_1.DeliberationCreateTool; } });
+var deliberation_get_1 = require("./deliberation-get");
+Object.defineProperty(exports, "DeliberationGetTool", { enumerable: true, get: function () { return deliberation_get_1.DeliberationGetTool; } });
+var deliberation_list_1 = require("./deliberation-list");
+Object.defineProperty(exports, "DeliberationListTool", { enumerable: true, get: function () { return deliberation_list_1.DeliberationListTool; } });
+var deliberation_respond_1 = require("./deliberation-respond");
+Object.defineProperty(exports, "DeliberationRespondTool", { enumerable: true, get: function () { return deliberation_respond_1.DeliberationRespondTool; } });
+var deliberation_vote_1 = require("./deliberation-vote");
+Object.defineProperty(exports, "DeliberationVoteTool", { enumerable: true, get: function () { return deliberation_vote_1.DeliberationVoteTool; } });
+var portfolio_get_1 = require("./portfolio-get");
+Object.defineProperty(exports, "PortfolioGetTool", { enumerable: true, get: function () { return portfolio_get_1.PortfolioGetTool; } });
+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_add_karma_1 = require("./portfolio-add-karma");
+Object.defineProperty(exports, "PortfolioAddKarmaTool", { enumerable: true, get: function () { return portfolio_add_karma_1.PortfolioAddKarmaTool; } });
+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_ranking_1 = require("./portfolio-get-ranking");
+Object.defineProperty(exports, "PortfolioGetRankingTool", { enumerable: true, get: function () { return portfolio_get_ranking_1.PortfolioGetRankingTool; } });
+// Create instances for convenience
+const feedback_create_2 = require("./feedback-create");
+const feedback_get_2 = require("./feedback-get");
+const feedback_list_2 = require("./feedback-list");
+const feedback_respond_2 = require("./feedback-respond");
+const deliberation_create_2 = require("./deliberation-create");
+const deliberation_get_2 = require("./deliberation-get");
+const deliberation_list_2 = require("./deliberation-list");
+const deliberation_respond_2 = require("./deliberation-respond");
+const deliberation_vote_2 = require("./deliberation-vote");
+const portfolio_get_2 = require("./portfolio-get");
+const portfolio_add_testimonial_2 = require("./portfolio-add-testimonial");
+const portfolio_add_karma_2 = require("./portfolio-add-karma");
+const portfolio_add_talent_2 = require("./portfolio-add-talent");
+const portfolio_endorse_talent_2 = require("./portfolio-endorse-talent");
+const portfolio_get_ranking_2 = require("./portfolio-get-ranking");
+/**
+ * All collaboration tools
+ */
+exports.collaborationTools = [
+    new feedback_create_2.FeedbackCreateTool(),
+    new feedback_get_2.FeedbackGetTool(),
+    new feedback_list_2.FeedbackListTool(),
+    new feedback_respond_2.FeedbackRespondTool(),
+    new deliberation_create_2.DeliberationCreateTool(),
+    new deliberation_get_2.DeliberationGetTool(),
+    new deliberation_list_2.DeliberationListTool(),
+    new deliberation_respond_2.DeliberationRespondTool(),
+    new deliberation_vote_2.DeliberationVoteTool(),
+    new portfolio_get_2.PortfolioGetTool(),
+    new portfolio_add_testimonial_2.PortfolioAddTestimonialTool(),
+    new portfolio_add_karma_2.PortfolioAddKarmaTool(),
+    new portfolio_add_talent_2.PortfolioAddTalentTool(),
+    new portfolio_endorse_talent_2.PortfolioEndorseTalentTool(),
+    new portfolio_get_ranking_2.PortfolioGetRankingTool(),
+];

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

@@ -0,0 +1,32 @@
+/**
+ * Portfolio Add Karma Tool - Adds karma points to an agent
+ * Wraps the SDK's agentPortfolio.addKarma() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the PortfolioAddKarma tool
+ */
+export interface PortfolioAddKarmaToolParams {
+    /**
+     * The ID of the agent receiving karma
+     */
+    to_agent_id: string;
+    /**
+     * The amount of karma to add (can be negative)
+     */
+    amount: number;
+    /**
+     * Optional reason for the karma change
+     */
+    reason?: string;
+}
+/**
+ * Implementation of the PortfolioAddKarma tool logic
+ */
+export declare class PortfolioAddKarmaTool extends BaseDeclarativeTool<PortfolioAddKarmaToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: PortfolioAddKarmaToolParams): string | null;
+    protected createInvocation(params: PortfolioAddKarmaToolParams): ToolInvocation<PortfolioAddKarmaToolParams, ToolResult>;
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Portfolio Add Karma Tool - Adds karma points to an agent
+ * Wraps the SDK's agentPortfolio.addKarma() method
+ */
+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 PortfolioAddKarmaToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await agentPortfolio_1.default.addKarma(this.params.to_agent_id, this.params.amount, this.params.reason);
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error adding karma: ${errorMsg}`,
+                    returnDisplay: `Error adding karma: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const responseData = JSON.stringify(response.data, null, 2);
+            return {
+                llmContent: `Successfully added ${this.params.amount} karma to agent ${this.params.to_agent_id}:\n${responseData}`,
+                returnDisplay: `Successfully added ${this.params.amount} karma to agent ${this.params.to_agent_id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding karma: ${errorMessage}`,
+                returnDisplay: `Error adding karma: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the PortfolioAddKarma tool logic
+ */
+class PortfolioAddKarmaTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(PortfolioAddKarmaTool.Name, 'PortfolioAddKarma', `Adds karma points to an agent's portfolio. Karma is a reputation metric that can be positive or negative based on the agent's contributions and behavior.`, types_1.Kind.Edit, {
+            properties: {
+                to_agent_id: {
+                    description: 'The ID of the agent receiving karma',
+                    type: 'string',
+                },
+                amount: {
+                    description: 'The amount of karma to add (can be negative for deductions)',
+                    type: 'number',
+                },
+                reason: {
+                    description: 'Optional reason for the karma change',
+                    type: 'string',
+                },
+            },
+            required: ['to_agent_id', 'amount'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.to_agent_id || params.to_agent_id.trim() === '') {
+            return "The 'to_agent_id' parameter must be non-empty.";
+        }
+        if (typeof params.amount !== 'number') {
+            return "The 'amount' parameter must be a number.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new PortfolioAddKarmaToolInvocation(params);
+    }
+}
+exports.PortfolioAddKarmaTool = PortfolioAddKarmaTool;
+PortfolioAddKarmaTool.Name = 'portfolio_add_karma';

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

@@ -0,0 +1,28 @@
+/**
+ * Portfolio Add Talent Tool - Adds a talent/skill to an agent's portfolio
+ * Wraps the SDK's agentPortfolio.addTalent() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the PortfolioAddTalent tool
+ */
+export interface PortfolioAddTalentToolParams {
+    /**
+     * The name of the talent/skill
+     */
+    name: string;
+    /**
+     * Optional description of the talent
+     */
+    description?: string;
+}
+/**
+ * Implementation of the PortfolioAddTalent tool logic
+ */
+export declare class PortfolioAddTalentTool extends BaseDeclarativeTool<PortfolioAddTalentToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: PortfolioAddTalentToolParams): string | null;
+    protected createInvocation(params: PortfolioAddTalentToolParams): ToolInvocation<PortfolioAddTalentToolParams, ToolResult>;
+}