@openserv-labs/sdk 1.0.0

package/dist/agent.js

@@ -0,0 +1,643 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const axios_1 = __importDefault(require("axios"));
+const compression_1 = __importDefault(require("compression"));
+const express_1 = __importDefault(require("express"));
+const express_async_router_1 = require("express-async-router");
+const helmet_1 = __importDefault(require("helmet"));
+const hpp_1 = __importDefault(require("hpp"));
+const logger_1 = require("./logger");
+const types_1 = require("./types");
+const http_errors_1 = require("http-errors");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const openai_1 = __importDefault(require("openai"));
+const capability_1 = require("./capability");
+const PLATFORM_URL = process.env.OPENSERV_API_URL || 'https://api.openserv.ai';
+const RUNTIME_URL = process.env.OPENSERV_RUNTIME_URL || 'https://agents.openserv.ai';
+const DEFAULT_PORT = Number.parseInt(process.env.PORT || '') || 7378;
+class Agent {
+    options;
+    /**
+     * The Express application instance used to handle HTTP requests.
+     * This is initialized in the constructor and used to set up middleware and routes.
+     * @private
+     */
+    app;
+    /**
+     * The HTTP server instance created from the Express application.
+     * This is initialized when start() is called and used to listen for incoming requests.
+     * @private
+     */
+    server = null;
+    /**
+     * The Express router instance used to define API routes.
+     * This handles routing for health checks, tool execution, and action handling.
+     * @private
+     */
+    router;
+    /**
+     * The port number the server will listen on.
+     * Defaults to DEFAULT_PORT (7378) if not specified in options.
+     * @private
+     */
+    port;
+    /**
+     * The system prompt used for OpenAI chat completions.
+     * This defines the base behavior and context for the agent.
+     * @protected
+     */
+    systemPrompt;
+    /**
+     * Array of capabilities (tools) available to the agent.
+     * Each capability is an instance of the Capability class with a name, description, schema, and run function.
+     * @protected
+     */
+    tools = [];
+    /**
+     * The OpenServ API key used for authentication.
+     * Can be provided in options or via OPENSERV_API_KEY environment variable.
+     * @private
+     */
+    apiKey;
+    /**
+     * Axios instance for making requests to the OpenServ API.
+     * Pre-configured with base URL and authentication headers.
+     * @private
+     */
+    apiClient;
+    /**
+     * Axios instance for making requests to the OpenServ Runtime API.
+     * Pre-configured with base URL and authentication headers.
+     * @protected
+     */
+    runtimeClient;
+    /**
+     * OpenAI client instance.
+     * Lazily initialized when needed using the provided API key.
+     * @protected
+     */
+    _openai;
+    /**
+     * Getter that converts the agent's tools into OpenAI function calling format.
+     * Used when making chat completion requests to OpenAI.
+     * @private
+     * @returns Array of ChatCompletionTool objects
+     */
+    get openAiTools() {
+        return this.tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema)
+            }
+        }));
+    }
+    /**
+     * Getter that provides access to the OpenAI client instance.
+     * Lazily initializes the client with the API key from options or environment.
+     * @private
+     * @throws {Error} If no OpenAI API key is available
+     * @returns {OpenAI} The OpenAI client instance
+     */
+    get openai() {
+        if (!this._openai) {
+            const apiKey = this.options.openaiApiKey || process.env.OPENAI_API_KEY;
+            if (!apiKey) {
+                throw new Error('OpenAI API key is required for process(). Please provide it in options or set OPENAI_API_KEY environment variable.');
+            }
+            this._openai = new openai_1.default({ apiKey });
+        }
+        return this._openai;
+    }
+    /**
+     * Creates a new Agent instance.
+     * Sets up the Express application, middleware, and routes.
+     * Initializes API clients with appropriate authentication.
+     *
+     * @param {AgentOptions} options - Configuration options for the agent
+     * @throws {Error} If OpenServ API key is not provided in options or environment
+     */
+    constructor(options) {
+        this.options = options;
+        this.app = (0, express_1.default)();
+        this.router = (0, express_async_router_1.AsyncRouter)();
+        this.port = this.options.port || DEFAULT_PORT;
+        this.systemPrompt = this.options.systemPrompt;
+        this.apiKey = this.options.apiKey || process.env.OPENSERV_API_KEY || '';
+        if (!this.apiKey) {
+            throw new Error('OpenServ API key is required. Please provide it in options or set OPENSERV_API_KEY environment variable.');
+        }
+        // Initialize API client
+        this.apiClient = axios_1.default.create({
+            baseURL: PLATFORM_URL,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-openserv-key': this.apiKey
+            }
+        });
+        // Initialize runtime client
+        this.runtimeClient = axios_1.default.create({
+            baseURL: `${RUNTIME_URL}/runtime`,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-openserv-key': this.apiKey
+            }
+        });
+        this.app.use(express_1.default.json());
+        this.app.use(express_1.default.urlencoded({ extended: false }));
+        this.app.use((0, hpp_1.default)());
+        this.app.use((0, helmet_1.default)());
+        this.app.use((0, compression_1.default)());
+        this.setupRoutes();
+    }
+    /**
+     * Adds a single capability (tool) to the agent.
+     * Each capability must have a unique name and defines a function that can be called via the API.
+     *
+     * @template S - The Zod schema type for the capability's parameters
+     * @param {Object} capability - The capability configuration
+     * @param {string} capability.name - Unique name for the capability
+     * @param {string} capability.description - Description of what the capability does
+     * @param {S} capability.schema - Zod schema defining the capability's parameters
+     * @param {Function} capability.run - Function that implements the capability's behavior
+     * @param {Object} capability.run.params - Parameters for the run function
+     * @param {z.infer<S>} capability.run.params.args - Validated arguments matching the schema
+     * @param {z.infer<typeof actionSchema>} [capability.run.params.action] - Optional action context
+     * @param {ChatCompletionMessageParam[]} capability.run.messages - Chat message history
+     * @returns {this} The agent instance for method chaining
+     * @throws {Error} If a capability with the same name already exists
+     */
+    addCapability({ name, description, schema, run }) {
+        // Validate tool name uniqueness
+        if (this.tools.some(tool => tool.name === name)) {
+            throw new Error(`Tool with name "${name}" already exists`);
+        }
+        this.tools.push(new capability_1.Capability(name, description, schema, run));
+        return this;
+    }
+    /**
+     * Adds multiple capabilities (tools) to the agent at once.
+     * Each capability must have a unique name and not conflict with existing capabilities.
+     *
+     * @template T - Tuple of Zod schema types for the capabilities' parameters
+     * @param {Object} capabilities - Array of capability configurations
+     * @param {string} capabilities[].name - Unique name for each capability
+     * @param {string} capabilities[].description - Description of what each capability does
+     * @param {T[number]} capabilities[].schema - Zod schema defining each capability's parameters
+     * @param {Function} capabilities[].run - Function that implements each capability's behavior
+     * @returns {this} The agent instance for method chaining
+     * @throws {Error} If any capability has a name that already exists
+     */
+    addCapabilities(capabilities) {
+        capabilities.forEach(capability => {
+            this.addCapability(capability);
+        });
+        return this;
+    }
+    /**
+     * Gets files in a workspace.
+     *
+     * @param {GetFilesParams} params - Parameters for the file retrieval
+     * @param {number} params.workspaceId - ID of the workspace to get files from
+     * @returns {Promise<any>} The files in the workspace
+     */
+    async getFiles(params) {
+        const response = await this.apiClient.get(`/workspaces/${params.workspaceId}/files`);
+        return response.data;
+    }
+    /**
+     * Uploads a file to a workspace.
+     *
+     * @param {UploadFileParams} params - Parameters for the file upload
+     * @param {number} params.workspaceId - ID of the workspace to upload to
+     * @param {string} params.path - Path where the file should be stored
+     * @param {number[]|number|null} [params.taskIds] - Optional task IDs to associate with the file
+     * @param {boolean} [params.skipSummarizer] - Whether to skip file summarization
+     * @param {Buffer|string} params.file - The file content to upload
+     * @returns {Promise<any>} The uploaded file details
+     */
+    async uploadFile(params) {
+        const formData = new FormData();
+        formData.append('path', params.path);
+        if (params.taskIds) {
+            formData.append('taskIds', JSON.stringify(params.taskIds));
+        }
+        if (params.skipSummarizer !== undefined) {
+            formData.append('skipSummarizer', params.skipSummarizer.toString());
+        }
+        // Convert Buffer or string to Blob for FormData
+        const fileBlob = params.file instanceof Buffer
+            ? new Blob([params.file])
+            : new Blob([params.file], { type: 'text/plain' });
+        formData.append('file', fileBlob);
+        const response = await this.apiClient.post(`/workspaces/${params.workspaceId}/file`, formData, {
+            headers: {
+                'Content-Type': 'multipart/form-data'
+            }
+        });
+        return response.data;
+    }
+    /**
+     * Marks a task as errored.
+     *
+     * @param {MarkTaskAsErroredParams} params - Parameters for marking the task as errored
+     * @param {number} params.workspaceId - ID of the workspace containing the task
+     * @param {number} params.taskId - ID of the task to mark as errored
+     * @param {string} params.error - Error message describing what went wrong
+     * @returns {Promise<any>} The updated task details
+     */
+    async markTaskAsErrored(params) {
+        const response = await this.apiClient.post(`/workspaces/${params.workspaceId}/tasks/${params.taskId}/error`, {
+            error: params.error
+        });
+        return response.data;
+    }
+    /**
+     * Completes a task with the specified output.
+     *
+     * @param {CompleteTaskParams} params - Parameters for completing the task
+     * @param {number} params.workspaceId - ID of the workspace containing the task
+     * @param {number} params.taskId - ID of the task to complete
+     * @param {string} params.output - Output or result of the completed task
+     * @returns {Promise<any>} The completed task details
+     */
+    async completeTask(params) {
+        const response = await this.apiClient.put(`/workspaces/${params.workspaceId}/tasks/${params.taskId}/complete`, {
+            output: params.output
+        });
+        return response.data;
+    }
+    /**
+     * Sends a chat message from the agent.
+     *
+     * @param {SendChatMessageParams} params - Parameters for sending the chat message
+     * @param {number} params.workspaceId - ID of the workspace where the chat is happening
+     * @param {number} params.agentId - ID of the agent sending the message
+     * @param {string} params.message - Content of the message to send
+     * @returns {Promise<any>} The sent message details
+     */
+    async sendChatMessage(params) {
+        const response = await this.apiClient.post(`/workspaces/${params.workspaceId}/agent-chat/${params.agentId}/message`, {
+            message: params.message
+        });
+        return response.data;
+    }
+    /**
+     * Gets detailed information about a specific task.
+     *
+     * @param {GetTaskDetailParams} params - Parameters for getting task details
+     * @param {number} params.workspaceId - ID of the workspace containing the task
+     * @param {number} params.taskId - ID of the task to get details for
+     * @returns {Promise<any>} The detailed task information
+     */
+    async getTaskDetail(params) {
+        const response = await this.apiClient.get(`/workspaces/${params.workspaceId}/tasks/${params.taskId}/detail`);
+        return response.data;
+    }
+    /**
+     * Gets a list of agents in a workspace.
+     *
+     * @param {GetAgentsParams} params - Parameters for getting agents
+     * @param {number} params.workspaceId - ID of the workspace to get agents from
+     * @returns {Promise<any>} List of agents in the workspace
+     */
+    async getAgents(params) {
+        const response = await this.apiClient.get(`/workspaces/${params.workspaceId}/agents`);
+        return response.data;
+    }
+    /**
+     * Gets a list of tasks in a workspace.
+     *
+     * @param {GetTasksParams} params - Parameters for getting tasks
+     * @param {number} params.workspaceId - ID of the workspace to get tasks from
+     * @returns {Promise<any>} List of tasks in the workspace
+     */
+    async getTasks(params) {
+        const response = await this.apiClient.get(`/workspaces/${params.workspaceId}/tasks`);
+        return response.data;
+    }
+    /**
+     * Creates a new task in a workspace.
+     *
+     * @param {CreateTaskParams} params - Parameters for creating the task
+     * @param {number} params.workspaceId - ID of the workspace to create the task in
+     * @param {number} params.assignee - ID of the agent to assign the task to
+     * @param {string} params.description - Short description of the task
+     * @param {string} params.body - Detailed body/content of the task
+     * @param {string} params.input - Input data for the task
+     * @param {string} params.expectedOutput - Expected output format or content
+     * @param {number[]} params.dependencies - IDs of tasks that this task depends on
+     * @returns {Promise<any>} The created task details
+     */
+    async createTask(params) {
+        const response = await this.apiClient.post(`/workspaces/${params.workspaceId}/task`, {
+            assignee: params.assignee,
+            description: params.description,
+            body: params.body,
+            input: params.input,
+            expectedOutput: params.expectedOutput,
+            dependencies: params.dependencies
+        });
+        return response.data;
+    }
+    /**
+     * Adds a log entry to a task.
+     *
+     * @param {AddLogToTaskParams} params - Parameters for adding the log
+     * @param {number} params.workspaceId - ID of the workspace containing the task
+     * @param {number} params.taskId - ID of the task to add the log to
+     * @param {'info'|'warning'|'error'} params.severity - Severity level of the log
+     * @param {'text'|'openai-message'} params.type - Type of log entry
+     * @param {string|object} params.body - Content of the log entry
+     * @returns {Promise<any>} The created log entry details
+     */
+    async addLogToTask(params) {
+        const response = await this.apiClient.post(`/workspaces/${params.workspaceId}/tasks/${params.taskId}/log`, {
+            severity: params.severity,
+            type: params.type,
+            body: params.body
+        });
+        return response.data;
+    }
+    /**
+     * Requests human assistance for a task.
+     *
+     * @param {RequestHumanAssistanceParams} params - Parameters for requesting assistance
+     * @param {number} params.workspaceId - ID of the workspace containing the task
+     * @param {number} params.taskId - ID of the task needing assistance
+     * @param {'text'|'project-manager-plan-review'} params.type - Type of assistance needed
+     * @param {string|object} params.question - Question or request for the human
+     * @param {object} [params.agentDump] - Optional agent state/context information
+     * @returns {Promise<any>} The created assistance request details
+     */
+    async requestHumanAssistance(params) {
+        const response = await this.apiClient.post(`/workspaces/${params.workspaceId}/tasks/${params.taskId}/human-assistance`, {
+            type: params.type,
+            question: params.question,
+            agentDump: params.agentDump
+        });
+        return response.data;
+    }
+    /**
+     * Updates the status of a task.
+     *
+     * @param {UpdateTaskStatusParams} params - Parameters for updating the status
+     * @param {number} params.workspaceId - ID of the workspace containing the task
+     * @param {number} params.taskId - ID of the task to update
+     * @param {TaskStatus} params.status - New status for the task
+     * @returns {Promise<any>} The updated task details
+     */
+    async updateTaskStatus(params) {
+        const response = await this.apiClient.put(`/workspaces/${params.workspaceId}/tasks/${params.taskId}/status`, {
+            status: params.status
+        });
+        return response.data;
+    }
+    /**
+     * Processes a conversation with OpenAI, handling tool calls iteratively until completion.
+     *
+     * @param {ProcessParams} params - Parameters for processing the conversation
+     * @param {ChatCompletionMessageParam[]} params.messages - The conversation history
+     * @returns {Promise<ChatCompletion>} The final response from OpenAI
+     * @throws {Error} If no response is received from OpenAI or max iterations are reached
+     */
+    async process({ messages }) {
+        const currentMessages = [...messages];
+        let completion = null;
+        let iterationCount = 0;
+        const MAX_ITERATIONS = 10;
+        while (iterationCount < MAX_ITERATIONS) {
+            completion = await this.openai.chat.completions.create({
+                model: 'gpt-4o',
+                messages: currentMessages,
+                tools: this.openAiTools
+            });
+            if (!completion.choices?.length || !completion.choices[0]?.message) {
+                throw new Error('No response from OpenAI');
+            }
+            const lastMessage = completion.choices[0].message;
+            // If there are no tool calls, we're done
+            if (!lastMessage.tool_calls?.length) {
+                return completion;
+            }
+            // Process each tool call
+            const toolResults = await Promise.all(lastMessage.tool_calls.map(async (toolCall) => {
+                // We know the function exists because we provided the tools
+                const { name, arguments: args } = toolCall.function;
+                const parsedArgs = JSON.parse(args);
+                try {
+                    // Call the corresponding method on this class with named parameters
+                    const result = await this[name](parsedArgs);
+                    return {
+                        tool_call_id: toolCall.id,
+                        role: 'tool',
+                        name,
+                        content: JSON.stringify(result)
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                    logger_1.logger.error({ error, toolCall }, 'Error executing tool call');
+                    return {
+                        tool_call_id: toolCall.id,
+                        role: 'tool',
+                        name,
+                        content: JSON.stringify({ error: errorMessage })
+                    };
+                }
+            }));
+            // Add the assistant's message and tool results to the conversation
+            currentMessages.push(lastMessage, ...toolResults);
+            iterationCount++;
+        }
+        throw new Error('Max iterations reached without completion');
+    }
+    /**
+     * Handle a task execution request
+     * This method can be overridden by extending classes to customize task handling
+     * @protected
+     */
+    async doTask(action) {
+        const messages = [
+            {
+                role: 'system',
+                content: this.systemPrompt
+            }
+        ];
+        if (action.task?.description) {
+            messages.push({
+                role: 'user',
+                content: action.task.description
+            });
+        }
+        try {
+            await this.runtimeClient.post('/execute', {
+                tools: this.tools.map(convertToolToJsonSchema),
+                messages,
+                action
+            });
+        }
+        catch (error) {
+            if (action.task) {
+                await this.markTaskAsErrored({
+                    workspaceId: action.workspace.id,
+                    taskId: action.task.id,
+                    error: error instanceof Error ? error.message : 'Unknown error occurred'
+                });
+            }
+            logger_1.logger.error({ error }, 'Failed to forward action to runtime agent');
+            throw error;
+        }
+    }
+    /**
+     * Handle a chat message response request
+     * This method can be overridden by extending classes to customize chat handling
+     * @protected
+     */
+    async respondToChat(action) {
+        const messages = [
+            {
+                role: 'system',
+                content: this.systemPrompt
+            }
+        ];
+        if (action.messages) {
+            action.messages.forEach((msg) => {
+                messages.push({
+                    role: msg.author === 'user' ? 'user' : 'assistant',
+                    content: msg.message
+                });
+            });
+        }
+        try {
+            await this.runtimeClient.post('/chat', {
+                tools: this.tools.map(convertToolToJsonSchema),
+                messages,
+                action
+            });
+        }
+        catch (error) {
+            await this.sendChatMessage({
+                workspaceId: action.workspace.id,
+                agentId: action.me.id,
+                message: error instanceof Error ? error.message : 'Unknown error occurred'
+            });
+            logger_1.logger.error({ error }, 'Failed to forward action to runtime agent');
+            throw error;
+        }
+    }
+    /**
+     * Handles execution of a specific tool/capability.
+     *
+     * @param {Object} req - The request object
+     * @param {Object} req.params - Request parameters
+     * @param {string} req.params.toolName - Name of the tool to execute
+     * @param {Object} req.body - Request body
+     * @param {z.infer<z.ZodTypeAny>} [req.body.args] - Arguments for the tool
+     * @param {z.infer<typeof actionSchema>} [req.body.action] - Action context
+     * @returns {Promise<{result: string}>} The result of the tool execution
+     * @throws {BadRequest} If tool name is missing or tool is not found
+     * @throws {Error} If tool execution fails
+     */
+    async handleToolRoute(req) {
+        if (!('toolName' in req.params)) {
+            throw new http_errors_1.BadRequest('Tool name is required');
+        }
+        const tool = this.tools.find(t => t.name === req.params.toolName);
+        if (!tool) {
+            throw new http_errors_1.BadRequest(`Tool "${req.params.toolName}" not found`);
+        }
+        try {
+            const args = await tool.schema.parseAsync(req.body?.args);
+            const result = await tool.run.call(this, { args, action: req.body.action }, []);
+            return { result };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            throw new Error(errorMessage);
+        }
+    }
+    /**
+     * Handles the root route for task execution and chat message responses.
+     *
+     * @param {Object} req - The request object
+     * @param {unknown} req.body - Request body to be parsed as an action
+     * @returns {Promise<void>}
+     * @throws {Error} If action type is invalid
+     */
+    async handleRootRoute(req) {
+        const action = await types_1.actionSchema.parseAsync(req.body);
+        if (action.type === 'do-task') {
+            this.doTask(action);
+        }
+        else if (action.type === 'respond-chat-message') {
+            this.respondToChat(action);
+        }
+        else
+            throw new Error('Invalid action type');
+    }
+    /**
+     * Sets up the Express routes for the agent's HTTP server.
+     * Configures health check endpoint and routes for tool execution.
+     * @private
+     */
+    setupRoutes() {
+        this.router.get('/health', async (_req, res) => {
+            res.status(200).json({ status: 'ok', uptime: process.uptime() });
+        });
+        this.router.post('/', async (req) => {
+            return this.handleRootRoute({ body: req.body });
+        });
+        this.router.post('/tools/:toolName', async (req) => {
+            const { toolName } = req.params;
+            if (!toolName) {
+                throw new http_errors_1.BadRequest('Tool name is required');
+            }
+            return this.handleToolRoute({
+                params: { toolName },
+                body: req.body
+            });
+        });
+        this.app.use('/', this.router);
+    }
+    /**
+     * Starts the agent's HTTP server.
+     *
+     * @returns {Promise<void>} Resolves when the server has started
+     * @throws {Error} If server fails to start
+     */
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = this.app.listen(this.port, () => {
+                logger_1.logger.info(`Agent server started on port ${this.port}`);
+                resolve();
+            });
+            this.server.on('error', reject);
+        });
+    }
+    /**
+     * Stops the agent's HTTP server.
+     *
+     * @returns {Promise<void>} Resolves when the server has stopped
+     */
+    async stop() {
+        if (!this.server)
+            return;
+        return new Promise(resolve => {
+            this.server?.close(() => resolve());
+        });
+    }
+}
+exports.Agent = Agent;
+function convertToolToJsonSchema(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        schema: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema)
+    };
+}

package/dist/capability.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions';
+import type { CapabilityFuncParams } from './types';
+export declare class Capability<Schema extends z.ZodTypeAny> {
+    readonly name: string;
+    readonly description: string;
+    readonly schema: Schema;
+    readonly run: (params: CapabilityFuncParams<Schema>, messages: ChatCompletionMessageParam[]) => string | Promise<string>;
+    constructor(name: string, description: string, schema: Schema, run: (params: CapabilityFuncParams<Schema>, messages: ChatCompletionMessageParam[]) => string | Promise<string>);
+}
+//# sourceMappingURL=capability.d.ts.map

package/dist/capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../src/capability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAA;AACnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEnD,qBAAa,UAAU,CAAC,MAAM,SAAS,CAAC,CAAC,UAAU;aAE/B,IAAI,EAAE,MAAM;aACZ,WAAW,EAAE,MAAM;aACnB,MAAM,EAAE,MAAM;aACd,GAAG,EAAE,CACnB,MAAM,EAAE,oBAAoB,CAAC,MAAM,CAAC,EACpC,QAAQ,EAAE,0BAA0B,EAAE,KACnC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;gBANb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,CACnB,MAAM,EAAE,oBAAoB,CAAC,MAAM,CAAC,EACpC,QAAQ,EAAE,0BAA0B,EAAE,KACnC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAEhC"}

package/dist/capability.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Capability = void 0;
+class Capability {
+    name;
+    description;
+    schema;
+    run;
+    constructor(name, description, schema, run) {
+        this.name = name;
+        this.description = description;
+        this.schema = schema;
+        this.run = run;
+    }
+}
+exports.Capability = Capability;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { Agent } from './agent';
+export type { AgentOptions } from './agent';
+export { Capability } from './capability';
+export type { TaskStatus, GetFilesParams, UploadFileParams, MarkTaskAsErroredParams, CompleteTaskParams, SendChatMessageParams, GetTaskDetailParams, GetAgentsParams, GetTasksParams, CreateTaskParams, AddLogToTaskParams, RequestHumanAssistanceParams, UpdateTaskStatusParams, ProcessParams, CapabilityFuncParams } from './types';
+export { actionSchema, doTaskActionSchema, respondChatMessageActionSchema, taskStatusSchema, agentKind } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC,YAAY,EACV,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,4BAA4B,EAC5B,sBAAsB,EACtB,aAAa,EACb,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAEhB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,8BAA8B,EAC9B,gBAAgB,EAChB,SAAS,EACV,MAAM,SAAS,CAAA"}