opc-agent 1.2.0 → 1.2.1

package/src/core/a2a.ts

@@ -1,143 +1,143 @@
-import { EventEmitter } from 'events';
-import { Room } from './room';
-import type { Message, IAgent } from './types';
-import { Logger } from './logger';
-
-// ── A2A Types ───────────────────────────────────────────────
-
-export interface AgentCapability {
-  name: string;
-  description: string;
-  inputSchema?: Record<string, unknown>;
-  outputSchema?: Record<string, unknown>;
-}
-
-export interface AgentRegistration {
-  agentName: string;
-  capabilities: AgentCapability[];
-  endpoint?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface A2ARequest {
-  id: string;
-  from: string;
-  to: string;
-  capability: string;
-  payload: string;
-  timestamp: number;
-  timeout?: number;
-}
-
-export interface A2AResponse {
-  requestId: string;
-  from: string;
-  status: 'success' | 'error' | 'timeout';
-  payload?: string;
-  error?: string;
-  timestamp: number;
-}
-
-// ── Agent Registry ──────────────────────────────────────────
-
-export class AgentRegistry extends EventEmitter {
-  private registrations: Map<string, AgentRegistration> = new Map();
-  private agents: Map<string, IAgent> = new Map();
-  private room: Room;
-  private logger = new Logger('a2a');
-
-  constructor(room?: Room) {
-    super();
-    this.room = room ?? new Room('a2a-default');
-  }
-
-  register(agent: IAgent, capabilities: AgentCapability[]): void {
-    const reg: AgentRegistration = { agentName: agent.name, capabilities };
-    this.registrations.set(agent.name, reg);
-    this.agents.set(agent.name, agent);
-    this.room.addAgent(agent);
-    this.logger.info('Agent registered', { name: agent.name, capabilities: capabilities.map(c => c.name) });
-    this.emit('agent:registered', reg);
-  }
-
-  unregister(name: string): void {
-    this.registrations.delete(name);
-    this.agents.delete(name);
-    this.room.removeAgent(name);
-    this.emit('agent:unregistered', name);
-  }
-
-  discover(capability?: string): AgentRegistration[] {
-    const all = Array.from(this.registrations.values());
-    if (!capability) return all;
-    return all.filter(r => r.capabilities.some(c => c.name === capability));
-  }
-
-  getAgent(name: string): IAgent | undefined {
-    return this.agents.get(name);
-  }
-
-  async request(req: A2ARequest): Promise<A2AResponse> {
-    const agent = this.agents.get(req.to);
-    if (!agent) {
-      return {
-        requestId: req.id,
-        from: req.to,
-        status: 'error',
-        error: `Agent "${req.to}" not found`,
-        timestamp: Date.now(),
-      };
-    }
-
-    const message: Message = {
-      id: req.id,
-      role: 'user',
-      content: req.payload,
-      timestamp: req.timestamp,
-      metadata: { a2a: true, from: req.from, capability: req.capability },
-    };
-
-    this.emit('request', req);
-
-    try {
-      const timeoutMs = req.timeout ?? 30000;
-      const response = await Promise.race([
-        agent.handleMessage(message),
-        new Promise<never>((_, reject) =>
-          setTimeout(() => reject(new Error('A2A request timeout')), timeoutMs),
-        ),
-      ]);
-
-      const res: A2AResponse = {
-        requestId: req.id,
-        from: req.to,
-        status: 'success',
-        payload: response.content,
-        timestamp: Date.now(),
-      };
-      this.emit('response', res);
-      return res;
-    } catch (err) {
-      const res: A2AResponse = {
-        requestId: req.id,
-        from: req.to,
-        status: (err as Error).message.includes('timeout') ? 'timeout' : 'error',
-        error: (err as Error).message,
-        timestamp: Date.now(),
-      };
-      this.emit('response', res);
-      return res;
-    }
-  }
-
-  async call(from: string, to: string, capability: string, payload: string): Promise<A2AResponse> {
-    return this.request({
-      id: `a2a_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      from,
-      to,
-      capability,
-      payload,
-      timestamp: Date.now(),
-    });
-  }
-}
+import { EventEmitter } from 'events';
+import { Room } from './room';
+import type { Message, IAgent } from './types';
+import { Logger } from './logger';
+
+// ── A2A Types ───────────────────────────────────────────────
+
+export interface AgentCapability {
+  name: string;
+  description: string;
+  inputSchema?: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
+}
+
+export interface AgentRegistration {
+  agentName: string;
+  capabilities: AgentCapability[];
+  endpoint?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface A2ARequest {
+  id: string;
+  from: string;
+  to: string;
+  capability: string;
+  payload: string;
+  timestamp: number;
+  timeout?: number;
+}
+
+export interface A2AResponse {
+  requestId: string;
+  from: string;
+  status: 'success' | 'error' | 'timeout';
+  payload?: string;
+  error?: string;
+  timestamp: number;
+}
+
+// ── Agent Registry ──────────────────────────────────────────
+
+export class AgentRegistry extends EventEmitter {
+  private registrations: Map<string, AgentRegistration> = new Map();
+  private agents: Map<string, IAgent> = new Map();
+  private room: Room;
+  private logger = new Logger('a2a');
+
+  constructor(room?: Room) {
+    super();
+    this.room = room ?? new Room('a2a-default');
+  }
+
+  register(agent: IAgent, capabilities: AgentCapability[]): void {
+    const reg: AgentRegistration = { agentName: agent.name, capabilities };
+    this.registrations.set(agent.name, reg);
+    this.agents.set(agent.name, agent);
+    this.room.addAgent(agent);
+    this.logger.info('Agent registered', { name: agent.name, capabilities: capabilities.map(c => c.name) });
+    this.emit('agent:registered', reg);
+  }
+
+  unregister(name: string): void {
+    this.registrations.delete(name);
+    this.agents.delete(name);
+    this.room.removeAgent(name);
+    this.emit('agent:unregistered', name);
+  }
+
+  discover(capability?: string): AgentRegistration[] {
+    const all = Array.from(this.registrations.values());
+    if (!capability) return all;
+    return all.filter(r => r.capabilities.some(c => c.name === capability));
+  }
+
+  getAgent(name: string): IAgent | undefined {
+    return this.agents.get(name);
+  }
+
+  async request(req: A2ARequest): Promise<A2AResponse> {
+    const agent = this.agents.get(req.to);
+    if (!agent) {
+      return {
+        requestId: req.id,
+        from: req.to,
+        status: 'error',
+        error: `Agent "${req.to}" not found`,
+        timestamp: Date.now(),
+      };
+    }
+
+    const message: Message = {
+      id: req.id,
+      role: 'user',
+      content: req.payload,
+      timestamp: req.timestamp,
+      metadata: { a2a: true, from: req.from, capability: req.capability },
+    };
+
+    this.emit('request', req);
+
+    try {
+      const timeoutMs = req.timeout ?? 30000;
+      const response = await Promise.race([
+        agent.handleMessage(message),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('A2A request timeout')), timeoutMs),
+        ),
+      ]);
+
+      const res: A2AResponse = {
+        requestId: req.id,
+        from: req.to,
+        status: 'success',
+        payload: response.content,
+        timestamp: Date.now(),
+      };
+      this.emit('response', res);
+      return res;
+    } catch (err) {
+      const res: A2AResponse = {
+        requestId: req.id,
+        from: req.to,
+        status: (err as Error).message.includes('timeout') ? 'timeout' : 'error',
+        error: (err as Error).message,
+        timestamp: Date.now(),
+      };
+      this.emit('response', res);
+      return res;
+    }
+  }
+
+  async call(from: string, to: string, capability: string, payload: string): Promise<A2AResponse> {
+    return this.request({
+      id: `a2a_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      from,
+      to,
+      capability,
+      payload,
+      timestamp: Date.now(),
+    });
+  }
+}

package/src/core/agent.ts

@@ -1,152 +1,152 @@
-import { EventEmitter } from 'events';
-import type { AgentState, IAgent, IChannel, ISkill, Message, MemoryStore, AgentContext } from './types';
-import { InMemoryStore } from '../memory';
-import { createProvider, type LLMProvider } from '../providers';
-
-export class BaseAgent extends EventEmitter implements IAgent {
-  readonly name: string;
-  private _state: AgentState = 'init';
-  private skills: Map<string, ISkill> = new Map();
-  private channels: IChannel[] = [];
-  private memory: MemoryStore;
-  private _provider: LLMProvider;
-  private systemPrompt: string;
-  private historyLimit: number;
-
-  constructor(options: {
-    name: string;
-    systemPrompt?: string;
-    provider?: string;
-    model?: string;
-    memory?: MemoryStore;
-    historyLimit?: number;
-  }) {
-    super();
-    this.name = options.name;
-    this.systemPrompt = options.systemPrompt ?? 'You are a helpful AI agent.';
-    this.memory = options.memory ?? new InMemoryStore();
-    this._provider = createProvider(options.provider ?? 'openai', options.model);
-    this.historyLimit = options.historyLimit ?? 50;
-  }
-
-  get state(): AgentState {
-    return this._state;
-  }
-
-  get provider(): LLMProvider {
-    return this._provider;
-  }
-
-  getSystemPrompt(): string {
-    return this.systemPrompt;
-  }
-
-  getMemory(): MemoryStore {
-    return this.memory;
-  }
-
-  private transition(to: AgentState): void {
-    const from = this._state;
-    this._state = to;
-    this.emit('state:change', from, to);
-  }
-
-  async init(): Promise<void> {
-    this.transition('ready');
-  }
-
-  async start(): Promise<void> {
-    if (this._state !== 'ready') {
-      throw new Error(`Cannot start agent in state: ${this._state}`);
-    }
-    for (const channel of this.channels) {
-      channel.onMessage((msg) => this.handleMessage(msg));
-      await channel.start();
-    }
-    this.transition('running');
-  }
-
-  async stop(): Promise<void> {
-    for (const channel of this.channels) {
-      await channel.stop();
-    }
-    this.transition('stopped');
-  }
-
-  registerSkill(skill: ISkill): void {
-    this.skills.set(skill.name, skill);
-  }
-
-  bindChannel(channel: IChannel): void {
-    this.channels.push(channel);
-  }
-
-  getChannels(): IChannel[] {
-    return this.channels;
-  }
-
-  async handleMessage(message: Message): Promise<Message> {
-    this.emit('message:in', message);
-
-    const sessionId = (message.metadata?.sessionId as string) ?? 'default';
-    await this.memory.addMessage(sessionId, message);
-
-    const context: AgentContext = {
-      agentName: this.name,
-      sessionId,
-      messages: (await this.memory.getConversation(sessionId)).slice(-this.historyLimit),
-      memory: this.memory,
-      metadata: {},
-    };
-
-    // Try skills first
-    for (const [name, skill] of this.skills) {
-      try {
-        const result = await skill.execute(context, message);
-        this.emit('skill:execute', name, result);
-        if (result.handled && result.response) {
-          const response = this.createResponse(result.response, message);
-          await this.memory.addMessage(sessionId, response);
-          this.emit('message:out', response);
-          return response;
-        }
-      } catch (err) {
-        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);
-    await this.memory.addMessage(sessionId, response);
-    this.emit('message:out', response);
-    return response;
-  }
-
-  async *handleMessageStream(message: Message): AsyncIterable<string> {
-    const sessionId = (message.metadata?.sessionId as string) ?? 'default';
-    await this.memory.addMessage(sessionId, message);
-
-    const history = (await this.memory.getConversation(sessionId)).slice(-this.historyLimit);
-
-    let fullResponse = '';
-    for await (const chunk of this._provider.chatStream(history, this.systemPrompt)) {
-      fullResponse += chunk;
-      yield chunk;
-    }
-
-    const response = this.createResponse(fullResponse, message);
-    await this.memory.addMessage(sessionId, response);
-    this.emit('message:out', response);
-  }
-
-  private createResponse(content: string, inReplyTo: Message): Message {
-    return {
-      id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      role: 'assistant',
-      content,
-      timestamp: Date.now(),
-      metadata: { inReplyTo: inReplyTo.id },
-    };
-  }
-}
+import { EventEmitter } from 'events';
+import type { AgentState, IAgent, IChannel, ISkill, Message, MemoryStore, AgentContext } from './types';
+import { InMemoryStore } from '../memory';
+import { createProvider, type LLMProvider } from '../providers';
+
+export class BaseAgent extends EventEmitter implements IAgent {
+  readonly name: string;
+  private _state: AgentState = 'init';
+  private skills: Map<string, ISkill> = new Map();
+  private channels: IChannel[] = [];
+  private memory: MemoryStore;
+  private _provider: LLMProvider;
+  private systemPrompt: string;
+  private historyLimit: number;
+
+  constructor(options: {
+    name: string;
+    systemPrompt?: string;
+    provider?: string;
+    model?: string;
+    memory?: MemoryStore;
+    historyLimit?: number;
+  }) {
+    super();
+    this.name = options.name;
+    this.systemPrompt = options.systemPrompt ?? 'You are a helpful AI agent.';
+    this.memory = options.memory ?? new InMemoryStore();
+    this._provider = createProvider(options.provider ?? 'openai', options.model);
+    this.historyLimit = options.historyLimit ?? 50;
+  }
+
+  get state(): AgentState {
+    return this._state;
+  }
+
+  get provider(): LLMProvider {
+    return this._provider;
+  }
+
+  getSystemPrompt(): string {
+    return this.systemPrompt;
+  }
+
+  getMemory(): MemoryStore {
+    return this.memory;
+  }
+
+  private transition(to: AgentState): void {
+    const from = this._state;
+    this._state = to;
+    this.emit('state:change', from, to);
+  }
+
+  async init(): Promise<void> {
+    this.transition('ready');
+  }
+
+  async start(): Promise<void> {
+    if (this._state !== 'ready') {
+      throw new Error(`Cannot start agent in state: ${this._state}`);
+    }
+    for (const channel of this.channels) {
+      channel.onMessage((msg) => this.handleMessage(msg));
+      await channel.start();
+    }
+    this.transition('running');
+  }
+
+  async stop(): Promise<void> {
+    for (const channel of this.channels) {
+      await channel.stop();
+    }
+    this.transition('stopped');
+  }
+
+  registerSkill(skill: ISkill): void {
+    this.skills.set(skill.name, skill);
+  }
+
+  bindChannel(channel: IChannel): void {
+    this.channels.push(channel);
+  }
+
+  getChannels(): IChannel[] {
+    return this.channels;
+  }
+
+  async handleMessage(message: Message): Promise<Message> {
+    this.emit('message:in', message);
+
+    const sessionId = (message.metadata?.sessionId as string) ?? 'default';
+    await this.memory.addMessage(sessionId, message);
+
+    const context: AgentContext = {
+      agentName: this.name,
+      sessionId,
+      messages: (await this.memory.getConversation(sessionId)).slice(-this.historyLimit),
+      memory: this.memory,
+      metadata: {},
+    };
+
+    // Try skills first
+    for (const [name, skill] of this.skills) {
+      try {
+        const result = await skill.execute(context, message);
+        this.emit('skill:execute', name, result);
+        if (result.handled && result.response) {
+          const response = this.createResponse(result.response, message);
+          await this.memory.addMessage(sessionId, response);
+          this.emit('message:out', response);
+          return response;
+        }
+      } catch (err) {
+        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);
+    await this.memory.addMessage(sessionId, response);
+    this.emit('message:out', response);
+    return response;
+  }
+
+  async *handleMessageStream(message: Message): AsyncIterable<string> {
+    const sessionId = (message.metadata?.sessionId as string) ?? 'default';
+    await this.memory.addMessage(sessionId, message);
+
+    const history = (await this.memory.getConversation(sessionId)).slice(-this.historyLimit);
+
+    let fullResponse = '';
+    for await (const chunk of this._provider.chatStream(history, this.systemPrompt)) {
+      fullResponse += chunk;
+      yield chunk;
+    }
+
+    const response = this.createResponse(fullResponse, message);
+    await this.memory.addMessage(sessionId, response);
+    this.emit('message:out', response);
+  }
+
+  private createResponse(content: string, inReplyTo: Message): Message {
+    return {
+      id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'assistant',
+      content,
+      timestamp: Date.now(),
+      metadata: { inReplyTo: inReplyTo.id },
+    };
+  }
+}