opc-agent 3.0.0 → 4.0.0

package/dist/tools/builtin/rl-tools.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rlTools = exports.rlResetEpisode = exports.rlGetStatistics = exports.rlUpdatePolicy = exports.rlExplorationSuggest = exports.rlRewardSignal = exports.rlGenerateTrainingData = exports.rlCompareStrategies = exports.rlGetBestStrategy = exports.rlEvaluateOutcome = exports.rlRecordTrajectory = void 0;
+const trajectories = [];
+const policies = new Map();
+let currentEpisode = null;
+function getOrCreateEpisode(taskType) {
+    if (!currentEpisode || currentEpisode.taskType !== taskType) {
+        currentEpisode = {
+            id: `ep_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            taskType,
+            actions: [],
+            totalReward: 0,
+        };
+        trajectories.push(currentEpisode);
+    }
+    return currentEpisode;
+}
+exports.rlRecordTrajectory = {
+    name: 'rl_record_trajectory',
+    description: 'Record action sequences and outcomes for RL training',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            taskType: { type: 'string' },
+            action: { type: 'string' },
+            outcome: { type: 'string', enum: ['success', 'partial', 'failure'] },
+        },
+        required: ['taskType', 'action'],
+    },
+    async execute(input) {
+        const ep = getOrCreateEpisode(input.taskType);
+        ep.actions.push({ action: input.action, timestamp: Date.now() });
+        if (input.outcome)
+            ep.outcome = input.outcome;
+        return { content: JSON.stringify({ episodeId: ep.id, actionsRecorded: ep.actions.length }) };
+    },
+};
+exports.rlEvaluateOutcome = {
+    name: 'rl_evaluate_outcome',
+    description: "Score an action's outcome (success/partial/failure)",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            episodeId: { type: 'string' },
+            outcome: { type: 'string', enum: ['success', 'partial', 'failure'] },
+        },
+        required: ['outcome'],
+    },
+    async execute(input) {
+        const ep = input.episodeId
+            ? trajectories.find(t => t.id === input.episodeId)
+            : currentEpisode;
+        if (!ep)
+            return { content: 'No active episode found', isError: true };
+        ep.outcome = input.outcome;
+        const score = ep.outcome === 'success' ? 1 : ep.outcome === 'partial' ? 0.5 : 0;
+        return { content: JSON.stringify({ episodeId: ep.id, outcome: ep.outcome, score }) };
+    },
+};
+exports.rlGetBestStrategy = {
+    name: 'rl_get_best_strategy',
+    description: 'Retrieve best-performing strategy for a task type',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' } },
+        required: ['taskType'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        const relevant = trajectories.filter(t => t.taskType === taskType && t.outcome === 'success');
+        if (relevant.length === 0)
+            return { content: JSON.stringify({ strategy: null, message: 'No successful strategies found' }) };
+        const best = relevant.reduce((a, b) => a.totalReward >= b.totalReward ? a : b);
+        return { content: JSON.stringify({ strategy: best.actions.map(a => a.action), totalReward: best.totalReward }) };
+    },
+};
+exports.rlCompareStrategies = {
+    name: 'rl_compare_strategies',
+    description: 'Compare multiple strategies by success rate',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' } },
+        required: ['taskType'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        const relevant = trajectories.filter(t => t.taskType === taskType && t.outcome);
+        const total = relevant.length;
+        const successes = relevant.filter(t => t.outcome === 'success').length;
+        const partials = relevant.filter(t => t.outcome === 'partial').length;
+        const failures = relevant.filter(t => t.outcome === 'failure').length;
+        return {
+            content: JSON.stringify({
+                taskType, total, successRate: total ? successes / total : 0,
+                breakdown: { successes, partials, failures },
+            }),
+        };
+    },
+};
+exports.rlGenerateTrainingData = {
+    name: 'rl_generate_training_data',
+    description: 'Export trajectories as fine-tuning JSONL',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' }, minReward: { type: 'number' } },
+    },
+    async execute(input) {
+        let data = trajectories;
+        if (input.taskType)
+            data = data.filter(t => t.taskType === input.taskType);
+        if (input.minReward != null)
+            data = data.filter(t => t.totalReward >= input.minReward);
+        const jsonl = data.map(t => JSON.stringify({
+            messages: [
+                { role: 'system', content: `Task: ${t.taskType}` },
+                ...t.actions.map(a => ({ role: 'assistant', content: a.action })),
+            ],
+            outcome: t.outcome,
+            reward: t.totalReward,
+        })).join('\n');
+        return { content: jsonl || '(no data)' };
+    },
+};
+exports.rlRewardSignal = {
+    name: 'rl_reward_signal',
+    description: 'Record positive/negative reward for last action',
+    inputSchema: {
+        type: 'object',
+        properties: { reward: { type: 'number' }, reason: { type: 'string' } },
+        required: ['reward'],
+    },
+    async execute(input) {
+        if (!currentEpisode || currentEpisode.actions.length === 0) {
+            return { content: 'No current episode or actions to reward', isError: true };
+        }
+        const lastAction = currentEpisode.actions[currentEpisode.actions.length - 1];
+        lastAction.reward = input.reward;
+        currentEpisode.totalReward += input.reward;
+        return { content: JSON.stringify({ action: lastAction.action, reward: input.reward, totalReward: currentEpisode.totalReward }) };
+    },
+};
+exports.rlExplorationSuggest = {
+    name: 'rl_exploration_suggest',
+    description: 'Suggest alternative approaches (exploration)',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' }, currentAction: { type: 'string' } },
+        required: ['taskType'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        const allActions = new Set();
+        trajectories.filter(t => t.taskType === taskType).forEach(t => t.actions.forEach(a => allActions.add(a.action)));
+        const suggestions = Array.from(allActions).filter(a => a !== input.currentAction).slice(0, 5);
+        if (suggestions.length === 0) {
+            return { content: JSON.stringify({ suggestions: [], message: 'No alternative actions found. Try a completely new approach.' }) };
+        }
+        return { content: JSON.stringify({ suggestions }) };
+    },
+};
+exports.rlUpdatePolicy = {
+    name: 'rl_update_policy',
+    description: "Update agent's action preferences based on rewards",
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' }, action: { type: 'string' }, weight: { type: 'number' } },
+        required: ['taskType', 'action', 'weight'],
+    },
+    async execute(input) {
+        const taskType = input.taskType;
+        let policy = policies.get(taskType);
+        if (!policy) {
+            policy = { taskType, preferredActions: [], weights: {} };
+            policies.set(taskType, policy);
+        }
+        const action = input.action;
+        policy.weights[action] = (policy.weights[action] || 0) + input.weight;
+        policy.preferredActions = Object.entries(policy.weights)
+            .sort(([, a], [, b]) => b - a)
+            .map(([k]) => k);
+        return { content: JSON.stringify({ taskType, preferredActions: policy.preferredActions.slice(0, 5), weights: policy.weights }) };
+    },
+};
+exports.rlGetStatistics = {
+    name: 'rl_get_statistics',
+    description: 'Get success/failure stats by task type',
+    inputSchema: {
+        type: 'object',
+        properties: { taskType: { type: 'string' } },
+    },
+    async execute(input) {
+        let data = trajectories;
+        if (input.taskType)
+            data = data.filter(t => t.taskType === input.taskType);
+        const stats = {};
+        for (const t of data) {
+            if (!stats[t.taskType])
+                stats[t.taskType] = { total: 0, success: 0, partial: 0, failure: 0, avgReward: 0 };
+            const s = stats[t.taskType];
+            s.total++;
+            if (t.outcome === 'success')
+                s.success++;
+            else if (t.outcome === 'partial')
+                s.partial++;
+            else if (t.outcome === 'failure')
+                s.failure++;
+            s.avgReward = (s.avgReward * (s.total - 1) + t.totalReward) / s.total;
+        }
+        return { content: JSON.stringify(stats) };
+    },
+};
+exports.rlResetEpisode = {
+    name: 'rl_reset_episode',
+    description: 'Clear current episode state',
+    inputSchema: { type: 'object', properties: {} },
+    async execute() {
+        const had = currentEpisode != null;
+        currentEpisode = null;
+        return { content: JSON.stringify({ reset: true, hadActiveEpisode: had }) };
+    },
+};
+exports.rlTools = [
+    exports.rlRecordTrajectory, exports.rlEvaluateOutcome, exports.rlGetBestStrategy, exports.rlCompareStrategies,
+    exports.rlGenerateTrainingData, exports.rlRewardSignal, exports.rlExplorationSuggest, exports.rlUpdatePolicy,
+    exports.rlGetStatistics, exports.rlResetEpisode,
+];
+//# sourceMappingURL=rl-tools.js.map

package/dist/tools/builtin/vision.d.ts

@@ -0,0 +1,6 @@
+import type { MCPTool } from '../mcp';
+export declare const visionAnalyzeTool: MCPTool;
+export declare const visionExtractTextTool: MCPTool;
+export declare const visionCompareTool: MCPTool;
+export declare const visionTools: MCPTool[];
+//# sourceMappingURL=vision.d.ts.map

package/dist/tools/builtin/vision.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visionTools = exports.visionCompareTool = exports.visionExtractTextTool = exports.visionAnalyzeTool = void 0;
+const vision_1 = require("../../core/vision");
+const manager = new vision_1.VisionManager();
+exports.visionAnalyzeTool = {
+    name: 'vision_analyze',
+    description: 'Analyze an image using vision AI. Provide image as URL or base64.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            image_url: { type: 'string', description: 'URL of the image to analyze' },
+            image_base64: { type: 'string', description: 'Base64-encoded image data' },
+            prompt: { type: 'string', description: 'Optional prompt for analysis' },
+        },
+    },
+    async execute(input) {
+        const imgInput = input.image_url
+            ? { type: 'url', data: input.image_url }
+            : { type: 'base64', data: input.image_base64 };
+        const result = await manager.analyze(imgInput, input.prompt);
+        return { content: JSON.stringify(result) };
+    },
+};
+exports.visionExtractTextTool = {
+    name: 'vision_extract_text',
+    description: 'Extract text (OCR) from an image.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            image_url: { type: 'string', description: 'URL of the image' },
+            image_base64: { type: 'string', description: 'Base64-encoded image data' },
+        },
+    },
+    async execute(input) {
+        const imgInput = input.image_url
+            ? { type: 'url', data: input.image_url }
+            : { type: 'base64', data: input.image_base64 };
+        const text = await manager.extractText(imgInput);
+        return { content: text };
+    },
+};
+exports.visionCompareTool = {
+    name: 'vision_compare',
+    description: 'Compare multiple images.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            image_urls: { type: 'array', items: { type: 'string' }, description: 'URLs of images to compare' },
+            prompt: { type: 'string', description: 'Optional comparison prompt' },
+        },
+    },
+    async execute(input) {
+        const urls = input.image_urls;
+        const images = urls.map(url => ({ type: 'url', data: url }));
+        const result = await manager.compareImages(images, input.prompt);
+        return { content: result };
+    },
+};
+exports.visionTools = [exports.visionAnalyzeTool, exports.visionExtractTextTool, exports.visionCompareTool];
+//# sourceMappingURL=vision.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,8 +32,8 @@
     "url": "https://github.com/Deepleaper/opc-agent.git"
   },
   "dependencies": {
-    "agent-workstation": "^1.2.1",
-    "agentkits": "^0.1.0",
+    "agent-workstation": "^2.0.1",
+    "agentkits": "^2.0.0",
     "commander": "^12.0.0",
     "express": "^4.21.0",
     "js-yaml": "^4.1.0",

package/src/channels/dingtalk.ts

@@ -0,0 +1,46 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface DingTalkChannelConfig {
+  webhookUrl: string;
+  secret?: string;
+  appKey?: string;
+  appSecret?: string;
+}
+
+export class DingTalkChannel extends BaseChannel {
+  readonly type = 'dingtalk';
+  private config: DingTalkChannelConfig;
+  private running = false;
+
+  constructor(config: DingTalkChannelConfig) {
+    super();
+    if (!config.webhookUrl) {
+      throw new Error('DingTalkChannel requires webhookUrl in config');
+    }
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    if (!this.running) {
+      throw new Error('DingTalkChannel: not started. Call start() first.');
+    }
+    const body = JSON.stringify({ msgtype: 'text', text: { content: text } });
+    const res = await fetch(this.config.webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+    });
+    if (!res.ok) {
+      throw new Error(`DingTalk webhook failed: ${res.status}`);
+    }
+  }
+}

package/src/channels/googlechat.ts

@@ -0,0 +1,42 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface GoogleChatChannelConfig {
+  webhookUrl: string;
+}
+
+export class GoogleChatChannel extends BaseChannel {
+  readonly type = 'googlechat';
+  private config: GoogleChatChannelConfig;
+  private running = false;
+
+  constructor(config: GoogleChatChannelConfig) {
+    super();
+    if (!config.webhookUrl) {
+      throw new Error('GoogleChatChannel requires webhookUrl in config');
+    }
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+  }
+
+  async send(spaceId: string, text: string): Promise<void> {
+    if (!this.running) {
+      throw new Error('GoogleChatChannel: not started. Call start() first.');
+    }
+    const res = await fetch(this.config.webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text }),
+    });
+    if (!res.ok) {
+      throw new Error(`Google Chat webhook failed: ${res.status}`);
+    }
+  }
+}

package/src/channels/imessage.ts

@@ -0,0 +1,32 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface IMessageChannelConfig {
+  applescriptPath?: string;
+}
+
+export class IMessageChannel extends BaseChannel {
+  readonly type = 'imessage';
+  private config: IMessageChannelConfig;
+
+  constructor(config: IMessageChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('macOS iMessage CLI');
+    } catch {
+      throw new Error('Install macOS iMessage CLI to use the IMessageChannel. Run: npm install macOS iMessage CLI');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('IMessageChannel: not yet connected. Call start() first.');
+  }
+}

package/src/channels/irc.ts

@@ -0,0 +1,82 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface IRCChannelConfig {
+  host: string;
+  port?: number;
+  nick: string;
+  channels: string[];
+  tls?: boolean;
+  password?: string;
+}
+
+export class IRCChannel extends BaseChannel {
+  readonly type = 'irc';
+  private config: IRCChannelConfig;
+  private client: any = null;
+  private running = false;
+
+  constructor(config: IRCChannelConfig) {
+    super();
+    if (!config.host || !config.nick || !config.channels?.length) {
+      throw new Error('IRCChannel requires host, nick, and channels in config');
+    }
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    let IRC: any;
+    try {
+      IRC = require('irc-framework');
+    } catch {
+      throw new Error('Install irc-framework to use the IRCChannel. Run: npm install irc-framework');
+    }
+    this.client = new IRC.Client();
+    this.client.connect({
+      host: this.config.host,
+      port: this.config.port ?? (this.config.tls ? 6697 : 6667),
+      nick: this.config.nick,
+      tls: this.config.tls ?? false,
+      password: this.config.password,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      this.client.on('registered', () => {
+        for (const ch of this.config.channels) {
+          this.client.join(ch);
+        }
+        resolve();
+      });
+      this.client.on('error', (err: any) => reject(new Error(`IRC connection error: ${err.message || err}`)));
+    });
+
+    this.running = true;
+
+    this.client.on('privmsg', async (event: any) => {
+      if (!this.handler) return;
+      const msg: Message = {
+        id: Date.now().toString(),
+        role: 'user',
+        content: event.message,
+        timestamp: Date.now(),
+        metadata: { channel: event.target, nick: event.nick },
+      };
+      await this.handler(msg);
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (this.client) {
+      this.client.quit('Goodbye');
+      this.client = null;
+    }
+    this.running = false;
+  }
+
+  async send(target: string, text: string): Promise<void> {
+    if (!this.running || !this.client) {
+      throw new Error('IRCChannel: not started. Call start() first.');
+    }
+    this.client.say(target, text);
+  }
+}

package/src/channels/line.ts

@@ -0,0 +1,33 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface LINEChannelConfig {
+  channelAccessToken?: string;
+  channelSecret?: string;
+}
+
+export class LINEChannel extends BaseChannel {
+  readonly type = 'line';
+  private config: LINEChannelConfig;
+
+  constructor(config: LINEChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('@line/bot-sdk');
+    } catch {
+      throw new Error('Install @line/bot-sdk to use the LINEChannel. Run: npm install @line/bot-sdk');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('LINEChannel: not yet connected. Call start() first.');
+  }
+}

package/src/channels/matrix.ts

@@ -0,0 +1,34 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface MatrixChannelConfig {
+  homeserverUrl?: string;
+  accessToken?: string;
+  userId?: string;
+}
+
+export class MatrixChannel extends BaseChannel {
+  readonly type = 'matrix';
+  private config: MatrixChannelConfig;
+
+  constructor(config: MatrixChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('matrix-js-sdk');
+    } catch {
+      throw new Error('Install matrix-js-sdk to use the MatrixChannel. Run: npm install matrix-js-sdk');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('MatrixChannel: not yet connected. Call start() first.');
+  }
+}

package/src/channels/mattermost.ts

@@ -0,0 +1,57 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface MattermostChannelConfig {
+  serverUrl: string;
+  token: string;
+  teamId?: string;
+  defaultChannelId?: string;
+}
+
+export class MattermostChannel extends BaseChannel {
+  readonly type = 'mattermost';
+  private config: MattermostChannelConfig;
+  private running = false;
+  private ws: any = null;
+
+  constructor(config: MattermostChannelConfig) {
+    super();
+    if (!config.serverUrl || !config.token) {
+      throw new Error('MattermostChannel requires serverUrl and token in config');
+    }
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    // Verify connection by hitting the API
+    const res = await fetch(`${this.config.serverUrl}/api/v4/users/me`, {
+      headers: { Authorization: `Bearer ${this.config.token}` },
+    }).catch(() => null);
+    this.running = true;
+  }
+
+  async stop(): Promise<void> {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.running = false;
+  }
+
+  async send(channelId: string, text: string): Promise<void> {
+    if (!this.running) {
+      throw new Error('MattermostChannel: not started. Call start() first.');
+    }
+    const res = await fetch(`${this.config.serverUrl}/api/v4/posts`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.config.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ channel_id: channelId, message: text }),
+    });
+    if (!res.ok) {
+      throw new Error(`Mattermost API failed: ${res.status}`);
+    }
+  }
+}

package/src/channels/msteams.ts

@@ -0,0 +1,33 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface MSTeamsChannelConfig {
+  appId?: string;
+  appPassword?: string;
+}
+
+export class MSTeamsChannel extends BaseChannel {
+  readonly type = 'msteams';
+  private config: MSTeamsChannelConfig;
+
+  constructor(config: MSTeamsChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('botframework-connector');
+    } catch {
+      throw new Error('Install botframework-connector to use the MSTeamsChannel. Run: npm install botframework-connector');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('MSTeamsChannel: not yet connected. Call start() first.');
+  }
+}