opc-agent 4.1.2 → 4.1.3

package/src/core/session-manager.ts

@@ -1,137 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import type { Message } from './types';
-
-export interface Session {
-  id: string;
-  agentId: string;
-  channel: string;
-  messages: Message[];
-  metadata: Record<string, any>;
-  createdAt: number;
-  lastActivity: number;
-  parentId?: string;
-  compactedAt?: number;
-}
-
-export class SessionManager {
-  private sessions: Map<string, Session> = new Map();
-  private storageDir: string;
-
-  constructor(storageDir?: string) {
-    this.storageDir = storageDir || path.join(process.env.HOME || process.env.USERPROFILE || '~', '.opc', 'sessions');
-  }
-
-  create(agentId: string, channel: string, parentId?: string): Session {
-    const session: Session = {
-      id: crypto.randomUUID(),
-      agentId,
-      channel,
-      messages: [],
-      metadata: {},
-      createdAt: Date.now(),
-      lastActivity: Date.now(),
-      parentId,
-    };
-    this.sessions.set(session.id, session);
-    return session;
-  }
-
-  get(id: string): Session | null {
-    return this.sessions.get(id) || null;
-  }
-
-  list(filter?: { agentId?: string; channel?: string; active?: boolean }): Session[] {
-    let result = Array.from(this.sessions.values());
-    if (filter?.agentId) result = result.filter(s => s.agentId === filter.agentId);
-    if (filter?.channel) result = result.filter(s => s.channel === filter.channel);
-    if (filter?.active !== undefined) {
-      const cutoff = Date.now() - 30 * 60 * 1000; // 30 min
-      result = result.filter(s => filter.active ? s.lastActivity > cutoff : s.lastActivity <= cutoff);
-    }
-    return result;
-  }
-
-  addMessage(sessionId: string, message: Message): void {
-    const session = this.sessions.get(sessionId);
-    if (!session) throw new Error(`Session ${sessionId} not found`);
-    session.messages.push(message);
-    session.lastActivity = Date.now();
-  }
-
-  async compact(sessionId: string, brain?: any): Promise<void> {
-    const session = this.sessions.get(sessionId);
-    if (!session) throw new Error(`Session ${sessionId} not found`);
-    if (brain && typeof brain.compress === 'function') {
-      const compressed = await brain.compress(session.messages);
-      session.messages = [{ id: 'compacted', role: 'system', content: compressed, timestamp: Date.now() }];
-    } else {
-      // Simple: keep first and last 5 messages
-      if (session.messages.length > 10) {
-        const first = session.messages.slice(0, 2);
-        const last = session.messages.slice(-5);
-        session.messages = [...first, { id: 'compacted', role: 'system', content: `[${session.messages.length - 7} messages compacted]`, timestamp: Date.now() }, ...last];
-      }
-    }
-    session.compactedAt = Date.now();
-  }
-
-  prune(maxAge: number): number {
-    const cutoff = Date.now() - maxAge;
-    let pruned = 0;
-    for (const [id, session] of this.sessions) {
-      if (session.lastActivity < cutoff) {
-        this.sessions.delete(id);
-        pruned++;
-      }
-    }
-    return pruned;
-  }
-
-  getLineage(sessionId: string): Session[] {
-    const lineage: Session[] = [];
-    let current = this.sessions.get(sessionId);
-    while (current) {
-      lineage.unshift(current);
-      current = current.parentId ? this.sessions.get(current.parentId) || undefined : undefined;
-    }
-    return lineage;
-  }
-
-  fork(sessionId: string): Session {
-    const parent = this.sessions.get(sessionId);
-    if (!parent) throw new Error(`Session ${sessionId} not found`);
-    return this.create(parent.agentId, parent.channel, parent.id);
-  }
-
-  export(sessionId: string): string {
-    const session = this.sessions.get(sessionId);
-    if (!session) throw new Error(`Session ${sessionId} not found`);
-    const lines = [`# Session ${session.id}`, `Agent: ${session.agentId} | Channel: ${session.channel}`, `Created: ${new Date(session.createdAt).toISOString()}`, ''];
-    for (const msg of session.messages) {
-      lines.push(`**${msg.role}** (${new Date(msg.timestamp).toISOString()}):`);
-      lines.push(msg.content);
-      lines.push('');
-    }
-    return lines.join('\n');
-  }
-
-  save(): void {
-    if (!fs.existsSync(this.storageDir)) {
-      fs.mkdirSync(this.storageDir, { recursive: true });
-    }
-    for (const [id, session] of this.sessions) {
-      fs.writeFileSync(path.join(this.storageDir, `${id}.json`), JSON.stringify(session, null, 2));
-    }
-  }
-
-  load(): void {
-    if (!fs.existsSync(this.storageDir)) return;
-    const files = fs.readdirSync(this.storageDir).filter(f => f.endsWith('.json'));
-    for (const file of files) {
-      const data = JSON.parse(fs.readFileSync(path.join(this.storageDir, file), 'utf-8'));
-      this.sessions.set(data.id, data);
-    }
-  }
-}

package/src/core/streaming.ts

@@ -1,195 +0,0 @@
-import { EventEmitter } from 'events';
-
-// ─── Types ───────────────────────────────────────────────────
-
-export interface StreamChunk {
-  id: string;
-  type: 'text' | 'tool_call' | 'error' | 'done';
-  data: string;
-  timestamp: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface StreamOptions {
-  /** High-water mark for backpressure (default 64 chunks). */
-  highWaterMark?: number;
-  /** Heartbeat interval in ms to keep connection alive (default 15000). */
-  heartbeatInterval?: number;
-}
-
-// ─── StreamableResponse ──────────────────────────────────────
-
-export class StreamableResponse extends EventEmitter {
-  readonly id: string;
-  private chunks: StreamChunk[] = [];
-  private ended = false;
-  private paused = false;
-  private buffer: StreamChunk[] = [];
-  private highWaterMark: number;
-
-  constructor(id: string, options?: StreamOptions) {
-    super();
-    this.id = id;
-    this.highWaterMark = options?.highWaterMark ?? 64;
-  }
-
-  /** Push a chunk. Returns false if backpressure threshold reached. */
-  push(chunk: StreamChunk): boolean {
-    if (this.ended) return false;
-
-    this.chunks.push(chunk);
-
-    if (this.paused) {
-      this.buffer.push(chunk);
-      return this.buffer.length < this.highWaterMark;
-    }
-
-    this.emit('chunk', chunk);
-
-    if (this.chunks.length >= this.highWaterMark) {
-      this.paused = true;
-      this.emit('backpressure');
-      return false;
-    }
-    return true;
-  }
-
-  /** Resume after backpressure — flush buffered chunks. */
-  resume(): void {
-    if (!this.paused) return;
-    this.paused = false;
-    const buffered = this.buffer.splice(0);
-    for (const chunk of buffered) {
-      this.emit('chunk', chunk);
-    }
-    this.emit('drain');
-  }
-
-  end(): void {
-    if (this.ended) return;
-    this.ended = true;
-    if (this.paused) this.resume();
-    this.emit('end');
-  }
-
-  getChunks(): StreamChunk[] {
-    return [...this.chunks];
-  }
-
-  /** Collect all text chunks into a single string. */
-  getText(): string {
-    return this.chunks
-      .filter((c) => c.type === 'text')
-      .map((c) => c.data)
-      .join('');
-  }
-
-  get isEnded(): boolean {
-    return this.ended;
-  }
-
-  get isPaused(): boolean {
-    return this.paused;
-  }
-
-  get length(): number {
-    return this.chunks.length;
-  }
-}
-
-// ─── StreamingManager ────────────────────────────────────────
-
-export class StreamingManager {
-  private streams: Map<string, StreamableResponse> = new Map();
-  private counter = 0;
-
-  /** Create a new stream. */
-  createStream(options?: StreamOptions): StreamableResponse {
-    const id = `stream_${++this.counter}_${Date.now()}`;
-    const stream = new StreamableResponse(id, options);
-    this.streams.set(id, stream);
-    stream.on('end', () => {
-      // Keep ended streams for a bit for late consumers, then clean up
-      setTimeout(() => this.streams.delete(id), 30_000);
-    });
-    return stream;
-  }
-
-  /** Write a text chunk to a stream. */
-  writeChunk(streamId: string, data: string, metadata?: Record<string, unknown>): boolean {
-    const stream = this.streams.get(streamId);
-    if (!stream) return false;
-    return stream.push({
-      id: `chunk_${stream.length}`,
-      type: 'text',
-      data,
-      timestamp: Date.now(),
-      metadata,
-    });
-  }
-
-  /** End a stream. */
-  endStream(streamId: string): void {
-    const stream = this.streams.get(streamId);
-    if (!stream) return;
-    stream.push({
-      id: `chunk_${stream.length}`,
-      type: 'done',
-      data: '',
-      timestamp: Date.now(),
-    });
-    stream.end();
-  }
-
-  /** Get an existing stream. */
-  getStream(streamId: string): StreamableResponse | undefined {
-    return this.streams.get(streamId);
-  }
-
-  /** Format a chunk as an SSE event string. */
-  static formatSSE(chunk: StreamChunk): string {
-    const lines: string[] = [];
-    lines.push(`event: ${chunk.type}`);
-    lines.push(`id: ${chunk.id}`);
-    const payload = JSON.stringify({ data: chunk.data, metadata: chunk.metadata });
-    lines.push(`data: ${payload}`);
-    lines.push('');
-    return lines.join('\n') + '\n';
-  }
-
-  /** Pipe a stream to an SSE-compatible HTTP response (Express-style). */
-  static pipeSSE(
-    stream: StreamableResponse,
-    res: { write(data: string): boolean; end(): void; setHeader?(name: string, value: string): void },
-    options?: StreamOptions,
-  ): void {
-    res.setHeader?.('Content-Type', 'text/event-stream');
-    res.setHeader?.('Cache-Control', 'no-cache');
-    res.setHeader?.('Connection', 'keep-alive');
-
-    const heartbeatMs = options?.heartbeatInterval ?? 15_000;
-    const heartbeat = setInterval(() => {
-      res.write(': heartbeat\n\n');
-    }, heartbeatMs);
-
-    stream.on('chunk', (chunk: StreamChunk) => {
-      const ok = res.write(StreamingManager.formatSSE(chunk));
-      if (!ok && stream.isPaused === false) {
-        // Downstream can't keep up — will resume on drain from stream
-      }
-    });
-
-    stream.on('end', () => {
-      clearInterval(heartbeat);
-      res.end();
-    });
-  }
-
-  get activeCount(): number {
-    let count = 0;
-    for (const s of this.streams.values()) {
-      if (!s.isEnded) count++;
-    }
-    return count;
-  }
-}

package/src/core/subagent.ts

@@ -1,98 +0,0 @@
-import { BaseAgent } from './agent';
-import { InMemoryStore } from '../memory';
-import type { Message } from './types';
-
-export interface SubAgentConfig {
-  name: string;
-  task: string;
-  systemPrompt?: string;
-  provider?: string;
-  model?: string;
-  timeout?: number;
-  isolated?: boolean;
-}
-
-export interface SubAgentResult {
-  id: string;
-  name: string;
-  status: 'completed' | 'failed' | 'timeout';
-  result: string;
-  duration: number;
-}
-
-interface SubAgentEntry {
-  agent: BaseAgent;
-  status: string;
-  name: string;
-}
-
-export class SubAgentManager {
-  private agents: Map<string, SubAgentEntry> = new Map();
-
-  async spawn(config: SubAgentConfig, parentProvider?: any): Promise<SubAgentResult> {
-    const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    const timeout = config.timeout ?? 300000;
-    const isolated = config.isolated !== false;
-
-    const agent = new BaseAgent({
-      name: config.name,
-      systemPrompt: config.systemPrompt ?? 'You are a helpful sub-agent.',
-      provider: config.provider ?? 'openai',
-      model: config.model,
-      memory: isolated ? new InMemoryStore() : undefined,
-    });
-
-    this.agents.set(id, { agent, status: 'running', name: config.name });
-
-    const message: Message = {
-      id: `msg_${Date.now()}`,
-      role: 'user',
-      content: config.task,
-      timestamp: Date.now(),
-      metadata: { subAgentId: id },
-    };
-
-    const start = Date.now();
-
-    try {
-      const result = await Promise.race([
-        agent.handleMessage(message),
-        new Promise<never>((_, reject) =>
-          setTimeout(() => reject(new Error('SubAgent timeout')), timeout),
-        ),
-      ]);
-
-      const duration = Date.now() - start;
-      this.agents.set(id, { agent, status: 'completed', name: config.name });
-
-      return { id, name: config.name, status: 'completed', result: result.content, duration };
-    } catch (err) {
-      const duration = Date.now() - start;
-      const isTimeout = (err as Error).message.includes('timeout');
-      const status = isTimeout ? 'timeout' : 'failed';
-      this.agents.set(id, { agent, status, name: config.name });
-
-      return { id, name: config.name, status, result: (err as Error).message, duration };
-    }
-  }
-
-  async spawnParallel(configs: SubAgentConfig[], parentProvider?: any): Promise<SubAgentResult[]> {
-    return Promise.all(configs.map((c) => this.spawn(c, parentProvider)));
-  }
-
-  list(): Array<{ id: string; name: string; status: string }> {
-    return Array.from(this.agents.entries()).map(([id, entry]) => ({
-      id,
-      name: entry.name,
-      status: entry.status,
-    }));
-  }
-
-  kill(id: string): boolean {
-    const entry = this.agents.get(id);
-    if (!entry) return false;
-    entry.status = 'killed';
-    this.agents.set(id, entry);
-    return true;
-  }
-}

package/src/core/types.ts

@@ -1,68 +0,0 @@
-import { EventEmitter } from 'events';
-
-// ─── Core Types ──────────────────────────────────────────────
-
-export type AgentState = 'init' | 'ready' | 'running' | 'stopped' | 'error';
-
-export interface Message {
-  id: string;
-  role: 'user' | 'assistant' | 'system';
-  content: string;
-  timestamp: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface AgentContext {
-  agentName: string;
-  sessionId: string;
-  messages: Message[];
-  memory: MemoryStore;
-  metadata: Record<string, unknown>;
-}
-
-export interface SkillResult {
-  handled: boolean;
-  response?: string;
-  confidence: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface ISkill {
-  name: string;
-  description: string;
-  execute(context: AgentContext, message: Message): Promise<SkillResult>;
-}
-
-export interface IChannel {
-  type: string;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  onMessage(handler: (message: Message) => Promise<Message>): void;
-}
-
-export interface MemoryStore {
-  get(key: string): Promise<unknown>;
-  set(key: string, value: unknown): Promise<void>;
-  getConversation(sessionId: string): Promise<Message[]>;
-  addMessage(sessionId: string, message: Message): Promise<void>;
-  clear(sessionId?: string): Promise<void>;
-}
-
-export interface AgentEvents {
-  'state:change': (from: AgentState, to: AgentState) => void;
-  'message:in': (message: Message) => void;
-  'message:out': (message: Message) => void;
-  'skill:execute': (skill: string, result: SkillResult) => void;
-  'error': (error: Error) => void;
-}
-
-export interface IAgent extends EventEmitter {
-  readonly name: string;
-  readonly state: AgentState;
-  init(): Promise<void>;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  handleMessage(message: Message): Promise<Message>;
-  registerSkill(skill: ISkill): void;
-  bindChannel(channel: IChannel): void;
-}

package/src/core/versioning.ts

@@ -1,106 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { Logger } from './logger';
-
-// ── Versioning Types ────────────────────────────────────────
-
-export interface VersionEntry {
-  version: string;
-  timestamp: number;
-  description?: string;
-  oadSnapshot: string; // serialized OAD YAML
-}
-
-export interface Migration {
-  fromVersion: string;
-  toVersion: string;
-  migrate: (oad: Record<string, unknown>) => Record<string, unknown>;
-}
-
-// ── Version Manager ─────────────────────────────────────────
-
-export class VersionManager {
-  private versions: VersionEntry[] = [];
-  private migrations: Migration[] = [];
-  private storePath: string;
-  private logger = new Logger('versioning');
-
-  constructor(storePath?: string) {
-    this.storePath = storePath ?? '.opc-versions.json';
-    this.load();
-  }
-
-  private load(): void {
-    try {
-      if (fs.existsSync(this.storePath)) {
-        const data = JSON.parse(fs.readFileSync(this.storePath, 'utf-8'));
-        this.versions = data.versions ?? [];
-      }
-    } catch {
-      this.versions = [];
-    }
-  }
-
-  private save(): void {
-    fs.writeFileSync(this.storePath, JSON.stringify({ versions: this.versions }, null, 2));
-  }
-
-  snapshot(version: string, oadYaml: string, description?: string): void {
-    this.versions.push({
-      version,
-      timestamp: Date.now(),
-      description,
-      oadSnapshot: oadYaml,
-    });
-    this.save();
-    this.logger.info('Version snapshot saved', { version });
-  }
-
-  list(): VersionEntry[] {
-    return [...this.versions];
-  }
-
-  get(version: string): VersionEntry | undefined {
-    return this.versions.find(v => v.version === version);
-  }
-
-  getCurrent(): VersionEntry | undefined {
-    return this.versions[this.versions.length - 1];
-  }
-
-  rollback(version: string): string | null {
-    const entry = this.get(version);
-    if (!entry) {
-      this.logger.warn('Version not found', { version });
-      return null;
-    }
-    this.logger.info('Rolling back to version', { version });
-    return entry.oadSnapshot;
-  }
-
-  registerMigration(migration: Migration): void {
-    this.migrations.push(migration);
-  }
-
-  migrate(oad: Record<string, unknown>, fromVersion: string, toVersion: string): Record<string, unknown> {
-    let current = fromVersion;
-    let result = { ...oad };
-
-    while (current !== toVersion) {
-      const migration = this.migrations.find(m => m.fromVersion === current);
-      if (!migration) {
-        throw new Error(`No migration path from ${current} to ${toVersion}`);
-      }
-      result = migration.migrate(result);
-      current = migration.toVersion;
-      this.logger.info('Migration applied', { from: migration.fromVersion, to: migration.toVersion });
-    }
-
-    return result;
-  }
-
-  clear(): void {
-    this.versions = [];
-    this.save();
-  }
-}