opc-agent 4.0.43 → 4.1.0

package/dist/studio/server.js

@@ -166,12 +166,96 @@ class StudioServer {
                 const industry = url.searchParams.get('industry') || '';
                 const search = url.searchParams.get('q') || '';
                 data = this.getTemplates(industry, search);
+                // Merge with real workstation templates
+                try {
+                    const ws = require('agent-workstation');
+                    const categories = ws.getCategories();
+                    const wsTemplates = [];
+                    for (const cat of categories) {
+                        for (const roleName of cat.roles) {
+                            const role = ws.getRole(cat.name, roleName);
+                            if (!role)
+                                continue;
+                            let oad = {};
+                            try {
+                                if (role.files?.['oad.yaml']) {
+                                    const yaml = require('js-yaml');
+                                    oad = yaml.load(role.files['oad.yaml']) || {};
+                                }
+                            }
+                            catch { }
+                            const tpl = {
+                                id: `ws-${cat.name}-${roleName}`,
+                                name: oad.name || roleName.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+                                nameZh: oad.nameZh || '',
+                                icon: oad.icon || '🤖',
+                                description: oad.description || '',
+                                descriptionZh: oad.descriptionZh || '',
+                                industry: cat.name,
+                                industryZh: cat.name,
+                                tags: [cat.name, 'workstation'],
+                                suggestedModel: 'auto',
+                                systemPrompt: oad.systemPrompt || role.files?.['brain-seed.md'] || '',
+                                source: 'workstation',
+                                ego: oad.ego || null,
+                                mission: oad.mission || null,
+                                skills: oad.skills || [],
+                            };
+                            if (!search || tpl.name.toLowerCase().includes(search.toLowerCase()) || tpl.nameZh.includes(search)) {
+                                if (!industry || tpl.industry === industry) {
+                                    wsTemplates.push(tpl);
+                                }
+                            }
+                        }
+                    }
+                    data.templates = [...data.templates, ...wsTemplates];
+                    // Add workstation industries to list
+                    const existingIds = new Set(data.industries.map((i) => i.id));
+                    for (const cat of categories) {
+                        if (!existingIds.has(cat.name)) {
+                            data.industries.push({ id: cat.name, name: cat.name, nameZh: cat.name });
+                        }
+                    }
+                }
+                catch (wsErr) {
+                    // workstation not available, use built-in templates only
+                }
                 res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
                 res.end(JSON.stringify(data));
                 return;
             }
             if (route.match(/^templates\/[^/]+$/) && req.method === 'GET') {
                 const tplId = route.split('/')[1];
+                // Check workstation first
+                if (tplId.startsWith('ws-')) {
+                    const parts = tplId.replace('ws-', '').split('-');
+                    const catName = parts[0];
+                    const roleName = parts.slice(1).join('-');
+                    try {
+                        const ws = require('agent-workstation');
+                        const role = ws.getRole(catName, roleName);
+                        if (role) {
+                            let oad = {};
+                            try {
+                                if (role.files?.['oad.yaml']) {
+                                    const yaml = require('js-yaml');
+                                    oad = yaml.load(role.files['oad.yaml']) || {};
+                                }
+                            }
+                            catch { }
+                            data = {
+                                id: tplId, name: oad.name || roleName, source: 'workstation',
+                                category: catName, role: roleName, files: role.files,
+                                ego: oad.ego, mission: oad.mission, skills: oad.skills,
+                                systemPrompt: oad.systemPrompt || role.files?.['brain-seed.md'] || '',
+                            };
+                            res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                            res.end(JSON.stringify(data));
+                            return;
+                        }
+                    }
+                    catch { }
+                }
                 data = this.getTemplateById(tplId);
                 res.writeHead(data.error ? 404 : 200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
                 res.end(JSON.stringify(data));
@@ -473,6 +557,64 @@ class StudioServer {
                 res.end(JSON.stringify(data));
                 return;
             }
+            // === Global config API (reads/writes ~/.opc/config.json) ===
+            if (route === 'config' && req.method === 'GET') {
+                data = loadSettingsConfig();
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route === 'config' && req.method === 'PUT') {
+                const body = JSON.parse(await this.readBody(req));
+                const cfg = loadSettingsConfig();
+                Object.assign(cfg, body);
+                saveSettingsConfig(cfg);
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify({ success: true, config: cfg }));
+                return;
+            }
+            // === Models API (real agentkits integration) ===
+            if (route === 'models' && req.method === 'GET') {
+                try {
+                    const ak = await Promise.resolve().then(() => __importStar(require('agentkits')));
+                    const providers = ak.listLLMProviders();
+                    data = { providers };
+                }
+                catch (e) {
+                    data = { providers: [], error: 'agentkits not available: ' + e.message };
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            // === Memory stats API (real deepbrain integration) ===
+            if (route === 'memory/stats' && req.method === 'GET') {
+                try {
+                    const { Brain } = require('deepbrain');
+                    const oad = this.loadOAD();
+                    const dbPath = oad?.spec?.memory?.longTerm?.database || './data/brain.db';
+                    const brain = new Brain({ database: dbPath, embedding_provider: 'ollama' });
+                    await brain.connect();
+                    const stats = await brain.stats();
+                    await brain.disconnect();
+                    data = { connected: true, ...stats };
+                }
+                catch {
+                    data = { connected: false, pages: 0, chunks: 0, error: 'DeepBrain not installed or not configured. Install with: npm i deepbrain' };
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                res.end(JSON.stringify(data));
+                return;
+            }
+            if (route.match(/^memory\/[^/]+$/) && req.method === 'GET') {
+                const agentId = route.split('/')[1];
+                if (agentId !== 'stats' && agentId !== 'list' && agentId !== 'search') {
+                    data = this.getAgentMemory(agentId);
+                    res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+                    res.end(JSON.stringify(data));
+                    return;
+                }
+            }
             switch (route) {
                 case 'modules':
                     data = await this.getModulesStatus();
@@ -710,8 +852,21 @@ class StudioServer {
         return { entries, timeline: entries.map((e) => ({ date: e.timestamp, summary: e.summary || e.content?.slice(0, 100) })) };
     }
     async handleAgentChat(req, res, agentId) {
-        const body = JSON.parse(await this.readBody(req));
-        const { messages = [] } = body;
+        let body;
+        try {
+            body = JSON.parse(await this.readBody(req));
+        }
+        catch {
+            res.writeHead(400, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+            res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+            return;
+        }
+        // Accept both { messages: [...] } and { message: "...", history: [...] }
+        let messages = body.messages || [];
+        if (body.message) {
+            // Frontend sends { message, history }
+            messages = [...(body.history || []), { role: 'user', content: body.message }];
+        }
         const agent = this.getAgentById(agentId);
         if (agent.error) {
             res.writeHead(404, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
@@ -722,8 +877,8 @@ class StudioServer {
         agent.messageCount = (agent.messageCount || 0) + 1;
         agent.lastActive = new Date().toISOString();
         agent.updated = new Date().toISOString();
-        const filePath = (0, path_1.join)(this.getAgentsDir(), `${agentId}.json`);
-        (0, fs_1.writeFileSync)(filePath, JSON.stringify(agent, null, 2));
+        const agentFilePath = (0, path_1.join)(this.getAgentsDir(), `${agentId}.json`);
+        (0, fs_1.writeFileSync)(agentFilePath, JSON.stringify(agent, null, 2));
         // SSE streaming response
         res.writeHead(200, {
             'Content-Type': 'text/event-stream',
@@ -731,30 +886,31 @@ class StudioServer {
             'Connection': 'keep-alive',
             'Access-Control-Allow-Origin': '*',
         });
-        const allMsgs = [{ role: 'system', content: agent.systemPrompt }, ...messages];
-        const lastMsg = allMsgs[allMsgs.length - 1]?.content || '';
         // Use createProvider directly to call LLM
         try {
             const { createProvider } = require('../providers');
-            // Read OAD config for provider info
+            // Determine provider: agent config > OAD yaml > env > auto
             let providerName = agent.provider || process.env.OPC_LLM_PROVIDER;
             if (!providerName) {
-                // Try reading from oad.yaml
                 try {
-                    const oadPath = (0, path_1.join)(this.config.agentDir, 'oad.yaml');
-                    if ((0, fs_1.existsSync)(oadPath)) {
-                        const yaml = require('js-yaml');
-                        const oad = yaml.load((0, fs_1.readFileSync)(oadPath, 'utf-8'));
-                        providerName = oad?.spec?.provider?.default;
+                    for (const fname of ['oad.yaml', 'agent.yaml']) {
+                        const oadPath = (0, path_1.join)(this.config.agentDir, fname);
+                        if ((0, fs_1.existsSync)(oadPath)) {
+                            const yaml = require('js-yaml');
+                            const oad = yaml.load((0, fs_1.readFileSync)(oadPath, 'utf-8'));
+                            providerName = oad?.spec?.provider?.default;
+                            if (providerName)
+                                break;
+                        }
                     }
                 }
                 catch { }
             }
-            providerName = providerName || 'openai';
+            providerName = providerName || 'auto';
             const provider = createProvider(providerName, agent.model);
             let fullText = '';
             try {
-                for await (const chunk of provider.chatStream(allMsgs, agent.systemPrompt)) {
+                for await (const chunk of provider.chatStream(messages, agent.systemPrompt)) {
                     const sseData = JSON.stringify({
                         choices: [{ delta: { content: chunk }, index: 0 }],
                     });
@@ -764,8 +920,9 @@ class StudioServer {
             }
             catch (streamErr) {
                 if (!fullText) {
-                    // No content streamed yet, send error
-                    const errData = JSON.stringify({ error: streamErr.message });
+                    const errData = JSON.stringify({
+                        choices: [{ delta: { content: `⚠️ LLM Error: ${streamErr.message}` }, index: 0 }],
+                    });
                     res.write(`data: ${errData}\n\n`);
                 }
             }
@@ -773,8 +930,13 @@ class StudioServer {
             res.end();
         }
         catch (err) {
-            // Fallback: try simulated response
-            this.sendSimulatedResponse(res, lastMsg, agent);
+            // Provider creation failed — send error as SSE so frontend can display it
+            const errData = JSON.stringify({
+                choices: [{ delta: { content: `⚠️ Provider error: ${err.message}\n\nTip: Install Claude CLI (npm i -g @anthropic-ai/claude-code) or set OPENAI_API_KEY.` }, index: 0 }],
+            });
+            res.write(`data: ${errData}\n\n`);
+            res.write('data: [DONE]\n\n');
+            res.end();
         }
     }
     sendSimulatedResponse(res, lastMsg, agent) {

package/dist/studio-ui/index.html

@@ -1317,26 +1317,61 @@
 
       agentChatHistory.push({ role: 'user', content: msg });
 
-      // Send to API
+      // Add assistant message placeholder
+      const assistantDiv = document.createElement('div');
+      assistantDiv.className = 'agent-chat-msg assistant';
+      assistantDiv.textContent = '';
+      messagesEl.appendChild(assistantDiv);
+
+      // Send to API and parse SSE stream
       try {
         const res = await fetch(`/api/agents/${selectedAgentId}/chat`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ message: msg, history: agentChatHistory })
+          body: JSON.stringify({ message: msg, history: agentChatHistory.slice(0, -1) })
         });
-        const data = await res.json();
-        const reply = data.reply || data.message || data.content || JSON.stringify(data);
-        const assistantDiv = document.createElement('div');
-        assistantDiv.className = 'agent-chat-msg assistant';
-        assistantDiv.textContent = reply;
-        messagesEl.appendChild(assistantDiv);
-        agentChatHistory.push({ role: 'assistant', content: reply });
+
+        if (!res.ok) {
+          let errMsg = `HTTP ${res.status}`;
+          try { const ej = await res.json(); errMsg = ej.error || errMsg; } catch {}
+          throw new Error(errMsg);
+        }
+
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let fullReply = '';
+        let buffer = '';
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: ')) continue;
+            const data = trimmed.slice(6);
+            if (data === '[DONE]') continue;
+            try {
+              const parsed = JSON.parse(data);
+              const content = parsed.choices?.[0]?.delta?.content;
+              if (content) {
+                fullReply += content;
+                assistantDiv.textContent = fullReply;
+                messagesEl.scrollTop = messagesEl.scrollHeight;
+              }
+            } catch {}
+          }
+        }
+
+        if (!fullReply) {
+          assistantDiv.textContent = '(No response received)';
+        }
+        agentChatHistory.push({ role: 'assistant', content: fullReply });
       } catch(e) {
-        const errDiv = document.createElement('div');
-        errDiv.className = 'agent-chat-msg assistant';
-        errDiv.style.borderColor = 'var(--red)';
-        errDiv.textContent = `⚠️ 发送失败: ${e.message}`;
-        messagesEl.appendChild(errDiv);
+        assistantDiv.style.borderColor = 'var(--red)';
+        assistantDiv.textContent = `⚠️ 发送失败: ${e.message}`;
       }
       messagesEl.scrollTop = messagesEl.scrollHeight;
     }

package/package.json

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

package/src/cli.ts

@@ -771,7 +771,7 @@ program
     let model: string | undefined;
     let agentName = 'Agent';
     let agentVersion = '1.0.0';
-    let providerName = 'openai';
+    let providerName = 'auto';
     let skillNames: string[] = [];
 
     // Try loading SOUL.md and CONTEXT.md for enriched system prompt
@@ -796,7 +796,7 @@ program
     // Prepend SOUL.md and CONTEXT.md to system prompt
     systemPrompt = [soulContent, contextContent, systemPrompt].filter(Boolean).join('\n\n');
 
-    const provider = createProvider('openai', model);
+    const provider = createProvider(providerName, model);
     const history: { role: 'user' | 'assistant' | 'system'; content: string }[] = [];
 
     // Print startup banner

package/src/core/runtime.ts

@@ -44,6 +44,24 @@ export class AgentRuntime {
   private evolveScheduler: any = null;
 
   async loadConfig(filePath: string): Promise<OADDocument> {
+    const fs = require('fs');
+    if (!fs.existsSync(filePath)) {
+      // Auto-create a minimal oad.yaml with auto-detect provider
+      const yaml = require('js-yaml');
+      const defaultOAD = {
+        apiVersion: 'opc/v1',
+        kind: 'Agent',
+        metadata: { name: 'my-agent', version: '1.0.0', description: 'OPC Agent' },
+        spec: {
+          model: 'auto',
+          provider: { default: 'auto' },
+          systemPrompt: 'You are a helpful AI assistant.',
+          channels: [{ type: 'web', config: { port: 3000 } }],
+        },
+      };
+      fs.writeFileSync(filePath, yaml.dump(defaultOAD, { lineWidth: 120 }));
+      this.logger.info('Created default oad.yaml (no config file found)');
+    }
     this.config = loadOAD(filePath);
     this.logger.info('Config loaded', { name: this.config.metadata.name });
     return this.config;

package/src/providers/index.ts

@@ -330,7 +330,17 @@ class ClaudeCLIProvider implements LLMProvider {
   private model: string;
 
   constructor(model?: string) {
-    this.model = model || 'sonnet';
+    // Claude CLI uses short model names; don't pass API-style model names
+    // Let Claude CLI use its default model unless explicitly set to a known CLI model
+    const cliModels = ['sonnet', 'opus', 'haiku', 'claude-sonnet-4-20250514', 'claude-opus-4-20250514'];
+    if (model && !cliModels.includes(model)) {
+      // Map common patterns
+      if (model.includes('opus')) this.model = 'opus';
+      else if (model.includes('haiku')) this.model = 'haiku';
+      else this.model = ''; // let CLI choose default
+    } else {
+      this.model = model || '';
+    }
   }
 
   async chat(messages: Message[], systemPrompt?: string, options?: ChatOptions): Promise<string> {
@@ -349,7 +359,7 @@ class ClaudeCLIProvider implements LLMProvider {
       prompt += buildToolPrompt(options.tools);
     }
 
-    const args = ['-p', '--no-project-context'];
+    const args = ['-p'];
     // Write system prompt to temp file to avoid shell escaping issues
     let tmpFile: string | undefined;
     if (systemPrompt) {
@@ -410,7 +420,7 @@ class ClaudeCLIProvider implements LLMProvider {
   }
 
   async *chatStream(messages: Message[], systemPrompt?: string): AsyncIterable<string> {
-    const args = ['-p', '--no-project-context', '--output-format', 'stream-json', '--include-partial-messages'];
+    const args = ['-p', '--verbose', '--output-format', 'stream-json'];
     if (this.model) {
       args.push('--model', this.model);
     }
@@ -451,14 +461,24 @@ class ClaudeCLIProvider implements LLMProvider {
           if (!trimmed) continue;
           try {
             const event = JSON.parse(trimmed);
-            // Handle partial message chunks (content_block_delta style)
-            if (event.type === 'content' && event.content) {
-              const newContent = event.content;
-              if (newContent.length > lastContent.length) {
-                yield newContent.slice(lastContent.length);
-                lastContent = newContent;
+            // Claude CLI stream-json format:
+            // {"type":"assistant","message":{"content":[{"type":"text","text":"..."}]}}
+            if (event.type === 'assistant' && event.message?.content) {
+              for (const block of event.message.content) {
+                if (block.type === 'text' && block.text) {
+                  const newContent = block.text;
+                  if (newContent.length > lastContent.length) {
+                    yield newContent.slice(lastContent.length);
+                    lastContent = newContent;
+                  }
+                }
               }
             }
+            // Also handle result type for final content
+            if (event.type === 'result' && event.result) {
+              const remaining = event.result.slice(lastContent.length);
+              if (remaining) yield remaining;
+            }
             // Handle assistant message with content array
             if (event.type === 'assistant' && event.message?.content) {
               for (const block of event.message.content) {
@@ -513,7 +533,72 @@ class ClaudeCLIProvider implements LLMProvider {
   }
 }
 
-export function createProvider(name: string = 'openai', model?: string, baseUrl?: string, apiKey?: string): LLMProvider {
+import { execSync } from 'child_process';
+
+function detectClaudeCLI(): boolean {
+  try {
+    execSync('claude --version', { stdio: 'pipe', timeout: 3000 });
+    return true;
+  } catch { return false; }
+}
+
+function detectOllama(): boolean {
+  try {
+    // Use node http instead of curl for Windows compatibility
+    const { execSync: es } = require('child_process');
+    // Quick check: try to connect to Ollama API via node
+    const result = es(
+      `node -e "const h=require('http');const r=h.get('http://localhost:11434/api/tags',{timeout:2000},s=>{let d='';s.on('data',c=>d+=c);s.on('end',()=>{process.stdout.write(d.includes('models')?'1':'0')})});r.on('error',()=>process.stdout.write('0'));r.on('timeout',()=>{r.destroy();process.stdout.write('0')})"`,
+      { stdio: 'pipe', timeout: 5000 }
+    );
+    return result.toString().trim() === '1';
+  } catch { return false; }
+}
+
+function detectApiKeys(): { provider: string; key: string; baseUrl?: string } | null {
+  if (process.env.ANTHROPIC_API_KEY) return { provider: 'anthropic', key: process.env.ANTHROPIC_API_KEY };
+  if (process.env.OPENAI_API_KEY && process.env.OPENAI_API_KEY !== 'your-api-key-here') return { provider: 'openai', key: process.env.OPENAI_API_KEY };
+  if (process.env.DEEPSEEK_API_KEY) return { provider: 'deepseek', key: process.env.DEEPSEEK_API_KEY, baseUrl: 'https://api.deepseek.com/v1' };
+  if (process.env.DASHSCOPE_API_KEY) return { provider: 'qwen', key: process.env.DASHSCOPE_API_KEY, baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1' };
+  if (process.env.GEMINI_API_KEY) return { provider: 'gemini', key: process.env.GEMINI_API_KEY };
+  return null;
+}
+
+export function autoDetectProvider(): { name: string; model?: string; baseUrl?: string; apiKey?: string } {
+  // 1. Claude CLI (zero config, Claude Max/Pro subscription)
+  if (detectClaudeCLI()) {
+    return { name: 'claude-cli' };
+  }
+
+  // 2. API keys from environment
+  const apiKey = detectApiKeys();
+  if (apiKey) {
+    return { name: apiKey.provider, apiKey: apiKey.key, baseUrl: apiKey.baseUrl };
+  }
+
+  // 3. Ollama (local, free)
+  if (detectOllama()) {
+    return { name: 'ollama', model: 'qwen2.5:7b' };
+  }
+
+  // 4. Nothing found
+  return { name: 'none' };
+}
+
+export function createProvider(name: string = 'auto', model?: string, baseUrl?: string, apiKey?: string): LLMProvider {
+  // Auto-detect if name is 'auto' or default openai with no real key
+  const needsAutoDetect = name === 'auto' || (name === 'openai' && !apiKey && (!process.env.OPENAI_API_KEY || process.env.OPENAI_API_KEY === 'your-api-key-here'));
+  if (needsAutoDetect) {
+    const detected = autoDetectProvider();
+    if (detected.name !== 'none') {
+      console.log(`[provider] Auto-detected: ${detected.name}`);
+      name = detected.name;
+      model = model || detected.model;
+      baseUrl = baseUrl || detected.baseUrl;
+      apiKey = apiKey || detected.apiKey;
+    }
+  }
+
   const finalModel = model || process.env.OPC_LLM_MODEL || 'gpt-4o-mini';
 
   // Claude CLI mode: use local claude command (Claude Max/Pro subscription)