opc-agent 1.3.1 → 1.4.0

package/dist/cli.js

@@ -118,7 +118,7 @@ async function select(question, options) {
 program
     .name('opc')
     .description('OPC Agent - Open Agent Framework for business workstations')
-    .version('1.0.0');
+    .version('1.4.0');
 // ── Init command ─────────────────────────────────────────────
 program
     .command('init')
@@ -138,6 +138,7 @@ program
         process.exit(1);
     }
     fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(path.join(dir, 'src', 'skills'), { recursive: true });
     const factory = TEMPLATES[template]?.factory ?? customer_service_1.createCustomerServiceConfig;
     const config = factory();
     config.metadata.name = name;
@@ -146,6 +147,93 @@ program
         config.spec.channels.push({ type: 'web', port: 3000 });
     }
     fs.writeFileSync(path.join(dir, 'oad.yaml'), yaml.dump(config, { lineWidth: 120 }));
+    // agent.yaml — standalone OAD config for runtime usage
+    fs.writeFileSync(path.join(dir, 'agent.yaml'), `apiVersion: opc/v1
+kind: Agent
+metadata:
+  name: ${name}
+  version: 1.0.0
+  description: My AI Agent
+spec:
+  model: qwen2.5
+  provider:
+    default: ollama
+  systemPrompt: |
+    You are a helpful AI assistant named ${name}.
+    Be concise, helpful, and friendly.
+  channels:
+    - type: web
+      port: 3000
+  memory:
+    shortTerm: true
+    longTerm:
+      provider: deepbrain
+  skills:
+    - name: echo
+      description: Echo test skill
+`);
+    // src/index.ts — entry point
+    fs.writeFileSync(path.join(dir, 'src', 'index.ts'), `import { AgentRuntime } from 'opc-agent';
+import { EchoSkill } from './skills/echo';
+
+async function main() {
+  const runtime = new AgentRuntime();
+
+  // Load OAD config
+  await runtime.loadConfig('./agent.yaml');
+
+  // Initialize agent with channels, memory, etc.
+  const agent = await runtime.initialize();
+
+  // Register custom skills
+  runtime.registerSkill(new EchoSkill());
+
+  // Start serving
+  await runtime.start();
+
+  console.log('🤖 Agent is running!');
+  console.log('   Web UI: http://localhost:3000');
+  console.log('   Press Ctrl+C to stop');
+}
+
+main().catch(console.error);
+`);
+    // src/skills/echo.ts — example skill
+    fs.writeFileSync(path.join(dir, 'src', 'skills', 'echo.ts'), `import { BaseSkill } from 'opc-agent';
+import type { AgentContext, Message, SkillResult } from 'opc-agent';
+
+export class EchoSkill extends BaseSkill {
+  name = 'echo';
+  description = 'Echo back the message (test skill)';
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    if (message.content.toLowerCase().startsWith('/echo ')) {
+      const text = message.content.slice(6);
+      return this.match(\`🔊 Echo: \${text}\`);
+    }
+    return this.noMatch();
+  }
+}
+`);
+    // tsconfig.json
+    fs.writeFileSync(path.join(dir, 'tsconfig.json'), JSON.stringify({
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'commonjs',
+            lib: ['ES2022'],
+            outDir: 'dist',
+            rootDir: 'src',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            declaration: true,
+            sourceMap: true,
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules', 'dist'],
+    }, null, 2));
     // .env.example
     fs.writeFileSync(path.join(dir, '.env.example'), `# LLM API Configuration
 OPC_LLM_API_KEY=your-api-key-here
@@ -156,9 +244,9 @@ OPC_LLM_MODEL=gpt-4o-mini
 # OPC_LLM_BASE_URL=https://api.deepseek.com/v1
 # OPC_LLM_MODEL=deepseek-chat
 
-# For local Ollama:
+# For local Ollama (default in agent.yaml):
 # OPC_LLM_BASE_URL=http://localhost:11434/v1
-# OPC_LLM_MODEL=llama3
+# OPC_LLM_MODEL=qwen2.5
 `);
     // .env (copy of example)
     fs.writeFileSync(path.join(dir, '.env'), `OPC_LLM_API_KEY=your-api-key-here
@@ -172,20 +260,27 @@ OPC_LLM_MODEL=gpt-4o-mini
         private: true,
         scripts: {
             start: 'opc run',
+            dev: 'opc dev',
             chat: 'opc chat',
+            build: 'tsc',
         },
         dependencies: {
-            'opc-agent': '^0.5.0',
+            'opc-agent': '^1.3.0',
+        },
+        devDependencies: {
+            typescript: '^5.5.0',
+            tsx: '^4.0.0',
         },
     }, null, 2));
     // .gitignore
-    fs.writeFileSync(path.join(dir, '.gitignore'), 'node_modules\n.env\n.opc-knowledge.json\ndata/\n');
+    fs.writeFileSync(path.join(dir, '.gitignore'), 'node_modules\ndist\n.env\n.opc-knowledge.json\ndata/\n');
     // Dockerfile
     fs.writeFileSync(path.join(dir, 'Dockerfile'), `FROM node:22-alpine
 WORKDIR /app
 COPY package.json package-lock.json* ./
 RUN npm ci --production 2>/dev/null || npm install --production
-COPY oad.yaml .env* ./
+COPY oad.yaml agent.yaml .env* ./
+COPY src/ ./src/
 COPY prompts/ ./prompts/ 2>/dev/null || true
 EXPOSE 3000
 CMD ["npx", "opc", "run"]
@@ -200,7 +295,7 @@ services:
     env_file:
       - .env
     volumes:
-      - ./oad.yaml:/app/oad.yaml:ro
+      - ./agent.yaml:/app/agent.yaml:ro
     restart: unless-stopped
 `);
     // README.md
@@ -210,51 +305,67 @@ Created with [OPC Agent](https://github.com/Deepleaper/opc-agent) using the \`${
 
 ## Quick Start
 
-1. **Set your API key:**
+1. **Install dependencies:**
    \`\`\`bash
-   # Edit .env and add your API key
-   cp .env.example .env
-   # Then edit .env with your actual key
+   npm install
    \`\`\`
 
-2. **Install dependencies:**
+2. **Run with Ollama (default):**
    \`\`\`bash
-   npm install
+   # Make sure Ollama is running with qwen2.5 model
+   ollama pull qwen2.5
+   npx tsx src/index.ts
    \`\`\`
 
-3. **Start the web server:**
+3. **Or use OpenAI/other providers:**
    \`\`\`bash
+   # Edit .env and set your API key
    npx opc run
    \`\`\`
 
 4. **Open browser:** [http://localhost:3000](http://localhost:3000)
 
-## CLI Chat
+## Development
 
 \`\`\`bash
-npx opc chat
+npx opc dev    # Hot-reload mode
+npx opc chat   # CLI chat
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${name}/
+├── agent.yaml          # OAD agent config (used by src/index.ts)
+├── oad.yaml            # OAD config (used by opc CLI)
+├── src/
+│   ├── index.ts        # Entry point
+│   └── skills/
+│       └── echo.ts     # Example skill
+├── package.json
+└── tsconfig.json
 \`\`\`
 
 ## Configuration
 
-Edit \`oad.yaml\` to customize your agent's personality, skills, and behavior.
+Edit \`agent.yaml\` to customize your agent's personality, skills, and behavior.
 `);
     console.log(`\n${icon.success} Created agent project: ${color.bold(name + '/')}`);
-    console.log(`   ${icon.file} oad.yaml      - Agent definition`);
-    console.log(`   ${icon.file} package.json  - Dependencies`);
-    console.log(`   ${icon.file} .env.example  - Environment template`);
-    console.log(`   ${icon.file} .env          - Environment config (edit this!)`);
+    console.log(`   ${icon.file} agent.yaml       - Agent definition (OAD)`);
+    console.log(`   ${icon.file} src/index.ts     - Entry point`);
+    console.log(`   ${icon.file} src/skills/echo.ts - Example skill`);
+    console.log(`   ${icon.file} package.json     - Dependencies`);
+    console.log(`   ${icon.file} tsconfig.json    - TypeScript config`);
+    console.log(`   ${icon.file} .env.example     - Environment template`);
     console.log(`   ${icon.file} .gitignore`);
     console.log(`   ${icon.file} Dockerfile`);
-    console.log(`   ${icon.file} docker-compose.yml`);
     console.log(`   ${icon.file} README.md`);
     console.log(`\n   Template: ${color.cyan(template)}`);
     console.log(`\n${color.bold('Next steps:')}`);
     console.log(`   1. cd ${name}`);
-    console.log(`   2. Edit .env — set your OPC_LLM_API_KEY`);
-    console.log(`   3. npm install`);
-    console.log(`   4. npx opc run`);
-    console.log(`   5. Open http://localhost:3000\n`);
+    console.log(`   2. npm install`);
+    console.log(`   3. npx tsx src/index.ts   ${color.dim('# or: npx opc run')}`);
+    console.log(`   4. Open http://localhost:3000\n`);
 });
 // ── Chat command ─────────────────────────────────────────────
 program

package/dist/core/runtime.d.ts

@@ -1,4 +1,5 @@
 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;
@@ -9,6 +10,7 @@ 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>;
@@ -18,5 +20,7 @@ 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,6 +9,7 @@ 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) {
@@ -24,6 +25,7 @@ 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 });
@@ -58,6 +60,12 @@ 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, {
@@ -66,15 +74,18 @@ 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();
                 });
@@ -94,6 +105,16 @@ 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;
     }
@@ -142,6 +163,12 @@ class AgentRuntime {
     getAgent() {
         return this.agent;
     }
+    getAnalytics() {
+        return this.analytics;
+    }
+    getConfig() {
+        return this.config;
+    }
 }
 exports.AgentRuntime = AgentRuntime;
 //# sourceMappingURL=runtime.js.map

package/dist/providers/index.d.ts

@@ -5,5 +5,5 @@ export interface LLMProvider {
     chatStream(messages: Message[], systemPrompt?: string): AsyncIterable<string>;
 }
 export declare function createProvider(name?: string, model?: string, baseUrl?: string, apiKey?: string): LLMProvider;
-export declare const SUPPORTED_PROVIDERS: readonly ["openai", "deepseek", "qwen", "gemini", "dashscope", "zhipu", "moonshot"];
+export declare const SUPPORTED_PROVIDERS: readonly ["openai", "ollama", "deepseek", "qwen", "gemini", "dashscope", "zhipu", "moonshot"];
 //# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -315,6 +315,12 @@ function isGeminiNative() {
 }
 function createProvider(name = 'openai', model, baseUrl, apiKey) {
     const finalModel = model || process.env.OPC_LLM_MODEL || 'gpt-4o-mini';
+    // Auto-detect ollama: use localhost:11434/v1 and dummy apiKey
+    if (name === 'ollama') {
+        const ollamaBase = baseUrl || process.env.OPC_LLM_BASE_URL || 'http://localhost:11434/v1';
+        const ollamaKey = apiKey || process.env.OPC_LLM_API_KEY || 'ollama';
+        return new OpenAICompatibleProvider('ollama', finalModel, ollamaBase, ollamaKey);
+    }
     const finalKey = apiKey || getApiKey();
     const finalBaseUrl = baseUrl || getBaseUrl();
     // Auto-detect Gemini native when key is new format or base URL points to googleapis
@@ -331,5 +337,5 @@ function createProvider(name = 'openai', model, baseUrl, apiKey) {
     }
     return new OpenAICompatibleProvider(resolvedName, finalModel, baseUrl, apiKey);
 }
-exports.SUPPORTED_PROVIDERS = ['openai', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'];
+exports.SUPPORTED_PROVIDERS = ['openai', 'ollama', 'deepseek', 'qwen', 'gemini', 'dashscope', 'zhipu', 'moonshot'];
 //# sourceMappingURL=index.js.map

package/examples/README.md

@@ -0,0 +1,22 @@
+# OPC Agent Examples
+
+## Run Examples
+
+```bash
+# Basic agent with skills
+npx tsx examples/basic-agent.ts
+
+# Multi-channel setup (Web + Telegram)
+npx tsx examples/multi-channel.ts
+
+# DeepBrain memory integration
+npx tsx examples/brain-integration.ts
+```
+
+## What Each Example Shows
+
+| Example | Concepts |
+|---------|----------|
+| `basic-agent.ts` | `BaseAgent`, `AgentRuntime`, `BaseSkill`, message handling |
+| `multi-channel.ts` | `WebChannel`, `TelegramChannel`, multi-channel config |
+| `brain-integration.ts` | `DeepBrainMemoryStore`, `InMemoryStore`, memory backends |

package/examples/basic-agent.ts

@@ -0,0 +1,90 @@
+/**
+ * OPC Agent Example: Basic Agent
+ *
+ * Create a simple agent with OAD config, register a skill, handle a message.
+ *
+ * Run: npx tsx examples/basic-agent.ts
+ */
+
+import {
+  BaseAgent,
+  AgentRuntime,
+  BaseSkill,
+  InMemoryStore,
+  type Message,
+  type AgentContext,
+  type SkillResult,
+} from 'opc-agent';
+
+// Define a custom skill
+class GreeterSkill extends BaseSkill {
+  name = 'greeter';
+  description = 'Responds to greetings';
+
+  canHandle(message: Message): boolean {
+    const text = message.content.toLowerCase();
+    return text.includes('hello') || text.includes('hi') || text.includes('hey');
+  }
+
+  async execute(message: Message, context: AgentContext): Promise<SkillResult> {
+    return {
+      content: `Hello! I'm ${context.agent?.name || 'Agent'}. How can I help you today?`,
+      confidence: 1.0,
+    };
+  }
+}
+
+async function main() {
+  console.log('🤖 OPC Agent — Basic Agent Demo\n');
+
+  try {
+    // Create agent with OAD-style config
+    const agent = new BaseAgent({
+      name: 'demo-agent',
+      description: 'A simple demo agent',
+      version: '1.0.0',
+    });
+
+    // Set up memory store
+    const memory = new InMemoryStore();
+
+    // Create runtime
+    const runtime = new AgentRuntime(agent, {
+      memory,
+    });
+
+    // Register skill
+    const greeter = new GreeterSkill();
+    runtime.registerSkill(greeter);
+
+    console.log(`✅ Agent "${agent.name}" created with ${1} skill\n`);
+
+    // Simulate messages
+    const testMessages: Message[] = [
+      { role: 'user', content: 'Hello there!' },
+      { role: 'user', content: 'What can you do?' },
+      { role: 'user', content: 'Hey, nice to meet you' },
+    ];
+
+    for (const msg of testMessages) {
+      console.log(`📨 User: ${msg.content}`);
+      const response = await runtime.handleMessage(msg);
+      console.log(`🤖 Agent: ${response?.content || '(no response)'}\n`);
+    }
+
+    console.log('✅ Done! OPC Agent supports:');
+    console.log('  • OAD config (YAML/JSON agent definition)');
+    console.log('  • Skill registration & routing');
+    console.log('  • Multi-channel (Web, Telegram, Slack, etc.)');
+    console.log('  • Memory stores (InMemory, DeepBrain)\n');
+    console.log('Next: npx tsx examples/multi-channel.ts');
+  } catch (e: any) {
+    console.error(`❌ Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch(e => {
+  console.error(`\n❌ Error: ${e.message}\n`);
+  process.exit(1);
+});

package/examples/brain-integration.ts

@@ -0,0 +1,71 @@
+/**
+ * OPC Agent Example: DeepBrain Memory Integration
+ *
+ * Shows how to use DeepBrainMemoryStore for persistent agent memory.
+ * Requires a running DeepBrain instance (or falls back to InMemory).
+ *
+ * Run: npx tsx examples/brain-integration.ts
+ */
+
+import {
+  BaseAgent,
+  AgentRuntime,
+  InMemoryStore,
+  DeepBrainMemoryStore,
+} from 'opc-agent';
+
+async function main() {
+  console.log('🧠 OPC Agent — DeepBrain Memory Integration\n');
+
+  try {
+    const agent = new BaseAgent({
+      name: 'brain-agent',
+      description: 'Agent with DeepBrain-powered memory',
+      version: '1.0.0',
+    });
+
+    // Try DeepBrain first, fall back to InMemory
+    let memory;
+    let memoryType: string;
+
+    try {
+      memory = new DeepBrainMemoryStore({
+        brainUrl: process.env.DEEPBRAIN_URL || 'http://localhost:3333',
+        agentId: 'brain-agent',
+      });
+      memoryType = 'DeepBrain';
+      console.log('✅ Using DeepBrain memory store');
+    } catch {
+      memory = new InMemoryStore();
+      memoryType = 'InMemory';
+      console.log('⚠️  DeepBrain unavailable, using InMemory fallback');
+    }
+
+    const runtime = new AgentRuntime(agent, { memory });
+
+    console.log(`\n📦 Memory store: ${memoryType}`);
+    console.log('\nDeepBrain vs InMemory:');
+    console.log('  ┌─────────────────┬────────────┬──────────────┐');
+    console.log('  │ Feature         │ InMemory   │ DeepBrain    │');
+    console.log('  ├─────────────────┼────────────┼──────────────┤');
+    console.log('  │ Persistence     │ ❌ (RAM)   │ ✅ (SQLite)  │');
+    console.log('  │ Semantic search │ ❌         │ ✅           │');
+    console.log('  │ Evolve          │ ❌         │ ✅           │');
+    console.log('  │ Multi-agent     │ ❌         │ ✅           │');
+    console.log('  │ Zero config     │ ✅         │ ✅           │');
+    console.log('  └─────────────────┴────────────┴──────────────┘\n');
+
+    console.log('✅ Done! To use DeepBrain:');
+    console.log('  npm install deepbrain');
+    console.log('  deepbrain serve  # starts on :3333');
+    console.log('  DEEPBRAIN_URL=http://localhost:3333 npx tsx examples/brain-integration.ts\n');
+  } catch (e: any) {
+    console.error(`❌ Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch(e => {
+  console.error(`\n❌ Error: ${e.message}\n`);
+  process.exit(1);
+});

package/examples/multi-channel.ts

@@ -0,0 +1,74 @@
+/**
+ * OPC Agent Example: Multi-Channel Setup
+ *
+ * Shows how to configure Web + Telegram channels for an agent.
+ * Note: This is a configuration demo — actual channel connections
+ * require valid tokens/endpoints.
+ *
+ * Run: npx tsx examples/multi-channel.ts
+ */
+
+import {
+  BaseAgent,
+  AgentRuntime,
+  WebChannel,
+  TelegramChannel,
+  InMemoryStore,
+} from 'opc-agent';
+
+async function main() {
+  console.log('🌐 OPC Agent — Multi-Channel Demo\n');
+
+  try {
+    const agent = new BaseAgent({
+      name: 'multi-channel-agent',
+      description: 'Agent that works across multiple channels',
+      version: '1.0.0',
+    });
+
+    const memory = new InMemoryStore();
+    const runtime = new AgentRuntime(agent, { memory });
+
+    // Channel 1: Web (HTTP endpoint)
+    const webChannel = new WebChannel({
+      port: 3000,
+      path: '/chat',
+    });
+    console.log('📡 Web channel configured: http://localhost:3000/chat');
+
+    // Channel 2: Telegram (requires BOT_TOKEN)
+    const telegramToken = process.env.TELEGRAM_BOT_TOKEN;
+    if (telegramToken) {
+      const telegramChannel = new TelegramChannel({
+        token: telegramToken,
+      });
+      runtime.addChannel(telegramChannel);
+      console.log('📱 Telegram channel configured');
+    } else {
+      console.log('📱 Telegram: skipped (set TELEGRAM_BOT_TOKEN to enable)');
+    }
+
+    // Register web channel
+    runtime.addChannel(webChannel);
+
+    console.log('\n✅ Agent configured with channels:');
+    console.log('  • Web:      HTTP REST endpoint');
+    console.log('  • Telegram: Bot API (optional)');
+    console.log('\nAvailable channels in OPC Agent:');
+    console.log('  WebChannel, TelegramChannel, WebSocketChannel,');
+    console.log('  SlackChannel, DiscordChannel, FeishuChannel,');
+    console.log('  EmailChannel, WeChatChannel, VoiceChannel,');
+    console.log('  WebhookChannel\n');
+
+    // In production you would call: await runtime.start();
+    console.log('💡 To start: await runtime.start()');
+  } catch (e: any) {
+    console.error(`❌ Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch(e => {
+  console.error(`\n❌ Error: ${e.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",