opc-agent 1.4.0 → 1.4.1

package/dist/core/dashboard.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dashboard = void 0;
+const express_1 = __importDefault(require("express"));
+// ─── Dashboard Server ────────────────────────────────────────
+class Dashboard {
+    app = (0, express_1.default)();
+    server = null;
+    config;
+    startTime = Date.now();
+    stats = {
+        sessions: new Map(),
+        toolInvocations: new Map(),
+        channelStats: new Map(),
+    };
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            port: config.port ?? 4100,
+            host: config.host ?? '127.0.0.1',
+            cors: config.cors ?? false,
+        };
+        this.setupRoutes();
+    }
+    setupRoutes() {
+        if (this.config.cors) {
+            this.app.use((_req, res, next) => {
+                res.header('Access-Control-Allow-Origin', '*');
+                res.header('Access-Control-Allow-Headers', 'Content-Type');
+                next();
+            });
+        }
+        this.app.use(express_1.default.json());
+        // Health check
+        this.app.get('/api/health', (_req, res) => {
+            res.json({ status: 'ok', uptime: Date.now() - this.startTime });
+        });
+        // Overview state
+        this.app.get('/api/state', (_req, res) => {
+            res.json(this.getState());
+        });
+        // Sessions
+        this.app.get('/api/sessions', (_req, res) => {
+            res.json([...this.stats.sessions.values()]);
+        });
+        // Tools
+        this.app.get('/api/tools', (_req, res) => {
+            const tools = [];
+            for (const [name, stat] of this.stats.toolInvocations) {
+                tools.push({ name, type: 'builtin', enabled: true, invocations: stat.count, lastUsed: stat.lastUsed });
+            }
+            res.json(tools);
+        });
+        // Channels
+        this.app.get('/api/channels', (_req, res) => {
+            const channels = [];
+            for (const [name, stat] of this.stats.channelStats) {
+                channels.push({ name, type: name, connected: stat.connected, messageCount: stat.messages });
+            }
+            res.json(channels);
+        });
+        // Simple HTML dashboard
+        this.app.get('/', (_req, res) => {
+            res.send(this.renderHTML());
+        });
+    }
+    getState() {
+        return {
+            agent: { name: 'opc-agent', version: '1.3.0', status: 'running', uptime: Date.now() - this.startTime },
+            sessions: [...this.stats.sessions.values()],
+            tools: [...this.stats.toolInvocations.entries()].map(([name, s]) => ({
+                name, type: 'builtin', enabled: true, invocations: s.count, lastUsed: s.lastUsed,
+            })),
+            channels: [...this.stats.channelStats.entries()].map(([name, s]) => ({
+                name, type: name, connected: s.connected, messageCount: s.messages,
+            })),
+            memory: { provider: 'unknown', entries: 0 },
+            modelAuth: { providers: [] },
+        };
+    }
+    // ─── Event Tracking ──────────────────────────────────────
+    trackSession(session) {
+        this.stats.sessions.set(session.id, session);
+    }
+    trackToolCall(toolName) {
+        const existing = this.stats.toolInvocations.get(toolName) ?? { count: 0, lastUsed: 0 };
+        existing.count++;
+        existing.lastUsed = Date.now();
+        this.stats.toolInvocations.set(toolName, existing);
+    }
+    trackChannel(name, connected, messages) {
+        const existing = this.stats.channelStats.get(name) ?? { connected: false, messages: 0 };
+        existing.connected = connected;
+        if (messages !== undefined)
+            existing.messages = messages;
+        this.stats.channelStats.set(name, existing);
+    }
+    // ─── Lifecycle ───────────────────────────────────────────
+    async start() {
+        if (!this.config.enabled)
+            return;
+        return new Promise((resolve) => {
+            this.server = this.app.listen(this.config.port, this.config.host, () => {
+                console.log(`[dashboard] http://${this.config.host}:${this.config.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server)
+                this.server.close(() => resolve());
+            else
+                resolve();
+        });
+    }
+    renderHTML() {
+        return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>OPC Agent Dashboard</title>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:system-ui,-apple-system,sans-serif;background:#0a0a0f;color:#e0e0e0;padding:24px}
+h1{font-size:1.5rem;margin-bottom:20px;color:#7c9aff}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px}
+.card{background:#14141f;border:1px solid #2a2a3a;border-radius:12px;padding:20px}
+.card h2{font-size:0.85rem;text-transform:uppercase;letter-spacing:1px;color:#888;margin-bottom:12px}
+.stat{font-size:2rem;font-weight:700;color:#7c9aff}
+.sub{font-size:0.8rem;color:#666;margin-top:4px}
+#data{margin-top:20px;font-family:monospace;font-size:0.75rem;color:#555;white-space:pre-wrap}
+</style></head><body>
+<h1>⚡ OPC Agent Dashboard</h1>
+<div class="grid">
+  <div class="card"><h2>Status</h2><div class="stat" id="status">Loading…</div><div class="sub" id="uptime"></div></div>
+  <div class="card"><h2>Sessions</h2><div class="stat" id="sessions">-</div></div>
+  <div class="card"><h2>Tools</h2><div class="stat" id="tools">-</div></div>
+  <div class="card"><h2>Channels</h2><div class="stat" id="channels">-</div></div>
+</div>
+<div id="data"></div>
+<script>
+async function poll(){try{const r=await fetch('/api/state');const d=await r.json();
+document.getElementById('status').textContent=d.agent.status;
+document.getElementById('uptime').textContent='Uptime: '+Math.floor(d.agent.uptime/1000)+'s';
+document.getElementById('sessions').textContent=d.sessions.length;
+document.getElementById('tools').textContent=d.tools.length;
+document.getElementById('channels').textContent=d.channels.length;
+document.getElementById('data').textContent=JSON.stringify(d,null,2);
+}catch(e){document.getElementById('status').textContent='offline'}}
+poll();setInterval(poll,5000);
+</script></body></html>`;
+    }
+}
+exports.Dashboard = Dashboard;
+//# sourceMappingURL=dashboard.js.map

package/dist/core/fast-mode.d.ts

@@ -0,0 +1,27 @@
+export interface FastModeConfig {
+    enabled: boolean;
+    supportedModels: string[];
+    priorityTier: 'standard' | 'fast' | 'turbo';
+}
+export interface FastModeStats {
+    requestsRouted: number;
+    avgLatencySavingMs: number;
+}
+export declare class FastModeRouter {
+    private config;
+    private requestsRouted;
+    private totalLatencySavingMs;
+    constructor(config: FastModeConfig);
+    /** Check if a model supports fast mode */
+    isSupported(model: string): boolean;
+    /**
+     * Get the fast-mode endpoint for a model.
+     * Appends /fast suffix or priority query param based on tier.
+     */
+    getEndpoint(model: string, baseEndpoint: string): string;
+    /** Toggle enabled state, return new state */
+    toggle(): boolean;
+    /** Get routing stats */
+    getStats(): FastModeStats;
+}
+//# sourceMappingURL=fast-mode.d.ts.map

package/dist/core/fast-mode.js

@@ -0,0 +1,59 @@
+"use strict";
+// ─── Fast Mode Router ────────────────────────────────────────
+// Higher-level fast mode abstraction on top of PriorityRouter.
+// Routes requests through priority queues for lower latency on supported models.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastModeRouter = void 0;
+class FastModeRouter {
+    config;
+    requestsRouted = 0;
+    totalLatencySavingMs = 0;
+    constructor(config) {
+        this.config = { ...config };
+    }
+    /** Check if a model supports fast mode */
+    isSupported(model) {
+        return this.config.supportedModels.some((pattern) => {
+            if (pattern.endsWith('*')) {
+                return model.startsWith(pattern.slice(0, -1));
+            }
+            return model === pattern;
+        });
+    }
+    /**
+     * Get the fast-mode endpoint for a model.
+     * Appends /fast suffix or priority query param based on tier.
+     */
+    getEndpoint(model, baseEndpoint) {
+        if (!this.config.enabled || !this.isSupported(model)) {
+            return baseEndpoint;
+        }
+        this.requestsRouted++;
+        // Estimate ~120ms saving for fast, ~200ms for turbo
+        this.totalLatencySavingMs += this.config.priorityTier === 'turbo' ? 200 : 120;
+        const separator = baseEndpoint.includes('?') ? '&' : '?';
+        if (this.config.priorityTier === 'turbo') {
+            // Turbo uses a dedicated /fast path
+            const url = baseEndpoint.replace(/\/$/, '');
+            return `${url}/fast`;
+        }
+        // Fast tier uses query param
+        return `${baseEndpoint}${separator}priority=${this.config.priorityTier}`;
+    }
+    /** Toggle enabled state, return new state */
+    toggle() {
+        this.config.enabled = !this.config.enabled;
+        return this.config.enabled;
+    }
+    /** Get routing stats */
+    getStats() {
+        return {
+            requestsRouted: this.requestsRouted,
+            avgLatencySavingMs: this.requestsRouted > 0
+                ? Math.round(this.totalLatencySavingMs / this.requestsRouted)
+                : 0,
+        };
+    }
+}
+exports.FastModeRouter = FastModeRouter;
+//# sourceMappingURL=fast-mode.js.map

package/dist/core/priority.d.ts

@@ -0,0 +1,52 @@
+export interface PriorityConfig {
+    /** Enable priority mode (default: false) */
+    enabled: boolean;
+    /** Provider-specific priority settings */
+    providers?: PriorityProviderConfig[];
+    /** Default priority tier */
+    defaultTier?: PriorityTier;
+}
+export type PriorityTier = 'standard' | 'fast' | 'batch';
+export interface PriorityProviderConfig {
+    provider: string;
+    tier: PriorityTier;
+    /** Custom endpoint override for priority routing */
+    endpoint?: string;
+    /** Supported models for this tier */
+    models?: string[];
+}
+interface PriorityHeaders {
+    [key: string]: string;
+}
+export declare class PriorityRouter {
+    private config;
+    private runtimeTier;
+    constructor(config: PriorityConfig);
+    /** Toggle fast mode on/off at runtime */
+    toggle(): PriorityTier;
+    /** Set specific tier */
+    setTier(tier: PriorityTier): void;
+    /** Get current tier */
+    getTier(): PriorityTier;
+    /** Check if fast mode is active */
+    isFast(): boolean;
+    /**
+     * Get priority headers for a provider + model combination.
+     * Returns empty object if provider doesn't support priority or model isn't eligible.
+     */
+    getHeaders(provider: string, model: string): PriorityHeaders;
+    /**
+     * Get effective endpoint for a provider, allowing priority-specific routing.
+     */
+    getEndpoint(provider: string, defaultEndpoint: string): string;
+    private getEffectiveTier;
+    private isModelEligible;
+    /** Status summary for dashboard / CLI */
+    status(): {
+        tier: PriorityTier;
+        enabled: boolean;
+        providers: string[];
+    };
+}
+export {};
+//# sourceMappingURL=priority.d.ts.map

package/dist/core/priority.js

@@ -0,0 +1,102 @@
+"use strict";
+// ─── Priority / Fast Mode ────────────────────────────────────
+// Route requests through provider priority tiers for lower latency.
+// Toggle via config or runtime command.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityRouter = void 0;
+// Known priority-capable providers and their routing
+const PROVIDER_PRIORITY_MAP = {
+    openai: {
+        headerKey: 'X-OpenAI-Processing-Priority',
+        headerValue: { fast: 'priority', standard: 'auto', batch: 'batch' },
+        supportedModels: ['gpt-5', 'gpt-5.4', 'gpt-4.1', 'codex-*', 'o3-*', 'o4-mini*'],
+    },
+    anthropic: {
+        headerKey: 'anthropic-priority',
+        headerValue: { fast: 'high', standard: 'normal', batch: 'low' },
+        supportedModels: ['claude-opus-*', 'claude-sonnet-*', 'claude-4*'],
+    },
+    google: {
+        headerKey: 'X-Goog-Priority',
+        headerValue: { fast: 'high', standard: 'normal', batch: 'low' },
+        supportedModels: ['gemini-2.5-*', 'gemini-3-*'],
+    },
+};
+class PriorityRouter {
+    config;
+    runtimeTier;
+    constructor(config) {
+        this.config = config;
+        this.runtimeTier = config.defaultTier ?? 'standard';
+    }
+    /** Toggle fast mode on/off at runtime */
+    toggle() {
+        this.runtimeTier = this.runtimeTier === 'fast' ? 'standard' : 'fast';
+        return this.runtimeTier;
+    }
+    /** Set specific tier */
+    setTier(tier) {
+        this.runtimeTier = tier;
+    }
+    /** Get current tier */
+    getTier() {
+        return this.runtimeTier;
+    }
+    /** Check if fast mode is active */
+    isFast() {
+        return this.runtimeTier === 'fast';
+    }
+    /**
+     * Get priority headers for a provider + model combination.
+     * Returns empty object if provider doesn't support priority or model isn't eligible.
+     */
+    getHeaders(provider, model) {
+        if (!this.config.enabled)
+            return {};
+        const tier = this.getEffectiveTier(provider);
+        if (tier === 'standard')
+            return {};
+        const providerMap = PROVIDER_PRIORITY_MAP[provider.toLowerCase()];
+        if (!providerMap)
+            return {};
+        // Check model eligibility
+        if (!this.isModelEligible(providerMap.supportedModels, model))
+            return {};
+        return { [providerMap.headerKey]: providerMap.headerValue[tier] };
+    }
+    /**
+     * Get effective endpoint for a provider, allowing priority-specific routing.
+     */
+    getEndpoint(provider, defaultEndpoint) {
+        const providerConfig = this.config.providers?.find((p) => p.provider.toLowerCase() === provider.toLowerCase());
+        if (providerConfig?.endpoint && this.runtimeTier === 'fast') {
+            return providerConfig.endpoint;
+        }
+        return defaultEndpoint;
+    }
+    getEffectiveTier(provider) {
+        // Check provider-specific override first
+        const providerConfig = this.config.providers?.find((p) => p.provider.toLowerCase() === provider.toLowerCase());
+        if (providerConfig)
+            return providerConfig.tier;
+        return this.runtimeTier;
+    }
+    isModelEligible(patterns, model) {
+        return patterns.some((pattern) => {
+            if (pattern.endsWith('*')) {
+                return model.startsWith(pattern.slice(0, -1));
+            }
+            return model === pattern;
+        });
+    }
+    /** Status summary for dashboard / CLI */
+    status() {
+        return {
+            tier: this.runtimeTier,
+            enabled: this.config.enabled,
+            providers: Object.keys(PROVIDER_PRIORITY_MAP),
+        };
+    }
+}
+exports.PriorityRouter = PriorityRouter;
+//# sourceMappingURL=priority.js.map

package/dist/core/runtime.d.ts

@@ -1,5 +1,4 @@
 import { BaseAgent } from './agent';
-import { Analytics } from '../analytics';
 import type { OADDocument } from '../schema/oad';
 import type { ISkill } from './types';
 export declare function truncateOutput(output: string, maxChars?: number): string;
@@ -10,7 +9,6 @@ export declare class AgentRuntime {
     private historyLimit;
     private shutdownHandlers;
     private isShuttingDown;
-    private analytics;
     loadConfig(filePath: string): Promise<OADDocument>;
     setHistoryLimit(limit: number): void;
     initialize(config?: OADDocument): Promise<BaseAgent>;
@@ -20,7 +18,5 @@ export declare class AgentRuntime {
     private setupGracefulShutdown;
     registerSkill(skill: ISkill): void;
     getAgent(): BaseAgent | null;
-    getAnalytics(): Analytics;
-    getConfig(): OADDocument | null;
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/core/runtime.js

@@ -9,7 +9,6 @@ const web_1 = require("../channels/web");
 const telegram_1 = require("../channels/telegram");
 const websocket_1 = require("../channels/websocket");
 const deepbrain_1 = require("../memory/deepbrain");
-const analytics_1 = require("../analytics");
 const MAX_TOOL_OUTPUT = 5000;
 const DEFAULT_HISTORY_LIMIT = 50;
 function truncateOutput(output, maxChars = MAX_TOOL_OUTPUT) {
@@ -25,7 +24,6 @@ class AgentRuntime {
     historyLimit = DEFAULT_HISTORY_LIMIT;
     shutdownHandlers = [];
     isShuttingDown = false;
-    analytics = new analytics_1.Analytics();
     async loadConfig(filePath) {
         this.config = (0, config_1.loadOAD)(filePath);
         this.logger.info('Config loaded', { name: this.config.metadata.name });
@@ -60,12 +58,6 @@ class AgentRuntime {
                 const port = ch.port ?? 3000;
                 const webChannel = new web_1.WebChannel(port);
                 webChannel.setAgentName(cfg.metadata.name);
-                webChannel.setAgentVersion(cfg.metadata.version);
-                webChannel.setAnalyticsProvider(() => this.analytics.getSnapshot());
-                webChannel.setChannelNames(cfg.spec.channels.map((c) => c.type));
-                webChannel.setSkillNames(cfg.spec.skills.map((s) => s.name));
-                const memType = memCfg && typeof memCfg.longTerm === 'object' && memCfg.longTerm.provider === 'deepbrain' ? 'deepbrain' : 'in-memory';
-                webChannel.setMemoryType(memType);
                 // Wire streaming
                 webChannel.onStreamMessage(async (msg, res) => {
                     res.writeHead(200, {
@@ -74,18 +66,15 @@ class AgentRuntime {
                         Connection: 'keep-alive',
                         'Access-Control-Allow-Origin': '*',
                     });
-                    const startTime = Date.now();
                     try {
                         for await (const chunk of this.agent.handleMessageStream(msg)) {
                             res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
                         }
                         res.write('data: [DONE]\n\n');
-                        this.analytics.recordMessage(Date.now() - startTime);
                     }
                     catch (err) {
                         const errMsg = err instanceof Error ? err.message : String(err);
                         res.write(`data: ${JSON.stringify({ error: errMsg })}\n\n`);
-                        this.analytics.recordError();
                     }
                     res.end();
                 });
@@ -105,16 +94,6 @@ class AgentRuntime {
             }
         }
         await this.agent.init();
-        // Wire analytics to agent events
-        this.agent.on('message:out', () => {
-            // responseTime is approximated; real timing is done via skill/llm events
-        });
-        this.agent.on('skill:execute', (skillName) => {
-            this.analytics.recordSkillUsage(skillName);
-        });
-        this.agent.on('error', () => {
-            this.analytics.recordError();
-        });
         this.logger.info('Agent initialized', { name: cfg.metadata.name });
         return this.agent;
     }
@@ -163,12 +142,6 @@ class AgentRuntime {
     getAgent() {
         return this.agent;
     }
-    getAnalytics() {
-        return this.analytics;
-    }
-    getConfig() {
-        return this.config;
-    }
 }
 exports.AgentRuntime = AgentRuntime;
 //# sourceMappingURL=runtime.js.map

package/dist/deploy/hermes.js

@@ -113,32 +113,32 @@ function deployToHermes(options) {
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
     files.push('settings.json');
     // .env template
-    const envContent = `# Hermes Agent Environment
-HERMES_CHARACTER=${oad.metadata.name}
-HERMES_MODEL=${oad.spec.model}
-HERMES_PROVIDER=${oad.spec.provider?.default ?? 'openai'}
-# Add your API keys below:
-# OPENAI_API_KEY=
-# DEEPSEEK_API_KEY=
+    const envContent = `# Hermes Agent Environment
+HERMES_CHARACTER=${oad.metadata.name}
+HERMES_MODEL=${oad.spec.model}
+HERMES_PROVIDER=${oad.spec.provider?.default ?? 'openai'}
+# Add your API keys below:
+# OPENAI_API_KEY=
+# DEEPSEEK_API_KEY=
 `;
     fs.writeFileSync(path.join(outputDir, '.env.hermes'), envContent, 'utf-8');
     files.push('.env.hermes');
     // README
-    const readme = `# ${oad.metadata.name} - Hermes Agent
-
-Converted from OAD format using \`opc deploy --target hermes\`.
-
-## Usage
-
-1. Copy \`character.json\` to your Hermes agents directory
-2. Configure \`.env.hermes\` with your API keys
-3. Start Hermes with this character
-
-## Files
-
-- \`character.json\` - Agent character definition
-- \`settings.json\` - Runtime settings
-- \`.env.hermes\` - Environment template
+    const readme = `# ${oad.metadata.name} - Hermes Agent
+
+Converted from OAD format using \`opc deploy --target hermes\`.
+
+## Usage
+
+1. Copy \`character.json\` to your Hermes agents directory
+2. Configure \`.env.hermes\` with your API keys
+3. Start Hermes with this character
+
+## Files
+
+- \`character.json\` - Agent character definition
+- \`settings.json\` - Runtime settings
+- \`.env.hermes\` - Environment template
 `;
     fs.writeFileSync(path.join(outputDir, 'README.md'), readme, 'utf-8');
     files.push('README.md');

package/dist/deploy/openclaw.js

@@ -41,27 +41,27 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function generateIdentityMd(oad) {
     const m = oad.metadata;
-    return `# IDENTITY.md
-
-- **Name:** ${m.name}
-- **Version:** ${m.version}
-- **Description:** ${m.description ?? 'An AI agent'}
-- **Author:** ${m.author ?? 'Unknown'}
-- **License:** ${m.license}
+    return `# IDENTITY.md
+
+- **Name:** ${m.name}
+- **Version:** ${m.version}
+- **Description:** ${m.description ?? 'An AI agent'}
+- **Author:** ${m.author ?? 'Unknown'}
+- **License:** ${m.license}
 `;
 }
 function generateSoulMd(oad) {
     const prompt = oad.spec.systemPrompt ?? 'You are a helpful AI assistant.';
-    return `# SOUL.md - ${oad.metadata.name}
-
-## System Prompt
-
-${prompt}
-
-## Model Configuration
-
-- **Model:** ${oad.spec.model}
-- **Provider:** ${oad.spec.provider?.default ?? 'deepseek'}
+    return `# SOUL.md - ${oad.metadata.name}
+
+## System Prompt
+
+${prompt}
+
+## Model Configuration
+
+- **Model:** ${oad.spec.model}
+- **Provider:** ${oad.spec.provider?.default ?? 'deepseek'}
 `;
 }
 function generateAgentsMd(oad) {
@@ -100,26 +100,35 @@ function generateAgentsMd(oad) {
         md += `Default memory settings.\n`;
     }
     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;
 }
 function generateUserMd(oad) {
-    return `# USER.md
-
-- **Name:** (your name)
-- **Role:** User
-- **Notes:** Configure this file with your preferences for ${oad.metadata.name}.
+    return `# USER.md
+
+- **Name:** (your name)
+- **Role:** User
+- **Notes:** Configure this file with your preferences for ${oad.metadata.name}.
 `;
 }
 function generateMemoryMd(oad) {
-    return `# MEMORY.md - ${oad.metadata.name}
-
-## Persistent Knowledge
-
-(Agent will store learned information here)
-
-## User Preferences
-
-(Discovered user preferences will be noted here)
+    return `# MEMORY.md - ${oad.metadata.name}
+
+## Persistent Knowledge
+
+(Agent will store learned information here)
+
+## User Preferences
+
+(Discovered user preferences will be noted here)
 `;
 }
 function generateOpenClawConfig(oad, agentDir) {