opc-agent 1.4.0 → 2.0.1

package/dist/core/a2a.d.ts

@@ -1,6 +1,23 @@
 import { EventEmitter } from 'events';
 import { Room } from './room';
 import type { IAgent } from './types';
+export interface AgentCard {
+    name: string;
+    description: string;
+    capabilities: string[];
+    endpoint?: string;
+    handler?: (message: string) => Promise<string>;
+}
+export declare class AgentCardRegistry {
+    private cards;
+    private logger;
+    register(card: AgentCard): void;
+    unregister(name: string): void;
+    get(name: string): AgentCard | undefined;
+    find(query: string): AgentCard[];
+    send(agentName: string, message: string): Promise<string>;
+    list(): AgentCard[];
+}
 export interface AgentCapability {
     name: string;
     description: string;

package/dist/core/a2a.js

@@ -1,9 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentRegistry = void 0;
+exports.AgentRegistry = exports.AgentCardRegistry = void 0;
 const events_1 = require("events");
 const room_1 = require("./room");
 const logger_1 = require("./logger");
+class AgentCardRegistry {
+    cards = new Map();
+    logger = new logger_1.Logger('a2a:cards');
+    register(card) {
+        this.cards.set(card.name, card);
+        this.logger.info('AgentCard registered', { name: card.name });
+    }
+    unregister(name) {
+        this.cards.delete(name);
+    }
+    get(name) {
+        return this.cards.get(name);
+    }
+    find(query) {
+        const lower = query.toLowerCase();
+        return Array.from(this.cards.values()).filter(a => a.name.toLowerCase().includes(lower) ||
+            a.description.toLowerCase().includes(lower) ||
+            a.capabilities.some(c => c.toLowerCase().includes(lower)));
+    }
+    async send(agentName, message) {
+        const agent = this.cards.get(agentName);
+        if (!agent)
+            throw new Error(`Agent '${agentName}' not found`);
+        if (agent.handler) {
+            return agent.handler(message);
+        }
+        else if (agent.endpoint) {
+            const res = await fetch(agent.endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ message }),
+            });
+            const data = await res.json();
+            return data.response || data.content || '';
+        }
+        throw new Error(`Agent '${agentName}' has no handler or endpoint`);
+    }
+    list() {
+        return Array.from(this.cards.values());
+    }
+}
+exports.AgentCardRegistry = AgentCardRegistry;
 // ── Agent Registry ──────────────────────────────────────────
 class AgentRegistry extends events_1.EventEmitter {
     registrations = new Map();

package/dist/core/agent.d.ts

@@ -1,6 +1,11 @@
 import { EventEmitter } from 'events';
 import type { AgentState, IAgent, IChannel, ISkill, Message, MemoryStore } from './types';
 import { type LLMProvider } from '../providers';
+import { SkillLearner } from '../skills/auto-learn';
+import type { MCPTool } from '../tools/mcp';
+import { MCPToolRegistry } from '../tools/mcp';
+import { type SubAgentConfig, type SubAgentResult } from './subagent';
+import { Tracer } from '../telemetry';
 export declare class BaseAgent extends EventEmitter implements IAgent {
     readonly name: string;
     private _state;
@@ -10,6 +15,14 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     private _provider;
     private systemPrompt;
     private historyLimit;
+    private toolRegistry;
+    private maxToolRounds;
+    private skillLearner?;
+    private autoLearnConfig;
+    private _subAgentManager?;
+    private longTermMemory?;
+    private longTermMemoryConfig;
+    private tracer?;
     constructor(options: {
         name: string;
         systemPrompt?: string;
@@ -17,11 +30,33 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
         model?: string;
         memory?: MemoryStore;
         historyLimit?: number;
+        skillsDir?: string;
+        learning?: {
+            autoSkillCreation?: boolean;
+            minConversationLength?: number;
+            improveOnUse?: boolean;
+        };
+        maxToolRounds?: number;
+        tracer?: Tracer;
     });
+    setLongTermMemory(brain: any, config?: {
+        autoLearn?: boolean;
+        autoRecall?: boolean;
+    }): void;
+    getLongTermMemory(): any;
+    getLongTermMemoryConfig(): {
+        autoLearn: boolean;
+        autoRecall: boolean;
+    };
     get state(): AgentState;
     get provider(): LLMProvider;
     getSystemPrompt(): string;
     getMemory(): MemoryStore;
+    getSkillLearner(): SkillLearner | undefined;
+    getToolRegistry(): MCPToolRegistry;
+    getTracer(): Tracer | undefined;
+    setTracer(tracer: Tracer): void;
+    registerTool(tool: MCPTool): void;
     private transition;
     init(): Promise<void>;
     start(): Promise<void>;
@@ -29,7 +64,11 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     registerSkill(skill: ISkill): void;
     bindChannel(channel: IChannel): void;
     getChannels(): IChannel[];
+    private getSubAgentManager;
+    spawnSubAgent(config: SubAgentConfig): Promise<SubAgentResult>;
+    spawnParallel(configs: SubAgentConfig[]): Promise<SubAgentResult[]>;
     handleMessage(message: Message): Promise<Message>;
+    private parseToolCall;
     handleMessageStream(message: Message): AsyncIterable<string>;
     private createResponse;
 }

package/dist/core/agent.js

@@ -4,6 +4,9 @@ exports.BaseAgent = void 0;
 const events_1 = require("events");
 const memory_1 = require("../memory");
 const providers_1 = require("../providers");
+const auto_learn_1 = require("../skills/auto-learn");
+const mcp_1 = require("../tools/mcp");
+const subagent_1 = require("./subagent");
 class BaseAgent extends events_1.EventEmitter {
     name;
     _state = 'init';
@@ -13,6 +16,14 @@ class BaseAgent extends events_1.EventEmitter {
     _provider;
     systemPrompt;
     historyLimit;
+    toolRegistry = new mcp_1.MCPToolRegistry();
+    maxToolRounds;
+    skillLearner;
+    autoLearnConfig;
+    _subAgentManager;
+    longTermMemory;
+    longTermMemoryConfig = { autoLearn: true, autoRecall: true };
+    tracer;
     constructor(options) {
         super();
         this.name = options.name;
@@ -20,6 +31,31 @@ class BaseAgent extends events_1.EventEmitter {
         this.memory = options.memory ?? new memory_1.InMemoryStore();
         this._provider = (0, providers_1.createProvider)(options.provider ?? 'openai', options.model);
         this.historyLimit = options.historyLimit ?? 50;
+        this.maxToolRounds = options.maxToolRounds ?? 10;
+        this.autoLearnConfig = {
+            enabled: options.learning?.autoSkillCreation !== false,
+            minConversationLength: options.learning?.minConversationLength ?? 3,
+            improveOnUse: options.learning?.improveOnUse !== false,
+        };
+        if (options.skillsDir) {
+            this.skillLearner = new auto_learn_1.SkillLearner(options.skillsDir);
+        }
+        this.tracer = options.tracer;
+    }
+    setLongTermMemory(brain, config) {
+        this.longTermMemory = brain;
+        if (config) {
+            this.longTermMemoryConfig = {
+                autoLearn: config.autoLearn !== false,
+                autoRecall: config.autoRecall !== false,
+            };
+        }
+    }
+    getLongTermMemory() {
+        return this.longTermMemory;
+    }
+    getLongTermMemoryConfig() {
+        return this.longTermMemoryConfig;
     }
     get state() {
         return this._state;
@@ -33,12 +69,30 @@ class BaseAgent extends events_1.EventEmitter {
     getMemory() {
         return this.memory;
     }
+    getSkillLearner() {
+        return this.skillLearner;
+    }
+    getToolRegistry() {
+        return this.toolRegistry;
+    }
+    getTracer() {
+        return this.tracer;
+    }
+    setTracer(tracer) {
+        this.tracer = tracer;
+    }
+    registerTool(tool) {
+        this.toolRegistry.register(tool);
+    }
     transition(to) {
         const from = this._state;
         this._state = to;
         this.emit('state:change', from, to);
     }
     async init() {
+        if (this.skillLearner) {
+            await this.skillLearner.loadLearnedSkills();
+        }
         this.transition('ready');
     }
     async start() {
@@ -66,10 +120,59 @@ class BaseAgent extends events_1.EventEmitter {
     getChannels() {
         return this.channels;
     }
+    getSubAgentManager() {
+        if (!this._subAgentManager) {
+            this._subAgentManager = new subagent_1.SubAgentManager();
+        }
+        return this._subAgentManager;
+    }
+    async spawnSubAgent(config) {
+        return this.getSubAgentManager().spawn(config, this._provider);
+    }
+    async spawnParallel(configs) {
+        return this.getSubAgentManager().spawnParallel(configs, this._provider);
+    }
     async handleMessage(message) {
         this.emit('message:in', message);
+        // Start root span if tracer is configured
+        let rootSpan;
+        if (this.tracer) {
+            rootSpan = this.tracer.startSpan('handleMessage', {
+                kind: 'server',
+                attributes: {
+                    'message.channel': message.metadata?.channel || 'unknown',
+                    'message.sender': message.metadata?.sender || 'unknown',
+                    'message.length': message.content.length,
+                },
+            });
+            this.tracer.increment('agent.messages.total', 1, { agent: this.name });
+        }
         const sessionId = message.metadata?.sessionId ?? 'default';
         await this.memory.addMessage(sessionId, message);
+        // === Recall from long-term memory ===
+        let memoryContext = '';
+        if (this.longTermMemory && this.longTermMemoryConfig.autoRecall) {
+            let memorySpan;
+            if (this.tracer && rootSpan) {
+                memorySpan = this.tracer.startSpan('memory.recall', { parent: rootSpan, kind: 'client' });
+            }
+            try {
+                const recalled = await this.longTermMemory.recall(message.content);
+                if (recalled && (Array.isArray(recalled) ? recalled.length > 0 : true)) {
+                    memoryContext = '\n\n[Relevant memories]\n' +
+                        (Array.isArray(recalled)
+                            ? recalled.map((r) => typeof r === 'string' ? r : r.content || r.compiled_truth || '').join('\n')
+                            : String(recalled));
+                }
+                if (this.tracer && memorySpan)
+                    this.tracer.endSpan(memorySpan, 'ok');
+            }
+            catch {
+                if (this.tracer && memorySpan)
+                    this.tracer.endSpan(memorySpan, 'error');
+                // Silent fail — don't break chat if memory fails
+            }
+        }
         const context = {
             agentName: this.name,
             sessionId,
@@ -93,13 +196,135 @@ class BaseAgent extends events_1.EventEmitter {
                 this.emit('error', err instanceof Error ? err : new Error(String(err)));
             }
         }
-        // Fall back to LLM
-        const llmResponse = await this._provider.chat(context.messages, this.systemPrompt);
-        const response = this.createResponse(llmResponse, message);
+        // Check if a learned skill matches — prepend instructions to system prompt
+        let effectiveSystemPrompt = this.systemPrompt;
+        // Inject long-term memory context
+        if (memoryContext) {
+            effectiveSystemPrompt = effectiveSystemPrompt + memoryContext;
+        }
+        const matchedSkill = this.skillLearner?.matchSkill(message.content);
+        if (matchedSkill) {
+            matchedSkill.usageCount++;
+            matchedSkill.lastUsed = new Date();
+            effectiveSystemPrompt = `[Learned Skill: ${matchedSkill.name}]\n${matchedSkill.instructions}\n\n${this.systemPrompt}`;
+            this.emit('skill:matched', matchedSkill);
+            if (this.tracer && rootSpan) {
+                this.tracer.addEvent(rootSpan, 'skill.matched', { 'skill.name': matchedSkill.name });
+            }
+        }
+        // Fall back to LLM with tool use loop
+        const tools = this.toolRegistry.list();
+        const llmMessages = [...context.messages];
+        let finalResponse = '';
+        for (let round = 0; round <= this.maxToolRounds; round++) {
+            let llmSpan;
+            if (this.tracer && rootSpan) {
+                llmSpan = this.tracer.startSpan('llm.chat', {
+                    parent: rootSpan,
+                    kind: 'client',
+                    attributes: { 'llm.round': round },
+                });
+            }
+            const llmResponse = await this._provider.chat(llmMessages, effectiveSystemPrompt, { tools: tools.length > 0 ? tools : undefined });
+            if (this.tracer && llmSpan) {
+                llmSpan.attributes['llm.response.length'] = llmResponse.length;
+                this.tracer.endSpan(llmSpan, 'ok');
+            }
+            const toolCall = this.parseToolCall(llmResponse);
+            if (!toolCall || tools.length === 0 || round === this.maxToolRounds) {
+                finalResponse = llmResponse;
+                break;
+            }
+            // Execute tool
+            let toolSpan;
+            if (this.tracer && rootSpan) {
+                toolSpan = this.tracer.startSpan('tool.execute', {
+                    parent: rootSpan,
+                    kind: 'internal',
+                    attributes: { 'tool.name': toolCall.name },
+                });
+            }
+            const toolResult = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+            this.emit('tool:execute', toolCall.name, toolResult);
+            if (this.tracer && toolSpan) {
+                toolSpan.attributes['tool.result.length'] = toolResult.content?.length || 0;
+                this.tracer.endSpan(toolSpan, 'ok');
+            }
+            // Add tool call and result to messages for next round
+            llmMessages.push({
+                id: `tool_call_${Date.now()}`,
+                role: 'assistant',
+                content: llmResponse,
+                timestamp: Date.now(),
+            });
+            llmMessages.push({
+                id: `tool_result_${Date.now()}`,
+                role: 'user',
+                content: `[Tool Result for ${toolCall.name}]: ${toolResult.content}`,
+                timestamp: Date.now(),
+            });
+        }
+        const response = this.createResponse(finalResponse, message);
         await this.memory.addMessage(sessionId, response);
         this.emit('message:out', response);
+        // End root telemetry span
+        if (this.tracer && rootSpan) {
+            rootSpan.attributes['response.length'] = finalResponse.length;
+            this.tracer.endSpan(rootSpan, 'ok');
+            this.tracer.histogram('agent.message.duration', rootSpan.endTime - rootSpan.startTime, { agent: this.name });
+        }
+        // === Learn from interaction ===
+        if (this.longTermMemory && this.longTermMemoryConfig.autoLearn) {
+            try {
+                await this.longTermMemory.learn(`User: ${message.content}\nAssistant: ${finalResponse}`, { tags: ['conversation', message.metadata?.channel || 'unknown'] });
+            }
+            catch {
+                // Silent fail
+            }
+        }
+        // After response, check if we should learn a skill
+        if (this.skillLearner &&
+            this.autoLearnConfig.enabled &&
+            context.messages.length >= this.autoLearnConfig.minConversationLength) {
+            this.skillLearner
+                .analyzeForSkillCreation(context.messages, this._provider)
+                .then(async (learnedSkill) => {
+                if (learnedSkill) {
+                    await this.skillLearner.saveSkill(learnedSkill);
+                    this.emit('skill:learned', learnedSkill);
+                }
+            })
+                .catch(() => { });
+        }
+        // Improve matched skill after use
+        if (matchedSkill && this.skillLearner && this.autoLearnConfig.improveOnUse) {
+            this.skillLearner
+                .improveSkill(matchedSkill, context.messages, this._provider)
+                .then(() => this.skillLearner.saveSkill(matchedSkill))
+                .catch(() => { });
+        }
         return response;
     }
+    parseToolCall(response) {
+        try {
+            const parsed = JSON.parse(response);
+            if (parsed.tool_call)
+                return parsed.tool_call;
+            if (parsed.name && parsed.arguments !== undefined)
+                return parsed;
+        }
+        catch { /* not JSON */ }
+        const match = response.match(/<tool_call>\s*(\{[\s\S]*?\})\s*<\/tool_call>/);
+        if (match) {
+            try {
+                const parsed = JSON.parse(match[1]);
+                if (parsed.name)
+                    return parsed;
+            }
+            catch { /* not valid JSON */ }
+        }
+        return null;
+    }
     async *handleMessageStream(message) {
         const sessionId = message.metadata?.sessionId ?? 'default';
         await this.memory.addMessage(sessionId, message);

package/dist/core/runtime.d.ts

@@ -1,3 +1,4 @@
+import { PluginManager } from '../plugins';
 import { BaseAgent } from './agent';
 import { Analytics } from '../analytics';
 import type { OADDocument } from '../schema/oad';
@@ -11,6 +12,11 @@ export declare class AgentRuntime {
     private shutdownHandlers;
     private isShuttingDown;
     private analytics;
+    private scheduler;
+    private pluginManager;
+    private brain;
+    private agentBrain;
+    private evolveScheduler;
     loadConfig(filePath: string): Promise<OADDocument>;
     setHistoryLimit(limit: number): void;
     initialize(config?: OADDocument): Promise<BaseAgent>;
@@ -22,5 +28,6 @@ export declare class AgentRuntime {
     getAgent(): BaseAgent | null;
     getAnalytics(): Analytics;
     getConfig(): OADDocument | null;
+    getPluginManager(): PluginManager;
 }
 //# sourceMappingURL=runtime.d.ts.map