opc-agent 1.3.0 → 1.3.1

package/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm ci
+      - run: npm run build --if-present
+      - run: npx vitest run --reporter=verbose
+        env:
+          CI: true

package/dist/cli.js

@@ -61,7 +61,6 @@ const workflow_1 = require("./core/workflow");
 const versioning_1 = require("./core/versioning");
 const providers_1 = require("./providers");
 const knowledge_1 = require("./core/knowledge");
-const marketplace_1 = require("./marketplace");
 const program = new commander_1.Command();
 const color = {
     green: (s) => `\x1b[32m${s}\x1b[0m`,
@@ -684,51 +683,23 @@ kbCmd.command('clear').action(() => {
     kb.clear();
     console.log(`${icon.success} Knowledge base cleared.`);
 });
-// 📦 Marketplace commands ───────────────────────────────────
+// 📦 Package commands ───────────────────────────────────
 program
     .command('publish')
     .description('Package agent for distribution')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
     .option('-o, --output <dir>', 'Output directory', '.')
     .option('--include-kb', 'Include knowledge base')
-    .action(async (opts) => {
-    try {
-        console.log(`\n${icon.package} Packaging agent...\n`);
-        const result = await (0, marketplace_1.publishAgent)({
-            oadPath: opts.file,
-            outputDir: opts.output,
-            includeKnowledge: opts.includeKb,
-        });
-        console.log(`${icon.success} Published: ${color.bold(result.archivePath)}`);
-        console.log(`   Name:    ${result.manifest.name}`);
-        console.log(`   Version: ${result.manifest.version}`);
-        console.log(`   Files:   ${result.manifest.files.length}`);
-        console.log();
-    }
-    catch (err) {
-        console.error(`${icon.error} Publish failed:`, err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
+    .action(async () => {
+    console.log(`\n${icon.package} Agent packaging coming soon.\n`);
 });
 program
     .command('install')
     .description('Install agent from package')
     .argument('<source>', 'Package file path or URL')
     .option('-d, --dir <dir>', 'Install directory')
-    .action(async (source, opts) => {
-    try {
-        console.log(`\n${icon.package} Installing agent from ${color.bold(source)}...\n`);
-        const result = await (0, marketplace_1.installAgent)({ source, targetDir: opts.dir });
-        console.log(`${icon.success} Installed: ${color.bold(result.manifest.name)} v${result.manifest.version}`);
-        console.log(`   Directory: ${result.dir}`);
-        console.log(`\n${color.bold('Next steps:')}`);
-        console.log(`   cd ${result.dir}`);
-        console.log(`   opc run\n`);
-    }
-    catch (err) {
-        console.error(`${icon.error} Install failed:`, err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
+    .action(async () => {
+    console.log(`\n${icon.package} Agent install coming soon.\n`);
 });
 // 🔌 Plugin commands ────────────────────────────────────────
 const pluginCmd = program.command('plugin').description('Manage plugins');
@@ -838,5 +809,118 @@ program
         process.exit(1);
     }
 });
+// ── Brain command ────────────────────────────────────────────
+program
+    .command('brain')
+    .description('Show agent memory/brain status from DeepBrain')
+    .option('--url <url>', 'DeepBrain server URL', 'http://localhost:3333')
+    .action(async (opts) => {
+    console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
+    try {
+        const res = await fetch(`${opts.url}/api/stats`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        const stats = (await res.json());
+        const rows = [
+            ['Total Pages', String(stats.totalPages ?? stats.pages ?? '-')],
+            ['Total Chunks', String(stats.totalChunks ?? stats.chunks ?? '-')],
+            ['Memory Tiers', String(stats.memoryTiers ?? stats.tiers ?? '-')],
+            ['Index Size', stats.indexSize ?? '-'],
+            ['Last Updated', stats.lastUpdated ?? stats.updatedAt ?? '-'],
+        ];
+        const maxKey = Math.max(...rows.map(([k]) => k.length));
+        for (const [key, val] of rows) {
+            console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
+            console.log(`  ${icon.warn} Cannot connect to DeepBrain at ${opts.url}`);
+            console.log(`  ${color.dim('Is the server running? Start with: deepbrain serve')}\n`);
+        }
+        else {
+            console.error(`  ${icon.error} ${msg}\n`);
+        }
+    }
+});
+// ── Logs command ─────────────────────────────────────────────
+program
+    .command('logs')
+    .description('Show recent agent traces')
+    .option('-n, --limit <n>', 'Number of spans to show', '20')
+    .option('-f, --follow', 'Keep watching for new spans')
+    .action(async (opts) => {
+    const { TraceCollector } = await Promise.resolve().then(() => __importStar(require('./traces')));
+    const collector = new TraceCollector();
+    const limit = parseInt(opts.limit) || 20;
+    const printSpans = (spans) => {
+        const slice = spans.slice(-limit);
+        if (slice.length === 0) {
+            console.log(`  ${icon.info} No traces yet. Interact with the agent to generate traces.`);
+            return;
+        }
+        for (const span of slice) {
+            const duration = span.endTime
+                ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
+                : 'ongoing';
+            const statusIcon = span.status === 'ok' ? icon.success : span.status === 'error' ? icon.error : color.dim('○');
+            const time = span.startTime.toLocaleTimeString();
+            console.log(`  ${statusIcon} ${color.dim(time)} ${color.bold(span.name)} ${color.dim(duration)}`);
+        }
+    };
+    console.log(`\n${icon.gear} ${color.bold('Agent Traces')}\n`);
+    const spans = collector.getBufferedSpans();
+    printSpans(spans);
+    if (opts.follow) {
+        console.log(`\n  ${color.dim('Watching for new traces... (Ctrl+C to stop)')}\n`);
+        let lastCount = spans.length;
+        const interval = setInterval(() => {
+            const current = collector.getBufferedSpans();
+            if (current.length > lastCount) {
+                const newSpans = current.slice(lastCount);
+                printSpans(newSpans);
+                lastCount = current.length;
+            }
+        }, 1000);
+        process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+    }
+    else {
+        console.log();
+    }
+});
+// ── Score command ────────────────────────────────────────────
+program
+    .command('score')
+    .description('Show agent performance score')
+    .action(async () => {
+    console.log(`\n${icon.gear} ${color.bold('Agent Performance Score')}\n`);
+    try {
+        const engine = new analytics_engine_1.AnalyticsEngine('.');
+        const stats = engine.getStats();
+        if (!stats || stats.totalMessages === 0) {
+            console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+            return;
+        }
+        const errorRate = stats.totalMessages > 0 ? (stats.totalErrors / stats.totalMessages) : 0;
+        const rows = [
+            ['Total Messages', String(stats.totalMessages)],
+            ['Total LLM Calls', String(stats.totalLLMCalls)],
+            ['Total Tool Uses', String(stats.totalToolUses)],
+            ['Avg Response Time', `${stats.avgResponseTimeMs}ms`],
+            ['Error Rate', `${(errorRate * 100).toFixed(1)}%`],
+            ['Token Usage', `${stats.totalTokens.total} tokens (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`],
+        ];
+        const maxKey = Math.max(...rows.map(([k]) => k.length));
+        for (const [key, val] of rows) {
+            console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+        }
+        console.log();
+    }
+    catch {
+        console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+    }
+});
 program.parse();
 //# sourceMappingURL=cli.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/openclaw.js

@@ -100,15 +100,6 @@ 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) {

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { AgentRuntime, truncateOutput } from './core/runtime';
 export { Logger } from './core/logger';
 export { loadOAD, validateOAD } from './core/config';
 export { OADSchema } from './schema/oad';
-export type { OADDocument, Metadata, Spec, DTVConfig, TrustLevelType } from './schema/oad';
+export type { OADDocument, Metadata, Spec } 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';
@@ -13,9 +13,6 @@ export { BaseSkill } from './skills/base';
 export { SkillRegistry } from './skills';
 export { InMemoryStore } from './memory';
 export { DeepBrainMemoryStore } from './memory/deepbrain';
-export { TrustManager } from './dtv/trust';
-export { ValueTracker } from './dtv/value';
-export { MRGConfigReader } from './dtv/data';
 export { createProvider, SUPPORTED_PROVIDERS } from './providers';
 export { Room } from './core/room';
 export type { RoomMessage } from './core/room';
@@ -45,8 +42,6 @@ export type { Locale } from './i18n';
 export { KnowledgeBase } from './core/knowledge';
 export { deployToHermes } from './deploy/hermes';
 export type { HermesDeployOptions, HermesDeployResult } from './deploy/hermes';
-export { publishAgent, installAgent } from './marketplace';
-export type { AgentManifest, PublishOptions, InstallOptions } from './marketplace';
 export { createAuthMiddleware, getActiveSessions } from './core/auth';
 export type { AuthConfig, AuthSession } from './core/auth';
 export { Orchestrator } from './core/orchestrator';
@@ -91,4 +86,10 @@ export { DiscordChannel } from './channels/discord';
 export type { DiscordChannelConfig } from './channels/discord';
 export { ProcessWatcher } from './core/watch';
 export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';
+export { ToolGateway } from './tools/gateway';
+export type { ToolGatewayConfig, GatewayToolName } from './tools/gateway';
+export { StreamingManager, StreamableResponse } from './core/streaming';
+export type { StreamChunk, StreamOptions } from './core/streaming';
+export { TraceCollector, ConsoleExporter, DeepBrainExporter } from './traces';
+export type { Span, SpanEvent, TraceExporter } from './traces';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmailChannel = exports.compose = exports.AgentPipeline = exports.Orchestrator = exports.getActiveSessions = exports.createAuthMiddleware = exports.installAgent = exports.publishAgent = exports.deployToHermes = exports.KnowledgeBase = exports.addMessages = exports.detectLocale = exports.getLocale = exports.setLocale = exports.t = exports.LazyLoader = exports.RequestBatcher = exports.ConnectionPool = exports.VersionManager = exports.WebhookChannel = exports.VoiceChannel = exports.HITLManager = exports.AgentRegistry = exports.WorkflowEngine = exports.Analytics = exports.Sandbox = exports.PluginManager = exports.createMCPTool = exports.MCPToolRegistry = exports.Room = exports.SUPPORTED_PROVIDERS = exports.createProvider = exports.MRGConfigReader = exports.ValueTracker = exports.TrustManager = exports.DeepBrainMemoryStore = exports.InMemoryStore = exports.SkillRegistry = exports.BaseSkill = exports.WebSocketChannel = exports.TelegramChannel = exports.WebChannel = exports.BaseChannel = exports.OADSchema = exports.validateOAD = exports.loadOAD = exports.Logger = exports.truncateOutput = exports.AgentRuntime = exports.BaseAgent = void 0;
-exports.ProcessWatcher = exports.DiscordChannel = exports.FeishuChannel = exports.createRateLimitPlugin = exports.createAnalyticsPlugin = exports.createLoggingPlugin = exports.inputValidation = exports.APIKeyManager = exports.corsMiddleware = exports.securityHeaders = exports.detectInjection = exports.sanitizeInput = exports.formatErrorForUser = exports.wrapError = exports.TimeoutError = exports.SecurityError = exports.RateLimitError = exports.PluginError = exports.ChannelError = exports.ConfigError = exports.ValidationError = exports.ProviderError = exports.OPCError = exports.createTeacherConfig = exports.createDataAnalystConfig = exports.getSupportedLocales = exports.LLMCache = exports.RateLimiter = exports.AnalyticsEngine = exports.formatReport = exports.loadTestCases = exports.runTests = exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.TextAnalysisTool = exports.JsonTransformTool = exports.DateTimeTool = exports.CalculatorTool = exports.WeChatChannel = exports.SlackChannel = void 0;
+exports.JsonTransformTool = exports.DateTimeTool = exports.CalculatorTool = exports.WeChatChannel = exports.SlackChannel = exports.EmailChannel = exports.compose = exports.AgentPipeline = exports.Orchestrator = exports.getActiveSessions = exports.createAuthMiddleware = exports.deployToHermes = exports.KnowledgeBase = exports.addMessages = exports.detectLocale = exports.getLocale = exports.setLocale = exports.t = exports.LazyLoader = exports.RequestBatcher = exports.ConnectionPool = exports.VersionManager = exports.WebhookChannel = exports.VoiceChannel = exports.HITLManager = exports.AgentRegistry = exports.WorkflowEngine = exports.Analytics = exports.Sandbox = exports.PluginManager = exports.createMCPTool = exports.MCPToolRegistry = exports.Room = exports.SUPPORTED_PROVIDERS = exports.createProvider = exports.DeepBrainMemoryStore = exports.InMemoryStore = exports.SkillRegistry = exports.BaseSkill = exports.WebSocketChannel = exports.TelegramChannel = exports.WebChannel = exports.BaseChannel = exports.OADSchema = exports.validateOAD = exports.loadOAD = exports.Logger = exports.truncateOutput = exports.AgentRuntime = exports.BaseAgent = void 0;
+exports.DeepBrainExporter = exports.ConsoleExporter = exports.TraceCollector = exports.StreamableResponse = exports.StreamingManager = exports.ToolGateway = exports.ProcessWatcher = exports.DiscordChannel = exports.FeishuChannel = exports.createRateLimitPlugin = exports.createAnalyticsPlugin = exports.createLoggingPlugin = exports.inputValidation = exports.APIKeyManager = exports.corsMiddleware = exports.securityHeaders = exports.detectInjection = exports.sanitizeInput = exports.formatErrorForUser = exports.wrapError = exports.TimeoutError = exports.SecurityError = exports.RateLimitError = exports.PluginError = exports.ChannelError = exports.ConfigError = exports.ValidationError = exports.ProviderError = exports.OPCError = exports.createTeacherConfig = exports.createDataAnalystConfig = exports.getSupportedLocales = exports.LLMCache = exports.RateLimiter = exports.AnalyticsEngine = exports.formatReport = exports.loadTestCases = exports.runTests = exports.DocumentSkill = exports.SchedulerSkill = exports.WebhookTriggerSkill = exports.HttpSkill = exports.TextAnalysisTool = void 0;
 // OPC Agent — Open Agent Framework
 var agent_1 = require("./core/agent");
 Object.defineProperty(exports, "BaseAgent", { enumerable: true, get: function () { return agent_1.BaseAgent; } });
@@ -31,12 +31,6 @@ var memory_1 = require("./memory");
 Object.defineProperty(exports, "InMemoryStore", { enumerable: true, get: function () { return memory_1.InMemoryStore; } });
 var deepbrain_1 = require("./memory/deepbrain");
 Object.defineProperty(exports, "DeepBrainMemoryStore", { enumerable: true, get: function () { return deepbrain_1.DeepBrainMemoryStore; } });
-var trust_1 = require("./dtv/trust");
-Object.defineProperty(exports, "TrustManager", { enumerable: true, get: function () { return trust_1.TrustManager; } });
-var value_1 = require("./dtv/value");
-Object.defineProperty(exports, "ValueTracker", { enumerable: true, get: function () { return value_1.ValueTracker; } });
-var data_1 = require("./dtv/data");
-Object.defineProperty(exports, "MRGConfigReader", { enumerable: true, get: function () { return data_1.MRGConfigReader; } });
 var providers_1 = require("./providers");
 Object.defineProperty(exports, "createProvider", { enumerable: true, get: function () { return providers_1.createProvider; } });
 Object.defineProperty(exports, "SUPPORTED_PROVIDERS", { enumerable: true, get: function () { return providers_1.SUPPORTED_PROVIDERS; } });
@@ -80,9 +74,6 @@ var knowledge_1 = require("./core/knowledge");
 Object.defineProperty(exports, "KnowledgeBase", { enumerable: true, get: function () { return knowledge_1.KnowledgeBase; } });
 var hermes_1 = require("./deploy/hermes");
 Object.defineProperty(exports, "deployToHermes", { enumerable: true, get: function () { return hermes_1.deployToHermes; } });
-var marketplace_1 = require("./marketplace");
-Object.defineProperty(exports, "publishAgent", { enumerable: true, get: function () { return marketplace_1.publishAgent; } });
-Object.defineProperty(exports, "installAgent", { enumerable: true, get: function () { return marketplace_1.installAgent; } });
 // v0.7.0 modules
 var auth_1 = require("./core/auth");
 Object.defineProperty(exports, "createAuthMiddleware", { enumerable: true, get: function () { return auth_1.createAuthMiddleware; } });
@@ -163,4 +154,15 @@ var discord_1 = require("./channels/discord");
 Object.defineProperty(exports, "DiscordChannel", { enumerable: true, get: function () { return discord_1.DiscordChannel; } });
 var watch_1 = require("./core/watch");
 Object.defineProperty(exports, "ProcessWatcher", { enumerable: true, get: function () { return watch_1.ProcessWatcher; } });
+// v1.2.0 modules
+var gateway_1 = require("./tools/gateway");
+Object.defineProperty(exports, "ToolGateway", { enumerable: true, get: function () { return gateway_1.ToolGateway; } });
+var streaming_1 = require("./core/streaming");
+Object.defineProperty(exports, "StreamingManager", { enumerable: true, get: function () { return streaming_1.StreamingManager; } });
+Object.defineProperty(exports, "StreamableResponse", { enumerable: true, get: function () { return streaming_1.StreamableResponse; } });
+// v1.3.0 modules
+var traces_1 = require("./traces");
+Object.defineProperty(exports, "TraceCollector", { enumerable: true, get: function () { return traces_1.TraceCollector; } });
+Object.defineProperty(exports, "ConsoleExporter", { enumerable: true, get: function () { return traces_1.ConsoleExporter; } });
+Object.defineProperty(exports, "DeepBrainExporter", { enumerable: true, get: function () { return traces_1.DeepBrainExporter; } });
 //# sourceMappingURL=index.js.map

package/dist/schema/oad.d.ts

@@ -1266,6 +1266,5 @@ export type SkillRef = z.infer<typeof SkillRefSchema>;
 export type Channel = z.infer<typeof ChannelSchema>;
 export type Metadata = z.infer<typeof MetadataSchema>;
 export type Spec = z.infer<typeof SpecSchema>;
-export type DTVConfig = z.infer<typeof DTVSchema>;
-export type TrustLevelType = z.infer<typeof TrustLevel>;
+export type TrustLevelType = string;
 //# sourceMappingURL=oad.d.ts.map

package/dist/templates/code-reviewer.d.ts

@@ -28,14 +28,6 @@ export declare function createCodeReviewerConfig(): {
             shortTerm: boolean;
             longTerm: boolean;
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=code-reviewer.d.ts.map

package/dist/templates/code-reviewer.js

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

package/dist/templates/customer-service.d.ts

@@ -43,14 +43,6 @@ export declare function createCustomerServiceConfig(): {
             shortTerm: boolean;
             longTerm: boolean;
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=customer-service.d.ts.map

package/dist/templates/customer-service.js

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

package/dist/templates/data-analyst.d.ts

@@ -40,14 +40,6 @@ export declare function createDataAnalystConfig(): {
             shortTerm: boolean;
             longTerm: boolean;
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=data-analyst.d.ts.map

package/dist/templates/data-analyst.js

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

package/dist/templates/knowledge-base.d.ts

@@ -31,14 +31,6 @@ export declare function createKnowledgeBaseConfig(): {
                 collection: string;
             };
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=knowledge-base.d.ts.map

package/dist/templates/knowledge-base.js

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

package/dist/templates/sales-assistant.d.ts

@@ -43,14 +43,6 @@ export declare function createSalesAssistantConfig(): {
             shortTerm: boolean;
             longTerm: boolean;
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=sales-assistant.d.ts.map

package/dist/templates/sales-assistant.js

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

package/dist/templates/teacher.d.ts

@@ -45,14 +45,6 @@ export declare function createTeacherConfig(): {
             shortTerm: boolean;
             longTerm: boolean;
         };
-        dtv: {
-            trust: {
-                level: "sandbox";
-            };
-            value: {
-                metrics: string[];
-            };
-        };
     };
 };
 //# sourceMappingURL=teacher.d.ts.map

package/dist/templates/teacher.js

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

package/dist/tools/gateway.d.ts

@@ -0,0 +1,28 @@
+import type { MCPTool, MCPToolDefinition, MCPToolResult } from './mcp';
+export interface ToolGatewayConfig {
+    enabled: boolean;
+    endpoint: string;
+    apiKey: string;
+    enabledTools?: GatewayToolName[];
+    timeout?: number;
+}
+export type GatewayToolName = 'web-search' | 'image-gen' | 'tts' | 'browser';
+export declare class ToolGateway {
+    private config;
+    private availableTools;
+    private connected;
+    constructor(config: ToolGatewayConfig);
+    /** Discover available tools from the gateway endpoint. */
+    connect(): Promise<void>;
+    /** Load default tool definitions (used as fallback). */
+    private loadDefaults;
+    /** Invoke a tool through the gateway. */
+    invokeTool(name: GatewayToolName, input: Record<string, unknown>): Promise<MCPToolResult>;
+    /** Get all gateway tools as MCPTool instances for registry integration. */
+    getTools(): MCPTool[];
+    /** Get tool definitions (without execute). */
+    listTools(): MCPToolDefinition[];
+    get isConnected(): boolean;
+    get toolCount(): number;
+}
+//# sourceMappingURL=gateway.d.ts.map

package/dist/tools/gateway.js

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

package/dist/traces/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * OPC Agent Traces — Structured logging for agent actions.
+ *
+ * Collects traces that can be fed to DeepBrain's learn() API.
+ * Inspired by OpenTelemetry spans.
+ */
+export interface Span {
+    traceId: string;
+    spanId: string;
+    name: string;
+    startTime: Date;
+    endTime?: Date;
+    attributes: Record<string, string | number | boolean>;
+    events: SpanEvent[];
+    status: 'ok' | 'error' | 'unset';
+}
+export interface SpanEvent {
+    name: string;
+    timestamp: Date;
+    attributes?: Record<string, string | number | boolean>;
+}
+export interface TraceExporter {
+    export(spans: Span[]): Promise<void>;
+}
+/** In-memory buffer that holds spans until flushed */
+export declare class TraceCollector {
+    private spans;
+    private exporters;
+    private maxBufferSize;
+    constructor(maxBufferSize?: number);
+    addExporter(exporter: TraceExporter): void;
+    startSpan(name: string, attributes?: Record<string, string | number | boolean>): Span;
+    endSpan(span: Span, status?: 'ok' | 'error'): void;
+    addEvent(span: Span, name: string, attributes?: Record<string, string | number | boolean>): void;
+    flush(): Promise<number>;
+    getBufferedSpans(): readonly Span[];
+    get bufferedCount(): number;
+}
+/** Console exporter for development */
+export declare class ConsoleExporter implements TraceExporter {
+    export(spans: Span[]): Promise<void>;
+}
+/** DeepBrain exporter — sends traces to DeepBrain learn() */
+export declare class DeepBrainExporter implements TraceExporter {
+    private learnEndpoint;
+    constructor(deepbrainUrl?: string);
+    export(spans: Span[]): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/traces/index.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * OPC Agent Traces — Structured logging for agent actions.
+ *
+ * Collects traces that can be fed to DeepBrain's learn() API.
+ * Inspired by OpenTelemetry spans.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepBrainExporter = exports.ConsoleExporter = exports.TraceCollector = void 0;
+/** In-memory buffer that holds spans until flushed */
+class TraceCollector {
+    spans = [];
+    exporters = [];
+    maxBufferSize;
+    constructor(maxBufferSize = 100) {
+        this.maxBufferSize = maxBufferSize;
+    }
+    addExporter(exporter) {
+        this.exporters.push(exporter);
+    }
+    startSpan(name, attributes = {}) {
+        const span = {
+            traceId: crypto.randomUUID(),
+            spanId: crypto.randomUUID().slice(0, 16),
+            name,
+            startTime: new Date(),
+            attributes,
+            events: [],
+            status: 'unset',
+        };
+        this.spans.push(span);
+        if (this.spans.length >= this.maxBufferSize) {
+            this.flush().catch(() => { }); // Best effort
+        }
+        return span;
+    }
+    endSpan(span, status = 'ok') {
+        span.endTime = new Date();
+        span.status = status;
+    }
+    addEvent(span, name, attributes) {
+        span.events.push({ name, timestamp: new Date(), attributes });
+    }
+    async flush() {
+        const toExport = [...this.spans];
+        this.spans = [];
+        for (const exporter of this.exporters) {
+            await exporter.export(toExport);
+        }
+        return toExport.length;
+    }
+    getBufferedSpans() {
+        return this.spans;
+    }
+    get bufferedCount() {
+        return this.spans.length;
+    }
+}
+exports.TraceCollector = TraceCollector;
+/** Console exporter for development */
+class ConsoleExporter {
+    async export(spans) {
+        for (const span of spans) {
+            const duration = span.endTime
+                ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
+                : 'ongoing';
+            console.log(`[TRACE] ${span.name} (${duration}) [${span.status}]`);
+        }
+    }
+}
+exports.ConsoleExporter = ConsoleExporter;
+/** DeepBrain exporter — sends traces to DeepBrain learn() */
+class DeepBrainExporter {
+    learnEndpoint;
+    constructor(deepbrainUrl = 'http://localhost:3333') {
+        this.learnEndpoint = `${deepbrainUrl}/api/learn`;
+    }
+    async export(spans) {
+        for (const span of spans) {
+            try {
+                await fetch(this.learnEndpoint, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        action: span.name,
+                        result: span.status === 'ok' ? 'success' : 'error',
+                        context: {
+                            ...span.attributes,
+                            duration: span.endTime ? span.endTime.getTime() - span.startTime.getTime() : null,
+                            events: span.events.map(e => e.name),
+                        },
+                    }),
+                });
+            }
+            catch {
+                // Best effort — don't break agent if brain is down
+            }
+        }
+    }
+}
+exports.DeepBrainExporter = DeepBrainExporter;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,50 +1,50 @@
-{
-  "name": "opc-agent",
-  "version": "1.3.0",
-  "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "opc": "dist/cli.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "dev": "tsc --watch",
-    "lint": "tsc --noEmit",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
-  },
-  "keywords": [
-    "agent",
-    "ai",
-    "llm",
-    "framework",
-    "typescript",
-    "agent-framework"
-  ],
-  "author": "Deepleaper",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Deepleaper/opc-agent.git"
-  },
-  "dependencies": {
-    "agentkits": "^0.1.0",
-    "commander": "^12.0.0",
-    "express": "^4.21.0",
-    "js-yaml": "^4.1.0",
-    "ws": "^8.20.0",
-    "zod": "^3.23.0"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.21",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.11.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0",
-    "vitepress": "^1.5.0"
-  }
-}
+{
+  "name": "opc-agent",
+  "version": "1.3.1",
+  "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "opc": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  },
+  "keywords": [
+    "agent",
+    "ai",
+    "llm",
+    "framework",
+    "typescript",
+    "agent-framework"
+  ],
+  "author": "Deepleaper",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Deepleaper/opc-agent.git"
+  },
+  "dependencies": {
+    "agentkits": "^0.1.0",
+    "commander": "^12.0.0",
+    "express": "^4.21.0",
+    "js-yaml": "^4.1.0",
+    "ws": "^8.20.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.11.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0",
+    "vitepress": "^1.5.0"
+  }
+}

package/src/cli.ts

@@ -721,7 +721,7 @@ kbCmd.command('clear').action(() => {
   console.log(`${icon.success} Knowledge base cleared.`);
 });
 
-// 📦 Marketplace commands ───────────────────────────────────
+// 📦 Package commands ───────────────────────────────────
 
 program
   .command('publish')
@@ -729,23 +729,8 @@ program
   .option('-f, --file <file>', 'OAD file', 'oad.yaml')
   .option('-o, --output <dir>', 'Output directory', '.')
   .option('--include-kb', 'Include knowledge base')
-  .action(async (opts: { file: string; output: string; includeKb?: boolean }) => {
-    try {
-      console.log(`\n${icon.package} Packaging agent...\n`);
-      const result = await publishAgent({
-        oadPath: opts.file,
-        outputDir: opts.output,
-        includeKnowledge: opts.includeKb,
-      });
-      console.log(`${icon.success} Published: ${color.bold(result.archivePath)}`);
-      console.log(`   Name:    ${result.manifest.name}`);
-      console.log(`   Version: ${result.manifest.version}`);
-      console.log(`   Files:   ${result.manifest.files.length}`);
-      console.log();
-    } catch (err) {
-      console.error(`${icon.error} Publish failed:`, err instanceof Error ? err.message : err);
-      process.exit(1);
-    }
+  .action(async () => {
+    console.log(`\n${icon.package} Agent packaging coming soon.\n`);
   });
 
 program
@@ -753,19 +738,8 @@ program
   .description('Install agent from package')
   .argument('<source>', 'Package file path or URL')
   .option('-d, --dir <dir>', 'Install directory')
-  .action(async (source: string, opts: { dir?: string }) => {
-    try {
-      console.log(`\n${icon.package} Installing agent from ${color.bold(source)}...\n`);
-      const result = await installAgent({ source, targetDir: opts.dir });
-      console.log(`${icon.success} Installed: ${color.bold(result.manifest.name)} v${result.manifest.version}`);
-      console.log(`   Directory: ${result.dir}`);
-      console.log(`\n${color.bold('Next steps:')}`);
-      console.log(`   cd ${result.dir}`);
-      console.log(`   opc run\n`);
-    } catch (err) {
-      console.error(`${icon.error} Install failed:`, err instanceof Error ? err.message : err);
-      process.exit(1);
-    }
+  .action(async () => {
+    console.log(`\n${icon.package} Agent install coming soon.\n`);
   });
 
 // 🔌 Plugin commands ────────────────────────────────────────

package/src/deploy/openclaw.ts

@@ -188,13 +188,3 @@ export function deployToOpenClaw(options: DeployOptions): DeployResult {
 
   return result;
 }
-:`, err);
-      }
-    } else {
-      console.error(`Warning: OpenClaw config not found at ${configPath}`);
-      console.error(`Run 'openclaw init' first, then re-run with --install`);
-    }
-  }
-
-  return result;
-}

package/src/index.ts

@@ -4,7 +4,7 @@ export { AgentRuntime, truncateOutput } from './core/runtime';
 export { Logger } from './core/logger';
 export { loadOAD, validateOAD } from './core/config';
 export { OADSchema } from './schema/oad';
-export type { OADDocument, Metadata, Spec, DTVConfig, TrustLevelType } from './schema/oad';
+export type { OADDocument, Metadata, Spec } 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';
@@ -14,9 +14,6 @@ export { BaseSkill } from './skills/base';
 export { SkillRegistry } from './skills';
 export { InMemoryStore } from './memory';
 export { DeepBrainMemoryStore } from './memory/deepbrain';
-export { TrustManager } from './dtv/trust';
-export { ValueTracker } from './dtv/value';
-export { MRGConfigReader } from './dtv/data';
 export { createProvider, SUPPORTED_PROVIDERS } from './providers';
 
 // v0.3.0 new modules
@@ -106,8 +103,6 @@ export { DiscordChannel } from './channels/discord';
 export type { DiscordChannelConfig } from './channels/discord';
 export { ProcessWatcher } from './core/watch';
 export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';
-export { ProcessWatcher } from './core/watch';
-export type { WatchPattern, WatchMatch, WatchOptions } from './core/watch';
 
 // v1.2.0 modules
 export { ToolGateway } from './tools/gateway';