opc-agent 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli.ts

@@ -27,9 +27,9 @@ import { WorkflowEngine } from './core/workflow';
 import { VersionManager } from './core/versioning';
 import { createProvider } from './providers';
 import { KnowledgeBase } from './core/knowledge';
-import { publishAgent, installAgent } from './marketplace';
 
 import { PluginManager, createLoggingPlugin, createAnalyticsPlugin, createRateLimitPlugin } from './plugins';
+import type { Span } from './traces';
 
 const program = new Command();
 
@@ -873,4 +873,122 @@ program
     }
   });
 
+// ── Brain command ────────────────────────────────────────────
+
+program
+  .command('brain')
+  .description('Show agent memory/brain status from DeepBrain')
+  .option('--url <url>', 'DeepBrain server URL', 'http://localhost:3333')
+  .action(async (opts: { url: string }) => {
+    console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
+    try {
+      const res = await fetch(`${opts.url}/api/stats`);
+      if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`);
+      const stats = (await res.json()) as Record<string, any>;
+      const rows: [string, string][] = [
+        ['Total Pages', String(stats.totalPages ?? stats.pages ?? '-')],
+        ['Total Chunks', String(stats.totalChunks ?? stats.chunks ?? '-')],
+        ['Memory Tiers', String(stats.memoryTiers ?? stats.tiers ?? '-')],
+        ['Index Size', stats.indexSize ?? '-'],
+        ['Last Updated', stats.lastUpdated ?? stats.updatedAt ?? '-'],
+      ];
+      const maxKey = Math.max(...rows.map(([k]) => k.length));
+      for (const [key, val] of rows) {
+        console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+      }
+      console.log();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
+        console.log(`  ${icon.warn} Cannot connect to DeepBrain at ${opts.url}`);
+        console.log(`  ${color.dim('Is the server running? Start with: deepbrain serve')}\n`);
+      } else {
+        console.error(`  ${icon.error} ${msg}\n`);
+      }
+    }
+  });
+
+// ── Logs command ─────────────────────────────────────────────
+
+program
+  .command('logs')
+  .description('Show recent agent traces')
+  .option('-n, --limit <n>', 'Number of spans to show', '20')
+  .option('-f, --follow', 'Keep watching for new spans')
+  .action(async (opts: { limit: string; follow?: boolean }) => {
+    const { TraceCollector } = await import('./traces');
+    const collector = new TraceCollector();
+    const limit = parseInt(opts.limit) || 20;
+
+    const printSpans = (spans: readonly Span[]) => {
+      const slice = spans.slice(-limit);
+      if (slice.length === 0) {
+        console.log(`  ${icon.info} No traces yet. Interact with the agent to generate traces.`);
+        return;
+      }
+      for (const span of slice) {
+        const duration = span.endTime
+          ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
+          : 'ongoing';
+        const statusIcon = span.status === 'ok' ? icon.success : span.status === 'error' ? icon.error : color.dim('○');
+        const time = span.startTime.toLocaleTimeString();
+        console.log(`  ${statusIcon} ${color.dim(time)} ${color.bold(span.name)} ${color.dim(duration)}`);
+      }
+    };
+
+    console.log(`\n${icon.gear} ${color.bold('Agent Traces')}\n`);
+    const spans = collector.getBufferedSpans();
+    printSpans(spans);
+
+    if (opts.follow) {
+      console.log(`\n  ${color.dim('Watching for new traces... (Ctrl+C to stop)')}\n`);
+      let lastCount = spans.length;
+      const interval = setInterval(() => {
+        const current = collector.getBufferedSpans();
+        if (current.length > lastCount) {
+          const newSpans = current.slice(lastCount);
+          printSpans(newSpans);
+          lastCount = current.length;
+        }
+      }, 1000);
+      process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+    } else {
+      console.log();
+    }
+  });
+
+// ── Score command ────────────────────────────────────────────
+
+program
+  .command('score')
+  .description('Show agent performance score')
+  .action(async () => {
+    console.log(`\n${icon.gear} ${color.bold('Agent Performance Score')}\n`);
+    try {
+      const engine = new AnalyticsEngine('.');
+      const stats = engine.getStats();
+      if (!stats || stats.totalMessages === 0) {
+        console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+        return;
+      }
+      const errorRate = stats.totalMessages > 0 ? (stats.totalErrors / stats.totalMessages) : 0;
+      const rows: [string, string][] = [
+        ['Total Messages', String(stats.totalMessages)],
+        ['Total LLM Calls', String(stats.totalLLMCalls)],
+        ['Total Tool Uses', String(stats.totalToolUses)],
+        ['Avg Response Time', `${stats.avgResponseTimeMs}ms`],
+        ['Error Rate', `${(errorRate * 100).toFixed(1)}%`],
+        ['Token Usage', `${stats.totalTokens.total} tokens (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`],
+      ];
+      const maxKey = Math.max(...rows.map(([k]) => k.length));
+      for (const [key, val] of rows) {
+        console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+      }
+      console.log();
+    } catch {
+      console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+    }
+  });
+
 program.parse();
+

package/src/core/streaming.ts

@@ -0,0 +1,195 @@
+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/deploy/openclaw.ts

@@ -80,16 +80,6 @@ function generateAgentsMd(oad: OADDocument): string {
   }
   md += `\n`;
 
-  // DTV
-  if (dtv) {
-    md += `## Trust & Value\n\n`;
-    md += `- Trust Level: ${dtv.trust?.level ?? 'sandbox'}\n`;
-    if (dtv.value?.metrics?.length) {
-      md += `- Metrics: ${dtv.value.metrics.join(', ')}\n`;
-    }
-    md += `\n`;
-  }
-
   return md;
 }
 
@@ -198,3 +188,13 @@ export function deployToOpenClaw(options: DeployOptions): DeployResult {
 
   return result;
 }
+:`, err);
+      }
+    } else {
+      console.error(`Warning: OpenClaw config not found at ${configPath}`);
+      console.error(`Run 'openclaw init' first, then re-run with --install`);
+    }
+  }
+
+  return result;
+}

package/src/index.ts

@@ -52,8 +52,6 @@ export type { Locale } from './i18n';
 export { KnowledgeBase } from './core/knowledge';
 export { deployToHermes } from './deploy/hermes';
 export type { HermesDeployOptions, HermesDeployResult } from './deploy/hermes';
-export { publishAgent, installAgent } from './marketplace';
-export type { AgentManifest, PublishOptions, InstallOptions } from './marketplace';
 
 // v0.7.0 modules
 export { createAuthMiddleware, getActiveSessions } from './core/auth';
@@ -108,3 +106,15 @@ export { DiscordChannel } from './channels/discord';
 export type { DiscordChannelConfig } from './channels/discord';
 export { ProcessWatcher } from './core/watch';
 export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';
+export { ProcessWatcher } from './core/watch';
+export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';
+
+// v1.2.0 modules
+export { ToolGateway } from './tools/gateway';
+export type { ToolGatewayConfig, GatewayToolName } from './tools/gateway';
+export { StreamingManager, StreamableResponse } from './core/streaming';
+export type { StreamChunk, StreamOptions } from './core/streaming';
+
+// v1.3.0 modules
+export { TraceCollector, ConsoleExporter, DeepBrainExporter } from './traces';
+export type { Span, SpanEvent, TraceExporter } from './traces';

package/src/schema/oad.ts

@@ -151,5 +151,4 @@ export type SkillRef = z.infer<typeof SkillRefSchema>;
 export type Channel = z.infer<typeof ChannelSchema>;
 export type Metadata = z.infer<typeof MetadataSchema>;
 export type Spec = z.infer<typeof SpecSchema>;
-export type DTVConfig = z.infer<typeof DTVSchema>;
-export type TrustLevelType = z.infer<typeof TrustLevel>;
+export type TrustLevelType = string;

package/src/templates/code-reviewer.ts

@@ -25,10 +25,6 @@ export function createCodeReviewerConfig() {
       ],
       channels: [{ type: 'web' as const, port: 3000 }],
       memory: { shortTerm: true, longTerm: false },
-      dtv: {
-        trust: { level: 'sandbox' as const },
-        value: { metrics: ['reviews_completed', 'issues_found'] },
-      },
     },
   };
 }

package/src/templates/customer-service.ts

@@ -71,10 +71,6 @@ export function createCustomerServiceConfig() {
       ],
       channels: [{ type: 'web' as const, port: 3000 }],
       memory: { shortTerm: true, longTerm: false },
-      dtv: {
-        trust: { level: 'sandbox' as const },
-        value: { metrics: ['response_time', 'satisfaction_score'] },
-      },
     },
   };
 }

package/src/templates/data-analyst.ts

@@ -61,10 +61,6 @@ export function createDataAnalystConfig() {
       ],
       channels: [{ type: 'web' as const, port: 3000 }],
       memory: { shortTerm: true, longTerm: true },
-      dtv: {
-        trust: { level: 'sandbox' as const },
-        value: { metrics: ['queries_processed', 'insights_generated'] },
-      },
     },
   };
 }

package/src/templates/knowledge-base.ts

@@ -22,10 +22,6 @@ export function createKnowledgeBaseConfig() {
       ],
       channels: [{ type: 'web' as const, port: 3000 }],
       memory: { shortTerm: true, longTerm: { provider: 'deepbrain' as const, collection: 'company-knowledge' } },
-      dtv: {
-        trust: { level: 'sandbox' as const },
-        value: { metrics: ['queries_answered', 'docs_indexed'] },
-      },
     },
   };
 }

package/src/templates/sales-assistant.ts

@@ -70,10 +70,6 @@ export function createSalesAssistantConfig() {
       ],
       channels: [{ type: 'web' as const, port: 3000 }],
       memory: { shortTerm: true, longTerm: false },
-      dtv: {
-        trust: { level: 'sandbox' as const },
-        value: { metrics: ['leads_captured', 'appointments_booked'] },
-      },
     },
   };
 }

package/src/templates/teacher.ts

@@ -70,10 +70,6 @@ export function createTeacherConfig() {
       ],
       channels: [{ type: 'web' as const, port: 3000 }],
       memory: { shortTerm: true, longTerm: true },
-      dtv: {
-        trust: { level: 'sandbox' as const },
-        value: { metrics: ['lessons_created', 'quizzes_generated', 'concepts_explained'] },
-      },
     },
   };
 }

package/src/tools/gateway.ts

@@ -0,0 +1,220 @@
+import type { AgentContext } from '../core/types';
+import type { MCPTool, MCPToolDefinition, MCPToolResult } from './mcp';
+
+// ─── Gateway Types ───────────────────────────────────────────
+
+export interface ToolGatewayConfig {
+  enabled: boolean;
+  endpoint: string;
+  apiKey: string;
+  enabledTools?: GatewayToolName[];
+  timeout?: number;
+}
+
+export type GatewayToolName = 'web-search' | 'image-gen' | 'tts' | 'browser';
+
+interface GatewayToolMeta {
+  name: GatewayToolName;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  available: boolean;
+}
+
+interface GatewayResponse {
+  content: string;
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+// ─── Gateway Tool Wrapper ────────────────────────────────────
+
+class GatewayTool implements MCPTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+
+  constructor(
+    private gateway: ToolGateway,
+    private meta: GatewayToolMeta,
+  ) {
+    this.name = `gateway:${meta.name}`;
+    this.description = `[Gateway] ${meta.description}`;
+    this.inputSchema = meta.inputSchema;
+  }
+
+  async execute(input: Record<string, unknown>, _context?: AgentContext): Promise<MCPToolResult> {
+    return this.gateway.invokeTool(this.meta.name, input);
+  }
+}
+
+// ─── Default Tool Definitions ────────────────────────────────
+
+const DEFAULT_TOOL_DEFS: GatewayToolMeta[] = [
+  {
+    name: 'web-search',
+    description: 'Search the web and return results',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        count: { type: 'number', description: 'Number of results (1-10)' },
+      },
+      required: ['query'],
+    },
+    available: true,
+  },
+  {
+    name: 'image-gen',
+    description: 'Generate images from text prompts',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'Image generation prompt' },
+        size: { type: 'string', description: 'Image size (e.g. 1024x1024)' },
+      },
+      required: ['prompt'],
+    },
+    available: true,
+  },
+  {
+    name: 'tts',
+    description: 'Convert text to speech audio',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'Text to synthesize' },
+        voice: { type: 'string', description: 'Voice identifier' },
+      },
+      required: ['text'],
+    },
+    available: true,
+  },
+  {
+    name: 'browser',
+    description: 'Automated browser actions — navigate, screenshot, extract content',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', description: 'Action: navigate | screenshot | extract' },
+        url: { type: 'string', description: 'Target URL' },
+        selector: { type: 'string', description: 'CSS selector for extraction' },
+      },
+      required: ['action', 'url'],
+    },
+    available: true,
+  },
+];
+
+// ─── ToolGateway ─────────────────────────────────────────────
+
+export class ToolGateway {
+  private config: ToolGatewayConfig;
+  private availableTools: Map<GatewayToolName, GatewayToolMeta> = new Map();
+  private connected = false;
+
+  constructor(config: ToolGatewayConfig) {
+    this.config = {
+      timeout: 30_000,
+      ...config,
+    };
+  }
+
+  /** Discover available tools from the gateway endpoint. */
+  async connect(): Promise<void> {
+    if (!this.config.enabled) return;
+
+    try {
+      const res = await fetch(`${this.config.endpoint}/tools`, {
+        headers: { Authorization: `Bearer ${this.config.apiKey}` },
+        signal: AbortSignal.timeout(this.config.timeout!),
+      });
+
+      if (!res.ok) {
+        throw new Error(`Gateway returned ${res.status}`);
+      }
+
+      const data = (await res.json()) as { tools: GatewayToolMeta[] };
+      const enabledSet = this.config.enabledTools
+        ? new Set(this.config.enabledTools)
+        : null;
+
+      for (const tool of data.tools) {
+        if (!enabledSet || enabledSet.has(tool.name)) {
+          this.availableTools.set(tool.name, tool);
+        }
+      }
+      this.connected = true;
+    } catch {
+      // Auto-detect failed — fall back to default definitions
+      this.loadDefaults();
+      this.connected = false;
+    }
+  }
+
+  /** Load default tool definitions (used as fallback). */
+  private loadDefaults(): void {
+    const enabledSet = this.config.enabledTools
+      ? new Set(this.config.enabledTools)
+      : null;
+
+    for (const def of DEFAULT_TOOL_DEFS) {
+      if (!enabledSet || enabledSet.has(def.name)) {
+        this.availableTools.set(def.name, def);
+      }
+    }
+  }
+
+  /** Invoke a tool through the gateway. */
+  async invokeTool(name: GatewayToolName, input: Record<string, unknown>): Promise<MCPToolResult> {
+    try {
+      const res = await fetch(`${this.config.endpoint}/tools/${name}/invoke`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.config.apiKey}`,
+        },
+        body: JSON.stringify({ input }),
+        signal: AbortSignal.timeout(this.config.timeout!),
+      });
+
+      if (!res.ok) {
+        return { content: `Gateway error: HTTP ${res.status}`, isError: true };
+      }
+
+      const data = (await res.json()) as GatewayResponse;
+      if (data.error) {
+        return { content: data.error, isError: true, metadata: data.metadata };
+      }
+      return { content: data.content, metadata: data.metadata };
+    } catch (err) {
+      return {
+        content: `Gateway invocation failed: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true,
+      };
+    }
+  }
+
+  /** Get all gateway tools as MCPTool instances for registry integration. */
+  getTools(): MCPTool[] {
+    return Array.from(this.availableTools.values()).map(
+      (meta) => new GatewayTool(this, meta),
+    );
+  }
+
+  /** Get tool definitions (without execute). */
+  listTools(): MCPToolDefinition[] {
+    return Array.from(this.availableTools.values()).map(({ name, description, inputSchema }) => ({
+      name: `gateway:${name}`,
+      description: `[Gateway] ${description}`,
+      inputSchema,
+    }));
+  }
+
+  get isConnected(): boolean {
+    return this.connected;
+  }
+
+  get toolCount(): number {
+    return this.availableTools.size;
+  }
+}