opc-agent 1.3.0 → 1.3.2

package/dist/core/dashboard.d.ts

@@ -0,0 +1,35 @@
+export interface DashboardConfig {
+    /** Enable the dashboard (default: false) */
+    enabled: boolean;
+    /** HTTP port (default: 4100) */
+    port?: number;
+    /** Bind address (default: 127.0.0.1 for security) */
+    host?: string;
+    /** Enable CORS (default: false) */
+    cors?: boolean;
+}
+interface SessionSummary {
+    id: string;
+    channel: string;
+    messages: number;
+    lastActive: number;
+    status: 'active' | 'idle' | 'closed';
+}
+export declare class Dashboard {
+    private app;
+    private server;
+    private config;
+    private startTime;
+    private stats;
+    constructor(config: DashboardConfig);
+    private setupRoutes;
+    private getState;
+    trackSession(session: SessionSummary): void;
+    trackToolCall(toolName: string): void;
+    trackChannel(name: string, connected: boolean, messages?: number): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private renderHTML;
+}
+export {};
+//# sourceMappingURL=dashboard.d.ts.map

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/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/streaming.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from 'events';
+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;
+}
+export declare class StreamableResponse extends EventEmitter {
+    readonly id: string;
+    private chunks;
+    private ended;
+    private paused;
+    private buffer;
+    private highWaterMark;
+    constructor(id: string, options?: StreamOptions);
+    /** Push a chunk. Returns false if backpressure threshold reached. */
+    push(chunk: StreamChunk): boolean;
+    /** Resume after backpressure — flush buffered chunks. */
+    resume(): void;
+    end(): void;
+    getChunks(): StreamChunk[];
+    /** Collect all text chunks into a single string. */
+    getText(): string;
+    get isEnded(): boolean;
+    get isPaused(): boolean;
+    get length(): number;
+}
+export declare class StreamingManager {
+    private streams;
+    private counter;
+    /** Create a new stream. */
+    createStream(options?: StreamOptions): StreamableResponse;
+    /** Write a text chunk to a stream. */
+    writeChunk(streamId: string, data: string, metadata?: Record<string, unknown>): boolean;
+    /** End a stream. */
+    endStream(streamId: string): void;
+    /** Get an existing stream. */
+    getStream(streamId: string): StreamableResponse | undefined;
+    /** Format a chunk as an SSE event string. */
+    static formatSSE(chunk: StreamChunk): string;
+    /** 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;
+    get activeCount(): number;
+}
+//# sourceMappingURL=streaming.d.ts.map

package/dist/core/streaming.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingManager = exports.StreamableResponse = void 0;
+const events_1 = require("events");
+// ─── StreamableResponse ──────────────────────────────────────
+class StreamableResponse extends events_1.EventEmitter {
+    id;
+    chunks = [];
+    ended = false;
+    paused = false;
+    buffer = [];
+    highWaterMark;
+    constructor(id, options) {
+        super();
+        this.id = id;
+        this.highWaterMark = options?.highWaterMark ?? 64;
+    }
+    /** Push a chunk. Returns false if backpressure threshold reached. */
+    push(chunk) {
+        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() {
+        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() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        if (this.paused)
+            this.resume();
+        this.emit('end');
+    }
+    getChunks() {
+        return [...this.chunks];
+    }
+    /** Collect all text chunks into a single string. */
+    getText() {
+        return this.chunks
+            .filter((c) => c.type === 'text')
+            .map((c) => c.data)
+            .join('');
+    }
+    get isEnded() {
+        return this.ended;
+    }
+    get isPaused() {
+        return this.paused;
+    }
+    get length() {
+        return this.chunks.length;
+    }
+}
+exports.StreamableResponse = StreamableResponse;
+// ─── StreamingManager ────────────────────────────────────────
+class StreamingManager {
+    streams = new Map();
+    counter = 0;
+    /** Create a new stream. */
+    createStream(options) {
+        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, data, metadata) {
+        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) {
+        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) {
+        return this.streams.get(streamId);
+    }
+    /** Format a chunk as an SSE event string. */
+    static formatSSE(chunk) {
+        const lines = [];
+        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, res, options) {
+        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) => {
+            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() {
+        let count = 0;
+        for (const s of this.streams.values()) {
+            if (!s.isEnded)
+                count++;
+        }
+        return count;
+    }
+}
+exports.StreamingManager = StreamingManager;
+//# sourceMappingURL=streaming.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');