opc-agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const runtime_1 = require("./core/runtime");
+const customer_service_1 = require("./templates/customer-service");
+const customer_service_2 = require("./templates/customer-service");
+const program = new commander_1.Command();
+program
+    .name('opc')
+    .description('OPC Agent — Open Agent Framework for business workstations')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Initialize a new OPC agent project')
+    .argument('[name]', 'Project name', 'my-agent')
+    .option('-t, --template <template>', 'Template to use', 'customer-service')
+    .action(async (name, opts) => {
+    const dir = path.resolve(name);
+    if (fs.existsSync(dir)) {
+        console.error(`Directory ${name} already exists.`);
+        process.exit(1);
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    const config = (0, customer_service_1.createCustomerServiceConfig)();
+    config.metadata.name = name;
+    fs.writeFileSync(path.join(dir, 'oad.yaml'), yaml.dump(config, { lineWidth: 120 }));
+    fs.writeFileSync(path.join(dir, 'README.md'), `# ${name}\n\nCreated with OPC Agent.\n\n## Run\n\n\`\`\`bash\nopc run\n\`\`\`\n`);
+    console.log(`✅ Created agent project: ${name}/`);
+    console.log(`   📄 oad.yaml — Agent definition`);
+    console.log(`   📖 README.md`);
+    console.log(`\nNext: cd ${name} && opc run`);
+});
+program
+    .command('create')
+    .description('Create an agent from a template')
+    .argument('<name>', 'Agent name')
+    .option('-t, --template <template>', 'Template', 'customer-service')
+    .action(async (name) => {
+    const config = (0, customer_service_1.createCustomerServiceConfig)();
+    config.metadata.name = name;
+    const outFile = `${name}-oad.yaml`;
+    fs.writeFileSync(outFile, yaml.dump(config, { lineWidth: 120 }));
+    console.log(`✅ Created ${outFile}`);
+});
+program
+    .command('build')
+    .description('Validate OAD and compile')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    try {
+        const runtime = new runtime_1.AgentRuntime();
+        const config = await runtime.loadConfig(opts.file);
+        console.log(`✅ Valid OAD: ${config.metadata.name} v${config.metadata.version}`);
+    }
+    catch (err) {
+        console.error('❌ Invalid OAD:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command('test')
+    .description('Run agent in sandbox mode')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    console.log('🧪 Running agent in sandbox mode...');
+    const runtime = new runtime_1.AgentRuntime();
+    await runtime.loadConfig(opts.file);
+    const agent = await runtime.initialize();
+    runtime.registerSkill(new customer_service_2.FAQSkill());
+    runtime.registerSkill(new customer_service_2.HandoffSkill());
+    console.log(`✅ Agent "${agent.name}" initialized in sandbox.`);
+    console.log(`   State: ${agent.state}`);
+    console.log(`   Send test message...`);
+    const response = await agent.handleMessage({
+        id: 'test_1',
+        role: 'user',
+        content: 'What are your business hours?',
+        timestamp: Date.now(),
+    });
+    console.log(`   Response: ${response.content}`);
+    console.log('✅ Sandbox test passed.');
+});
+program
+    .command('run')
+    .description('Start agent with channels')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    const runtime = new runtime_1.AgentRuntime();
+    await runtime.loadConfig(opts.file);
+    await runtime.initialize();
+    runtime.registerSkill(new customer_service_2.FAQSkill());
+    runtime.registerSkill(new customer_service_2.HandoffSkill());
+    await runtime.start();
+    const agent = runtime.getAgent();
+    console.log(`🚀 Agent "${agent?.name}" is running.`);
+    process.on('SIGINT', async () => {
+        console.log('\nShutting down...');
+        await runtime.stop();
+        process.exit(0);
+    });
+});
+program
+    .command('publish')
+    .description('Validate and package for OPC Registry (stub)')
+    .action(async () => {
+    console.log('📦 Publishing is not yet available. Coming soon in OPC Registry v1.');
+});
+program.parse();
+//# sourceMappingURL=cli.js.map

package/dist/core/agent.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from 'events';
+import type { AgentState, IAgent, IChannel, ISkill, Message, MemoryStore } from './types';
+export declare class BaseAgent extends EventEmitter implements IAgent {
+    readonly name: string;
+    private _state;
+    private skills;
+    private channels;
+    private memory;
+    private provider;
+    private systemPrompt;
+    constructor(options: {
+        name: string;
+        systemPrompt?: string;
+        provider?: string;
+        model?: string;
+        memory?: MemoryStore;
+    });
+    get state(): AgentState;
+    private transition;
+    init(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    registerSkill(skill: ISkill): void;
+    bindChannel(channel: IChannel): void;
+    handleMessage(message: Message): Promise<Message>;
+    private createResponse;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/core/agent.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAgent = void 0;
+const events_1 = require("events");
+const memory_1 = require("../memory");
+const providers_1 = require("../providers");
+class BaseAgent extends events_1.EventEmitter {
+    name;
+    _state = 'init';
+    skills = new Map();
+    channels = [];
+    memory;
+    provider;
+    systemPrompt;
+    constructor(options) {
+        super();
+        this.name = options.name;
+        this.systemPrompt = options.systemPrompt ?? 'You are a helpful AI agent.';
+        this.memory = options.memory ?? new memory_1.InMemoryStore();
+        this.provider = (0, providers_1.createProvider)(options.provider ?? 'deepseek', options.model ?? 'deepseek-chat');
+    }
+    get state() {
+        return this._state;
+    }
+    transition(to) {
+        const from = this._state;
+        this._state = to;
+        this.emit('state:change', from, to);
+    }
+    async init() {
+        this.transition('ready');
+    }
+    async start() {
+        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() {
+        for (const channel of this.channels) {
+            await channel.stop();
+        }
+        this.transition('stopped');
+    }
+    registerSkill(skill) {
+        this.skills.set(skill.name, skill);
+    }
+    bindChannel(channel) {
+        this.channels.push(channel);
+    }
+    async handleMessage(message) {
+        this.emit('message:in', message);
+        const sessionId = message.metadata?.sessionId ?? 'default';
+        await this.memory.addMessage(sessionId, message);
+        const context = {
+            agentName: this.name,
+            sessionId,
+            messages: await this.memory.getConversation(sessionId),
+            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;
+    }
+    createResponse(content, inReplyTo) {
+        return {
+            id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            role: 'assistant',
+            content,
+            timestamp: Date.now(),
+            metadata: { inReplyTo: inReplyTo.id },
+        };
+    }
+}
+exports.BaseAgent = BaseAgent;
+//# sourceMappingURL=agent.js.map

package/dist/core/config.d.ts

@@ -0,0 +1,4 @@
+import { type OADDocument } from '../schema/oad';
+export declare function loadOAD(filePath: string): OADDocument;
+export declare function validateOAD(data: unknown): OADDocument;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOAD = loadOAD;
+exports.validateOAD = validateOAD;
+const fs = __importStar(require("fs"));
+const yaml = __importStar(require("js-yaml"));
+const oad_1 = require("../schema/oad");
+function loadOAD(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    const data = (ext === 'yaml' || ext === 'yml') ? yaml.load(raw) : JSON.parse(raw);
+    return oad_1.OADSchema.parse(data);
+}
+function validateOAD(data) {
+    return oad_1.OADSchema.parse(data);
+}
+//# sourceMappingURL=config.js.map

package/dist/core/runtime.d.ts

@@ -0,0 +1,14 @@
+import { BaseAgent } from './agent';
+import type { OADDocument } from '../schema/oad';
+import type { ISkill } from './types';
+export declare class AgentRuntime {
+    private agent;
+    private config;
+    loadConfig(filePath: string): Promise<OADDocument>;
+    initialize(config?: OADDocument): Promise<BaseAgent>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    registerSkill(skill: ISkill): void;
+    getAgent(): BaseAgent | null;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/core/runtime.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRuntime = void 0;
+const agent_1 = require("./agent");
+const config_1 = require("./config");
+const web_1 = require("../channels/web");
+class AgentRuntime {
+    agent = null;
+    config = null;
+    async loadConfig(filePath) {
+        this.config = (0, config_1.loadOAD)(filePath);
+        return this.config;
+    }
+    async initialize(config) {
+        const cfg = config ?? this.config;
+        if (!cfg)
+            throw new Error('No config loaded. Call loadConfig() first.');
+        this.agent = new agent_1.BaseAgent({
+            name: cfg.metadata.name,
+            systemPrompt: cfg.spec.systemPrompt,
+            provider: cfg.spec.provider?.default,
+            model: cfg.spec.model,
+        });
+        // Bind channels
+        for (const ch of cfg.spec.channels) {
+            if (ch.type === 'web') {
+                const port = ch.port ?? 3000;
+                this.agent.bindChannel(new web_1.WebChannel(port));
+            }
+        }
+        await this.agent.init();
+        return this.agent;
+    }
+    async start() {
+        if (!this.agent)
+            throw new Error('Agent not initialized.');
+        await this.agent.start();
+    }
+    async stop() {
+        if (!this.agent)
+            return;
+        await this.agent.stop();
+    }
+    registerSkill(skill) {
+        if (!this.agent)
+            throw new Error('Agent not initialized.');
+        this.agent.registerSkill(skill);
+    }
+    getAgent() {
+        return this.agent;
+    }
+}
+exports.AgentRuntime = AgentRuntime;
+//# sourceMappingURL=runtime.js.map

package/dist/core/types.d.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'events';
+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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/dtv/data.d.ts

@@ -0,0 +1,18 @@
+export interface DataSource {
+    readonly name: string;
+    readonly type: string;
+    read(key: string): Promise<unknown>;
+}
+/**
+ * MRGConfig reader — read-only data layer for agents.
+ * Agents can read business data but cannot modify source systems.
+ */
+export declare class MRGConfigReader implements DataSource {
+    readonly name = "mrg-config";
+    readonly type = "config";
+    private data;
+    constructor(initial?: Record<string, unknown>);
+    read(key: string): Promise<unknown>;
+    load(data: Record<string, unknown>): void;
+}
+//# sourceMappingURL=data.d.ts.map

package/dist/dtv/data.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MRGConfigReader = void 0;
+/**
+ * MRGConfig reader — read-only data layer for agents.
+ * Agents can read business data but cannot modify source systems.
+ */
+class MRGConfigReader {
+    name = 'mrg-config';
+    type = 'config';
+    data;
+    constructor(initial) {
+        this.data = new Map(Object.entries(initial ?? {}));
+    }
+    async read(key) {
+        return this.data.get(key);
+    }
+    load(data) {
+        for (const [k, v] of Object.entries(data)) {
+            this.data.set(k, v);
+        }
+    }
+}
+exports.MRGConfigReader = MRGConfigReader;
+//# sourceMappingURL=data.js.map

package/dist/dtv/trust.d.ts

@@ -0,0 +1,19 @@
+import type { TrustLevelType } from '../schema/oad';
+/**
+ * Trust levels: sandbox → verified → certified → listed
+ *
+ * - sandbox:   No network, no file system, limited capabilities
+ * - verified:  Identity verified, basic capabilities
+ * - certified: Passed security audit, full capabilities
+ * - listed:    Published in OPC marketplace
+ */
+export declare class TrustManager {
+    private level;
+    constructor(level?: TrustLevelType);
+    getLevel(): TrustLevelType;
+    canAccessNetwork(): boolean;
+    canAccessFileSystem(): boolean;
+    canPublish(): boolean;
+    upgrade(to: TrustLevelType): void;
+}
+//# sourceMappingURL=trust.d.ts.map

package/dist/dtv/trust.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustManager = void 0;
+/**
+ * Trust levels: sandbox → verified → certified → listed
+ *
+ * - sandbox:   No network, no file system, limited capabilities
+ * - verified:  Identity verified, basic capabilities
+ * - certified: Passed security audit, full capabilities
+ * - listed:    Published in OPC marketplace
+ */
+class TrustManager {
+    level;
+    constructor(level = 'sandbox') {
+        this.level = level;
+    }
+    getLevel() {
+        return this.level;
+    }
+    canAccessNetwork() {
+        return this.level !== 'sandbox';
+    }
+    canAccessFileSystem() {
+        return this.level === 'certified' || this.level === 'listed';
+    }
+    canPublish() {
+        return this.level === 'listed';
+    }
+    upgrade(to) {
+        const order = ['sandbox', 'verified', 'certified', 'listed'];
+        const currentIdx = order.indexOf(this.level);
+        const targetIdx = order.indexOf(to);
+        if (targetIdx <= currentIdx) {
+            throw new Error(`Cannot downgrade trust from ${this.level} to ${to}`);
+        }
+        this.level = to;
+    }
+}
+exports.TrustManager = TrustManager;
+//# sourceMappingURL=trust.js.map

package/dist/dtv/value.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Value tracking — metrics and ROI for agent operations.
+ */
+export interface ValueMetric {
+    name: string;
+    value: number;
+    unit: string;
+    timestamp: number;
+}
+export declare class ValueTracker {
+    private metrics;
+    private trackedNames;
+    constructor(metricNames?: string[]);
+    record(name: string, value: number, unit?: string): void;
+    getMetrics(name: string): ValueMetric[];
+    getAverage(name: string): number;
+    getSummary(): Record<string, {
+        count: number;
+        average: number;
+        last: number;
+    }>;
+}
+//# sourceMappingURL=value.d.ts.map

package/dist/dtv/value.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueTracker = void 0;
+class ValueTracker {
+    metrics = new Map();
+    trackedNames;
+    constructor(metricNames = []) {
+        this.trackedNames = new Set(metricNames);
+    }
+    record(name, value, unit = '') {
+        if (!this.metrics.has(name)) {
+            this.metrics.set(name, []);
+        }
+        this.metrics.get(name).push({ name, value, unit, timestamp: Date.now() });
+    }
+    getMetrics(name) {
+        return this.metrics.get(name) ?? [];
+    }
+    getAverage(name) {
+        const m = this.getMetrics(name);
+        if (m.length === 0)
+            return 0;
+        return m.reduce((sum, v) => sum + v.value, 0) / m.length;
+    }
+    getSummary() {
+        const result = {};
+        for (const [name, values] of this.metrics) {
+            result[name] = {
+                count: values.length,
+                average: this.getAverage(name),
+                last: values[values.length - 1]?.value ?? 0,
+            };
+        }
+        return result;
+    }
+}
+exports.ValueTracker = ValueTracker;
+//# sourceMappingURL=value.js.map

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { BaseAgent } from './core/agent';
+export { AgentRuntime } from './core/runtime';
+export { loadOAD, validateOAD } from './core/config';
+export { OADSchema } from './schema/oad';
+export type { OADDocument, Metadata, Spec, DTVConfig, TrustLevelType } from './schema/oad';
+export type { IAgent, IChannel, ISkill, Message, AgentContext, SkillResult, MemoryStore, AgentState } from './core/types';
+export { BaseChannel } from './channels';
+export { WebChannel } from './channels/web';
+export { BaseSkill } from './skills/base';
+export { SkillRegistry } from './skills';
+export { InMemoryStore } from './memory';
+export { TrustManager } from './dtv/trust';
+export { ValueTracker } from './dtv/value';
+export { MRGConfigReader } from './dtv/data';
+export { createProvider, SUPPORTED_PROVIDERS } from './providers';
+//# sourceMappingURL=index.d.ts.map