psadk 1.1.0

package/build/module/lib/PSAgent.js

@@ -0,0 +1,992 @@
+import { PSAgentTool } from "./PSAgentTool";
+import { z } from "zod/v4";
+import { v4 as uuidv4 } from 'uuid'; // For generating unique IDs
+import os from "os";
+import { PSAgentTask } from "./PSAgentTask";
+import { DefaultRequestHandler, InMemoryTaskStore, } from "@a2a-js/sdk/server";
+import { A2AExpressApp } from "@a2a-js/sdk/server/express";
+import express from "express";
+import fs from "node:fs";
+import path from "node:path";
+import yaml from "yaml";
+import { PSAI } from "./PSAI";
+// fetch-retry can also wrap Node.js's native fetch API implementation:
+const fetch = require('fetch-retry')(global.fetch);
+export async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * PSAgent class to manage AI agents with tools and tasks
+ * Implements AgentExecutor interface from A2A SDK
+ * Supports starting, resuming, cancelling agents and executing tools
+ * Manages agent state, tools, tasks and interactions with A2A platform
+ * Includes methods for A2A server setup and event fetching
+ *
+ * uses the token from config if not PS_API_TOKEN env variable
+ * adds x-client-id, x-project-id, x-workspace-id from env variables
+ * PS_CLIENT_ID, PS_PROJECT_ID, PS_WORKSPACE_ID respectively for authentication headers
+ *
+ * @example
+ * ```typescript
+ * import { PSAI, PSAgent, PSAgentLogger } from 'psadk';
+ * import dotenv from 'dotenv';
+ * dotenv.config();
+ * async function main() {
+ *   const token = await PSAI.getServiceToken({});
+ *   const HelloAgent = new PSAgent({
+ *     name: 'HelloAgent',
+ *     description: 'A simple hello world agent',
+ *     system_prompt: 'You are a helpful assistant that greets users.',
+ *     model: 'gpt-5',
+ *     tools: [],
+ *     log: new PSAgentLogger({ level: 'info' }),
+ *     token: token,
+ *     port: 41241,
+ *   });
+ *   const { app, port } = HelloAgent.getServer();
+ *   app.listen(port, () => {
+ *     console.log('HelloAgent is running on http://localhost:${port}');
+ *   });
+ * }
+ * main();
+ * ```
+ * @see PSAgentConfig, PSAgentTool, PSAgentTask
+ *
+ * @see
+ * https://dev.lionis.ai/docs/api/v1/agents/create-agent
+ * https://pscode.lioncloud.net/ai-tso/psadk_samples
+ * https://a2aproject.com/docs/getting-started/quickstart
+ *
+ */
+export class PSAgent {
+    config;
+    tools = [];
+    tasks = [];
+    agentId;
+    correlationId;
+    log;
+    cancelledTasks = new Set();
+    cancelTask = async (taskId, _eventBus) => {
+        this.cancelledTasks.add(taskId);
+        // The execute loop is responsible for publishing the final state
+    };
+    /**
+     * create a new PSAgent with the given config
+     * @param config PSAgentConfig with optional logger
+     */
+    constructor(config) {
+        this.config = config;
+        this.log = config.log;
+    }
+    /**
+     * Get the Agent Class
+     * @returns Agent class from config or default "LlmAgent"
+     */
+    get AgentClass() {
+        return this.config.agent_class || "LlmAgent";
+    }
+    /**
+     * Get the Name of the Agent
+     *
+     * @returns Name of the agent from config
+     */
+    get Name() {
+        return this.config.name;
+    }
+    /**
+     * Get the Description of the Agent
+     * @returns Description of the agent from config
+     */
+    get Description() {
+        return this.config.description;
+    }
+    /**
+     * Get the Instruction(System Prompt) of the Agent
+     * @returns Instruction(System prompt) of the agent from config
+     */
+    get Instruction() {
+        return this.config.instruction;
+    }
+    /**
+     * Get the Model of the Agent
+     * @returns Model of the agent from config
+     */
+    get Model() {
+        return this.config.model;
+    }
+    /**
+     * Get the Input Schema of the Agent
+     * @returns Input schema of the agent from config
+     */
+    get InputSchema() {
+        return this.config.input_schema;
+    }
+    /**
+     * Get the Output Schema of the Agent
+     * @returns Output schema of the agent from config
+     */
+    get OutputSchema() {
+        return this.config.output_schema;
+    }
+    /**
+     * Get the Token for the Agent
+     * @returns Token of the agent from config
+     */
+    get Token() {
+        return this.config.token;
+    }
+    /**
+     * Set the Token for the Agent
+     * @param value Token string to set in config
+     */
+    set Token(value) {
+        this.config.token = value;
+    }
+    /**
+     * Get the Tools for the Agent
+     * Includes both config tools and dynamically added tools
+     * @returns Array of PSAgentTool instances
+     */
+    get Tools() {
+        return [...this.config.tools || [], ...this.tools];
+    }
+    /**
+     * Get the Tasks for the Agent
+     * Includes both config tasks and dynamically added tasks
+     * @returns Array of PSAgentTask instances
+     */
+    get Tasks() {
+        return [...this.config.tasks || [], ...this.tasks];
+    }
+    /**
+     * Get the Agent ID after starting the agent
+     * @returns Agent ID string or undefined if not started
+     */
+    get AgentId() {
+        return this.agentId;
+    }
+    /**
+     * Get the Correlation ID after starting the agent
+     * @returns Correlation ID string or undefined if not started
+     */
+    get CorrelationId() {
+        return this.correlationId;
+    }
+    /**
+     * Add tools to the agent dynamically
+     * @param tool PSAgentTool to add to the agent
+     */
+    addTool(tool) {
+        if (!this.tools) {
+            this.tools = [];
+        }
+        let toolIndex = this.config.tools?.findIndex(t => t.Name === tool.Name) || -1;
+        if (toolIndex !== -1) {
+            throw new Error(`Tool with name ${tool.Name} already exists in config`);
+        }
+        toolIndex = this.tools.findIndex(t => t.Name === tool.Name);
+        if (toolIndex !== -1) {
+            throw new Error(`Tool with name ${tool.Name} already exists in agent`);
+        }
+        else {
+            this.tools.push(tool);
+        }
+    }
+    // get token from config or environment variable
+    async getToken() {
+        if (this.config.token)
+            return this.config.token;
+        if (this.config.getToken)
+            return await this.config.getToken();
+        return process.env.PS_API_TOKEN || '';
+    }
+    // Private method to get auth headers
+    // uses the token from config if not PS_API_TOKEN env variable
+    // adds x-client-id, x-project-id, x-workspace-id from env variables
+    // PS_CLIENT_ID, PS_PROJECT_ID, PS_WORKSPACE_ID respectively
+    async getAuthHeaders() {
+        const headers = {};
+        headers['Authorization'] = `Bearer ${await this.getToken()}`;
+        headers["x-client-id"] = process.env.PS_CLIENT_ID || "";
+        headers["x-project-id"] = process.env.PS_PROJECT_ID || "";
+        headers["x-workspace-id"] = process.env.PS_WORKSPACE_ID || "";
+        if (this.config.additional_headers) {
+            Object.assign(headers, this.config.additional_headers);
+        }
+        return headers;
+    }
+    // Get base URL from environment variable or use default
+    // uses env variable PS_API_URL if set, otherwise defaults to https://dev.lionis.ai
+    getBaseUrl() {
+        const baseUrl = process.env.PS_API_URL || 'https://dev.lionis.ai';
+        return baseUrl.replace(/\/+$/, ''); // Remove trailing slashes
+    }
+    /**
+     * start a new temp agent on the agent platform
+     * @param input input to the agent the schema should match InputSchema if provided
+     * @param history history of messages for agent context
+     * @param log logger to use for logging, defaults to agent's logger
+     * @returns Correlation ID of the started agent
+     */
+    async start(input, history, log) {
+        log = log || this.log;
+        const ischema = this.InputSchema ? this.InputSchema : z.toJSONSchema(z.object({
+            query: z.string().meta({
+                title: "query",
+                description: "The query by the user."
+            }),
+            // history: z.array(z.object({
+            //   role: z.enum(["user", "model"]).meta({
+            //     title: "role",
+            //     description: "Role of the message sender"
+            //   }),
+            //   content: z.string().meta({
+            //     title: "content",
+            //     description: "Content of the message"
+            //   })
+            // })).optional().meta({
+            //   title: "history",
+            //   description: "List of the User and Assistant chat history"
+            // })
+        }).meta({
+            title: "request_body",
+            description: "The request body parameters for the agent.",
+        }), { "io": "input" });
+        //check if the input confirms to the input schema
+        // const parseResult = z.object(ischema).safeParse(input);
+        // if (!parseResult.success) {
+        //   log?.error('Input validation failed:', parseResult.error.message);
+        //   throw new Error(`Input validation failed: ${parseResult.error.issues.map(issue=>issue.message).join(', ')}`);
+        // }
+        if (ischema.properties) {
+            Object.assign(ischema.properties, {
+                history: {
+                    type: "array",
+                    items: {
+                        type: "object"
+                    },
+                    description: "List of the User and Assistant chat history",
+                    title: "Chat history"
+                }
+            });
+        }
+        // console.log("input schema:", JSON.stringify(ischema, null, 2));
+        const output_schema = this.OutputSchema || z.toJSONSchema(z.object({
+            response: z.string().meta({
+                title: "Response",
+                description: "The response from the agent",
+            }),
+        }).meta({
+            title: "Agent_Response",
+            description: "The response from the agent after processing the input",
+        }), { io: "output" });
+        const body = {
+            agent: {
+                name: this.Name,
+                description: this.Description,
+                system_prompt: this.Instruction,
+                llm: this.Model || "gpt-5",
+                input_schema: ischema,
+                output_schema: output_schema,
+            },
+            input_params: Object.assign(input, { history: history || [] }),
+            tasks: this.Tasks.map(task => ({
+                name: task.Name,
+                description: task.Description
+            })),
+            tools: {
+                new_tools: this.Tools.map(tool => ({
+                    name: tool.Name,
+                    description: tool.Description,
+                    type: tool.Type,
+                    local_execution: tool.LocalExecution,
+                    hitl: tool.HITL,
+                    inputs: tool.Inputs
+                })),
+                existing_tools: []
+            },
+            planning: {
+                plan_required: this.config.show_plan || false,
+                hitl: this.config.hitl_for_plan || false
+            },
+        };
+        try {
+            const headers = await this.getAuthHeaders();
+            // log?.debug('Starting agent with headers:', headers);
+            // log?.debug('Starting agent with body:', JSON.stringify(body.input_params, null, 2));
+            const response = await fetch(`${this.getBaseUrl()}/api/v1/agents/temp_agent`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers
+                },
+                body: JSON.stringify(body),
+                retries: 3,
+                retryOn: function (attempt, error, response) {
+                    // retry on any network error, or 4xx or 5xx status codes
+                    if (error !== null || response.status > 400 && attempt < 4) {
+                        log?.warn(`retrying execute agent, attempt number ${attempt + 1}, status: ${response.status}`, error);
+                        return true;
+                    }
+                    return false;
+                },
+                retryDelay: function (attempt, _error, _response) {
+                    return Math.pow(2, attempt) * 1000; // 1000, 2000, 4000
+                }
+            });
+            if (!response.ok) {
+                let errorDetails;
+                try {
+                    errorDetails = await response.text();
+                }
+                catch (e) {
+                    throw new Error(`Unable to start agent. status: ${response.status}`);
+                }
+                if (errorDetails) {
+                    throw new Error(`Unable to start agent. status: ${response.status}, details: ${JSON.stringify(errorDetails)}`);
+                }
+            }
+            const responseData = (await response.json());
+            this.agentId = responseData.data.agent_id;
+            this.correlationId = responseData.data.correlation_id;
+            log?.info(`Agent started with ID: ${this.agentId}, Correlation ID: ${this.correlationId}`);
+            return this.correlationId;
+        }
+        catch (error) {
+            log?.error('Unable to start agent:', error);
+            throw error;
+        }
+    }
+    /**
+     * resume the agent with tool output after a tool execution or human input
+     * @param tooloutput output from the tool execution to send back to the agent
+     * @returns
+     */
+    async resume(tooloutput) {
+        const log = this.log;
+        if (!this.agentId) {
+            throw new Error("Agent ID is not set");
+        }
+        try {
+            const response = await fetch(`${this.getBaseUrl()}/api/v1/agents/${this.agentId}/resume`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...await this.getAuthHeaders()
+                },
+                body: JSON.stringify({
+                    "correlation_id": this.CorrelationId,
+                    "tool_output_override": tooloutput,
+                }),
+                retries: 3,
+                retryOn: function (attempt, error, response) {
+                    // retry on any network error, or 4xx or 5xx status codes
+                    if (error !== null || response.status >= 400 && attempt < 4) {
+                        log?.warn(`retrying resume, attempt number ${attempt + 1} ${response.status}`, error);
+                        return true;
+                    }
+                    return false;
+                },
+                retryDelay: function (attempt, _error, _response) {
+                    return Math.pow(2, attempt) * 1000; // 1000, 2000, 4000
+                }
+            });
+            if (!response.ok) {
+                log?.error("Error resuming agent:", await response.json());
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const resumeData = await response.json();
+            return resumeData;
+        }
+        catch (error) {
+            log?.error("Error resuming agent:", error);
+            log?.error("Correlation ID:", this.correlationId);
+            log?.error("Tool Output:", tooloutput);
+            throw new Error(`Failed to resume agent: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * deletes the agent running on the platform
+     * @param log optional logger to use for logging, defaults to agent's logger
+     */
+    async cancel(log) {
+        if (!this.AgentId) {
+            throw new Error("Agent is not started");
+        }
+        try {
+            const response = await fetch(`${this.getBaseUrl()}/api/v1/agents/${this.agentId}`, {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...await this.getAuthHeaders()
+                },
+                retries: 3,
+                retryOn: function (attempt, error, response) {
+                    // retry on any network error, or 4xx or 5xx status codes
+                    if (error !== null || response.status >= 400 && attempt < 4) {
+                        log?.warn(`retrying cancel agent, attempt number ${attempt + 1}`);
+                        return true;
+                    }
+                    return false;
+                },
+                retryDelay: function (attempt, _error, _response) {
+                    return Math.pow(2, attempt) * 1000; // 1000, 2000, 4000
+                }
+            });
+            if (!response.ok) {
+                let errorDetails;
+                try {
+                    errorDetails = await response.json();
+                    log?.error(await response.json());
+                }
+                catch (e) {
+                    throw new Error(`Unable to cancel agent status: ${response.status}`);
+                }
+                if (errorDetails) {
+                    throw new Error(`Unable to cancel agent status: ${response.status}, details: ${JSON.stringify(errorDetails)}`);
+                }
+            }
+            log?.info(`Agent ${this.agentId} cancelled successfully`);
+        }
+        catch (error) {
+            log?.error('Error cancelling agent:', error);
+            throw error;
+        }
+    }
+    /**
+     * Gets all the events for the current agent run identified correlation ID
+     * @returns Array of event objects for the current agent's correlation ID
+     * @see https://dev.lionis.ai/api/v1/events/events?correlationId={{correlation_id}}
+     */
+    async getEvents() {
+        if (!this.CorrelationId) {
+            throw new Error("Correlation ID is not set");
+        }
+        try {
+            const response = await fetch(`${this.getBaseUrl()}/api/v1/events/events?correlationId=${this.correlationId}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...await this.getAuthHeaders()
+                },
+                retries: 3,
+                retryOn: function (attempt, error, response) {
+                    // retry on any network error, or 4xx or 5xx status codes
+                    if (error !== null || response.status >= 400 && attempt < 4) {
+                        //log?.warn(`retrying getEvents, attempt number ${attempt + 1}`);
+                        return true;
+                    }
+                    return false;
+                },
+                retryDelay: function (attempt, _error, _response) {
+                    return Math.pow(2, attempt) * 1000; // 1000, 2000, 4000
+                }
+            });
+            if (!response.ok) {
+                //log.error("Error fetching agent events:", await response.json());
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const eventsData = await response.json();
+            return eventsData;
+        }
+        catch (error) {
+            //log.error("Error fetching agent events:", error);
+            throw new Error(`Failed to fetch agent events: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Invoke the tool with the given name and input
+     * @remarks
+     * The input object should match the tool's input schema
+     *
+     * @param toolName name of the tool to execute
+     * @param input input object for the tool execution should match tool's input schema
+     * @param log logger to use for logging, defaults to agent's logger
+     * @returns output from the tool execution or error if any
+     *
+     * @example
+     * Example input for PSArtifactTool:
+     * ```json
+     * {
+     *   "name": "example_artifact",
+     *   "action": "write",
+     *   "content": "This is an example artifact content."
+     * }
+     * ```
+     */
+    async executeTool(toolName, input, log) {
+        let results = { error: null };
+        const tool = this.Tools.find(t => t.Name === toolName);
+        if (!tool) {
+            results.error = new Error(`Tool with name ${toolName} not found`);
+        }
+        else {
+            try {
+                results.result = await tool.run(input, log);
+            }
+            catch (error) {
+                results.result = undefined;
+                results.error = new Error(`${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            if (results.error) {
+                await this.resume({ error: results.error.message || results.error.toString() });
+            }
+            else {
+                await this.resume(results.result || { output: "No result returned from tool execution" });
+            }
+        }
+        catch (error) {
+            results.error = new Error(`Error resuming agent after tool execution: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return results;
+    }
+    /**
+     *
+     * @param requestContext
+     * @param eventBus
+     * @returns
+     */
+    async execute(requestContext, eventBus) {
+        const log = this.log;
+        const userMessage = requestContext.userMessage;
+        const existingTask = requestContext.task;
+        const taskId = existingTask?.id || uuidv4();
+        const contextId = userMessage.contextId || existingTask?.contextId || uuidv4();
+        log?.info(`[${this.Name}:AgentExecutor] Processing message ${userMessage.messageId} for task ${taskId} (context: ${contextId})`);
+        // 1. Publish initial Task event if it's a new task
+        if (!existingTask) {
+            const initialTask = {
+                kind: 'task',
+                id: taskId,
+                contextId: contextId,
+                status: {
+                    state: 'submitted',
+                    timestamp: new Date().toISOString(),
+                },
+                history: [userMessage],
+                metadata: userMessage.metadata,
+                artifacts: [], // Initialize artifacts array
+            };
+            eventBus.publish(initialTask);
+        }
+        // 2. Publish "working" status update
+        let workingStatusUpdate = {
+            kind: 'status-update',
+            taskId: taskId,
+            contextId: contextId,
+            status: {
+                state: 'working',
+                message: {
+                    kind: 'message',
+                    role: 'agent',
+                    messageId: uuidv4(),
+                    parts: [{ kind: 'text', text: 'Initializing the agent...' }],
+                    taskId: taskId,
+                    contextId: contextId,
+                },
+                timestamp: new Date().toISOString(),
+            },
+            final: false,
+        };
+        eventBus.publish(workingStatusUpdate);
+        // 3. Prepare messages for history
+        const history = existingTask?.history ? [...existingTask.history] : [];
+        if (!history.find(m => m.messageId === userMessage.messageId)) {
+            history.push(userMessage);
+        }
+        log?.debug(`[${this.Name}:AgentExecutor] Total messages in history: ${history.length}`);
+        const messages = history
+            .map((m) => ({
+            role: (m.role === 'agent' ? 'model' : 'user'),
+            content: m.parts
+                .filter((p) => p.kind === 'text' && !!p.text)
+                .map((p) => p.text).join('\n'),
+            // .map((p) => ({
+            //   text: (p as TextPart).text,
+            // })),
+        }))
+            .filter((m) => m.content.length > 0);
+        if (messages.length === 0) {
+            log?.warn(`[${this.Name}:AgentExecutor] No valid text messages found in history for task ${taskId}.`);
+            const failureUpdate = {
+                kind: 'status-update',
+                taskId: taskId,
+                contextId: contextId,
+                status: {
+                    state: 'failed',
+                    message: {
+                        kind: 'message',
+                        role: 'agent',
+                        messageId: uuidv4(),
+                        parts: [{ kind: 'text', text: 'No input message found to process.' }],
+                        taskId: taskId,
+                        contextId: contextId,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                final: true,
+            };
+            eventBus.publish(failureUpdate);
+            return;
+        }
+        try {
+            let input = {};
+            if (userMessage.parts && userMessage.parts.length > 0) {
+                for (const part of userMessage.parts) {
+                    if (part.kind === 'text' && part.text) {
+                        input['query'] = part.text;
+                    }
+                    // TODO: handle other part kinds (e.g., images, files) here as needed
+                }
+            }
+            if (this.Tools.length === 0) {
+                const ai = new PSAI(this.Token || '', this.getBaseUrl(), log);
+                const llmResponse = await ai.llm(input.query, this.Model);
+                //console.log("llmResponse:", llmResponse);
+                const completedUpdate = {
+                    kind: 'status-update',
+                    taskId: taskId,
+                    contextId: contextId,
+                    status: {
+                        state: 'completed',
+                        message: {
+                            kind: 'message',
+                            role: 'agent',
+                            messageId: uuidv4(),
+                            parts: [{ kind: 'text', text: llmResponse.choices[0].message.content }],
+                            taskId: taskId,
+                            contextId: contextId,
+                        },
+                        timestamp: new Date().toISOString(),
+                    },
+                    final: true,
+                };
+                eventBus.publish(completedUpdate);
+                return;
+            }
+            this.log?.debug(`Agent input: ${JSON.stringify(input)}`);
+            await this.start(input, messages.slice(0, -1), log);
+            workingStatusUpdate = {
+                kind: 'status-update',
+                taskId: taskId,
+                contextId: contextId,
+                status: {
+                    state: 'working',
+                    message: {
+                        kind: 'message',
+                        role: 'agent',
+                        messageId: uuidv4(),
+                        parts: [{ kind: 'text', text: `started new agent ${this.AgentId}, correlationid: ${this.correlationId}` }],
+                        taskId: taskId,
+                        contextId: contextId,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                final: false,
+            };
+            eventBus.publish(workingStatusUpdate);
+            let events;
+            let lastevent = {
+                timestamp: Date.now(),
+            };
+            let processedEvents = 0;
+            do {
+                do {
+                    if (this.cancelledTasks.has(taskId)) {
+                        log?.info(`[${this.Name}:AgentExecutor] Task ${taskId} has been cancelled.`);
+                        // Publish the final 'canceled' status.
+                        const cancelledUpdate = {
+                            kind: "status-update",
+                            taskId: taskId,
+                            contextId: contextId,
+                            status: { state: "canceled", timestamp: new Date().toISOString() },
+                            final: true,
+                        };
+                        eventBus.publish(cancelledUpdate);
+                        eventBus.finished();
+                        // Clean up and exit.
+                        this.cancelledTasks.delete(taskId);
+                        return;
+                    }
+                    await sleep(500);
+                    //log?.info(`[${this.Name}:AgentExecutor] Fetching events for correlation ID ${this.CorrelationId}`);
+                    events = await this.getEvents();
+                    if (events.length > processedEvents) {
+                        events = events.slice(processedEvents); // get only new events
+                    }
+                } while (events.length === 0);
+                const event = events[0];
+                if (lastevent.timestamp !== event.timestamp) {
+                    //log?.debug(`[${this.Name}:AgentExecutor] New event: ${event.timestamp} Last Event: ${lastevent.timestamp} `);
+                    lastevent = event;
+                    if (lastevent.agentStatus === "waiting") {
+                        if (lastevent.tool.startsWith('mcp_')) {
+                        }
+                        else if (lastevent.tool) {
+                            log?.info(`[${this.Name}:AgentExecutor] toolcall: ${lastevent.tool}, ts:${lastevent.timestamp}, c:${processedEvents}\n`);
+                            let workingStatusUpdate = {
+                                kind: 'status-update',
+                                taskId: taskId,
+                                contextId: contextId,
+                                status: {
+                                    state: 'working',
+                                    message: {
+                                        kind: 'message',
+                                        role: 'agent',
+                                        messageId: uuidv4(),
+                                        parts: [{ kind: 'text', text: `invoking tool ${lastevent.tool}(${JSON.stringify(lastevent.toolInput.request_body)})...\n` }],
+                                        taskId: taskId,
+                                        contextId: contextId,
+                                        metadata: {
+                                            data: lastevent.toolInput.request_body
+                                        }
+                                    },
+                                    timestamp: new Date().toISOString(),
+                                },
+                                final: false,
+                            };
+                            eventBus.publish(workingStatusUpdate);
+                            const res = await this.executeTool(lastevent.tool, lastevent.toolInput.request_body, log);
+                            let statusMsg = `Tool ${lastevent.tool} executed `;
+                            if (res.error) {
+                                log?.error(`${res.error}`);
+                                statusMsg += `with error: ${res.error.message || res.error.toString()}`;
+                            }
+                            else {
+                                statusMsg += `successfully.`;
+                            }
+                            workingStatusUpdate = {
+                                kind: 'status-update',
+                                taskId: taskId,
+                                contextId: contextId,
+                                status: {
+                                    state: 'working',
+                                    message: {
+                                        kind: 'message',
+                                        role: 'agent',
+                                        messageId: uuidv4(),
+                                        parts: [{ kind: 'text', text: statusMsg }],
+                                        taskId: taskId,
+                                        contextId: contextId,
+                                    },
+                                    timestamp: new Date().toISOString(),
+                                },
+                                final: false,
+                            };
+                            eventBus.publish(workingStatusUpdate);
+                        }
+                    }
+                    else if (lastevent.agentStatus === "pending") {
+                        //log(`\n\n#### ${lastevent.agentStatus}:\n`);
+                    }
+                    else if (lastevent.agentStatus === "in-progress") {
+                        if (lastevent.tool === 'generate_plan_tool' && lastevent.toolOutput) {
+                            log?.info("```log-Agent_Plan\n" + lastevent.toolOutput + "\n```");
+                        }
+                        else if (lastevent.message.indexOf("resume")) {
+                            //log.info(`.`);
+                        }
+                        else
+                            log?.info(`\n\n#### ${lastevent.message}:\n`);
+                    }
+                    else if (lastevent.agentStatus === "completed") {
+                        log?.info(`Agent Execution Completed`);
+                        log?.info(`---`);
+                        log?.done(lastevent.output.response);
+                    }
+                    else {
+                        log?.warn(`#### ${lastevent.agentStatus}`);
+                        log?.warn('last event:', lastevent);
+                        log?.error(`Agent execution failed: ${JSON.stringify(lastevent)}`);
+                        log?.done(' Agent execution failed ');
+                    }
+                    processedEvents++;
+                }
+            } while (lastevent?.agentStatus !== "failed" && lastevent?.agentStatus !== "completed");
+            if (lastevent?.agentStatus === "failed") {
+                const failureUpdate = {
+                    kind: 'status-update',
+                    taskId: taskId,
+                    contextId: contextId,
+                    status: {
+                        state: 'failed',
+                        message: {
+                            kind: 'message',
+                            role: 'agent',
+                            messageId: uuidv4(),
+                            parts: [{ kind: 'text', text: `Agent execution failed: ${lastevent?.message || ''}` }],
+                            taskId: taskId,
+                            contextId: contextId,
+                        },
+                        timestamp: new Date().toISOString(),
+                    },
+                    final: true,
+                };
+                eventBus.publish(failureUpdate);
+            }
+            else if (lastevent?.agentStatus === "completed") {
+                const completedUpdate = {
+                    kind: 'status-update',
+                    taskId: taskId,
+                    contextId: contextId,
+                    status: {
+                        state: 'completed',
+                        message: {
+                            kind: 'message',
+                            role: 'agent',
+                            messageId: uuidv4(),
+                            parts: [{ kind: 'text', text: lastevent.output.response }],
+                            taskId: taskId,
+                            contextId: contextId,
+                        },
+                        timestamp: new Date().toISOString(),
+                    },
+                    final: true,
+                };
+                eventBus.publish(completedUpdate);
+            }
+            return;
+        }
+        catch (error) {
+            log?.error(`[${this.Name}:AgentExecutor] Error processing task ${taskId}:`, error);
+            const errorUpdate = {
+                kind: 'status-update',
+                taskId: taskId,
+                contextId: contextId,
+                status: {
+                    state: 'failed',
+                    message: {
+                        kind: 'message',
+                        role: 'agent',
+                        messageId: uuidv4(),
+                        parts: [{ kind: 'text', text: `Error processing your message: ${error instanceof Error ? error.message : String(error)}` }],
+                        taskId: taskId,
+                        contextId: contextId,
+                    },
+                    timestamp: new Date().toISOString(),
+                },
+                final: true,
+            };
+            eventBus.publish(errorUpdate);
+        }
+    }
+    // Function to get the host IP address
+    getHostIPAddress() {
+        const interfaces = os.networkInterfaces();
+        for (const interfaceName in interfaces) {
+            for (const interfaceInfo of interfaces[interfaceName] || []) {
+                if (interfaceInfo.family === 'IPv4' && !interfaceInfo.internal) {
+                    return interfaceInfo.address;
+                }
+            }
+        }
+        return 'localhost';
+    }
+    /**
+     * Port for A2A express server
+     * @returns Port number from config or default 41241
+     */
+    getPort() {
+        return this.config.port || 41241;
+    }
+    /**
+     *
+     * @param taskStore Optional TaskStore, defaults to InMemoryTaskStore
+     * @returns A2A Express app
+     */
+    getServer(taskStore = new InMemoryTaskStore()) {
+        // Set up the server.
+        const agentExecutor = this;
+        const requestHandler = new DefaultRequestHandler(this.getAgentCard(), taskStore, agentExecutor);
+        const appBuilder = new A2AExpressApp(requestHandler);
+        const expressApp = appBuilder.setupRoutes(express());
+        return { app: expressApp, port: this.getPort() };
+    }
+    getAgentCard() {
+        return {
+            version: '0.0.1', // Incremented version
+            protocolVersion: '0.3.0',
+            name: this.Name,
+            description: this.Description,
+            // Adjust the base URL and port in A2AExpressApp
+            url: `http://${this.getHostIPAddress()}:${this.getPort()}/`,
+            provider: {
+                organization: 'PS',
+                url: 'https://example.com/a2a-agent' // Added provider URL
+            },
+            capabilities: {
+                streaming: true, // The new framework supports streaming
+                pushNotifications: false, // Assuming not implemented for this agent yet
+                stateTransitionHistory: true, // Agent uses history
+            },
+            // authentication: null, // Property 'authentication' does not exist on type 'AgentCard'.
+            securitySchemes: undefined, // Or define actual security schemes if any
+            security: undefined,
+            defaultInputModes: ['text'],
+            defaultOutputModes: ['text', 'task-status'], // task-status is a common output mode
+            skills: [
+                {
+                    id: this.Name.toLowerCase().replace(/\s+/g, '-'),
+                    name: this.Name,
+                    description: this.Description,
+                    tags: ['psagent'],
+                    examples: this.config.examples || [],
+                    inputModes: ['text'], // Explicitly defining for skill
+                    outputModes: ['text', 'task-status'] // Explicitly defining for skill
+                },
+                ...this.tasks.map(task => ({
+                    id: task.Name.toLowerCase().replace(/\s+/g, '-'),
+                    name: task.Name,
+                    description: task.Description,
+                    tags: ['psagent-task'],
+                    examples: task.Examples,
+                    inputModes: ['text'], // Assuming text input for tasks
+                    outputModes: ['text', 'task-status'] // Assuming text and status output for tasks
+                }))
+            ],
+            supportsAuthenticatedExtendedCard: false,
+        };
+    }
+    static FromConfigFile(config_path) {
+        if (!fs.existsSync(config_path)) {
+            throw new Error(`Config file ${config_path} does not exist`);
+        }
+        const ext = path.extname(config_path).toLowerCase();
+        let configData;
+        if (ext === '.json') {
+            const fileContent = fs.readFileSync(config_path, 'utf-8');
+            configData = JSON.parse(fileContent);
+        }
+        else if (ext === '.yaml' || ext === '.yml') {
+            const fileContent = fs.readFileSync(config_path, 'utf-8');
+            configData = yaml.parse(fileContent);
+        }
+        else {
+            throw new Error('Unsupported config file format. Use JSON or YAML.');
+        }
+        // Basic validation of required fields
+        const requiredFields = ['name', 'description', 'instruction'];
+        for (const field of requiredFields) {
+            if (!configData[field]) {
+                throw new Error(`Missing required field '${field}' in config file.`);
+            }
+        }
+        // Convert tools and tasks if present
+        if (configData.tools && Array.isArray(configData.tools)) {
+            configData.tools = configData.tools.map((toolConfig) => new PSAgentTool(toolConfig));
+        }
+        else {
+            configData.tools = [];
+        }
+        if (configData.tasks && Array.isArray(configData.tasks)) {
+            configData.tasks = configData.tasks.map((taskConfig) => new PSAgentTask(taskConfig.name, taskConfig.description));
+        }
+        else {
+            configData.tasks = [];
+        }
+        return new PSAgent(configData);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PSAgent.js","sourceRoot":"","sources":["../../../src/lib/PSAgent.ts"],"names":[],"mappings":"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"}