ideaco 1.1.5

package/src/core/agent/cli-agent/index.js

@@ -0,0 +1,154 @@
+import { BaseAgent } from '../base-agent.js';
+import { llmClient } from '../llm-agent/client.js';
+import { cliBackendRegistry } from './backends/index.js';
+
+/**
+ * CLIAgent — Communication engine powered by local CLI coding assistants.
+ *
+ * Pure communication layer: handles CLI execution, fallback LLM chat, provider management.
+ * No business logic (identity, memory, tasks) — that's the Employee layer.
+ */
+export class CLIAgent extends BaseAgent {
+  /**
+   * @param {object} config
+   * @param {string} config.cliBackend - CLI backend ID
+   * @param {object} [config.cliProvider] - CLI provider info (for display)
+   * @param {object} [config.fallbackProvider] - LLM provider for lightweight chat
+   */
+  constructor(config) {
+    super();
+    this.cliBackend = config.cliBackend;
+    this.cliProvider = config.cliProvider || null;
+    this.fallbackProvider = config.fallbackProvider || null;
+    // Backward compat: some external code reads agent.provider
+    this.provider = config.fallbackProvider || config.provider || null;
+  }
+
+  get agentType() {
+    return 'cli';
+  }
+
+  isAvailable() {
+    const backend = cliBackendRegistry.backends.get(this.cliBackend);
+    return !!(backend && (backend.state === 'detected' || backend.state === 'configured'));
+  }
+
+  canChat() {
+    return !!(this.fallbackProvider && this.fallbackProvider.enabled && this.fallbackProvider.apiKey && !this.fallbackProvider.isCLI);
+  }
+
+  setFallbackProvider(provider) {
+    if (provider && provider.enabled && provider.apiKey && !provider.isCLI) {
+      this.fallbackProvider = provider;
+      this.provider = provider;
+    }
+  }
+
+  async chat(messages, options = {}) {
+    if (!this.canChat()) {
+      throw new Error(`CLIAgent has no fallback LLM provider for chat`);
+    }
+    return await llmClient.chat(this.fallbackProvider, messages, options);
+  }
+
+  async chatWithTools(messages, toolExecutor, options = {}) {
+    if (!this.canChat()) {
+      throw new Error(`CLIAgent has no fallback LLM provider for chatWithTools`);
+    }
+    return await llmClient.chatWithTools(this.fallbackProvider, messages, toolExecutor, options);
+  }
+
+  getDisplayInfo() {
+    const backend = cliBackendRegistry.backends.get(this.cliBackend);
+    return {
+      name: this.cliProvider?.name || backend?.config?.name || this.cliBackend,
+      provider: 'Local CLI',
+      model: backend?.config?.execCommand || this.cliBackend,
+      type: 'cli',
+      category: 'cli',
+      backendId: this.cliBackend,
+    };
+  }
+
+  getProviderDisplayInfo() {
+    return {
+      id: this.cliProvider?.id,
+      name: this.cliProvider?.name,
+      provider: this.cliProvider?.provider || 'Local CLI',
+    };
+  }
+
+  getFallbackProviderName() {
+    return this.fallbackProvider?.name || this.provider?.name || null;
+  }
+
+  switchProvider(newProvider) {
+    if (newProvider.isCLI && newProvider.cliBackendId) {
+      this.cliBackend = newProvider.cliBackendId;
+      this.cliProvider = newProvider;
+    } else {
+      this.fallbackProvider = newProvider;
+      this.provider = newProvider;
+    }
+  }
+
+  getCostPerToken() {
+    return this.fallbackProvider?.costPerToken || this.provider?.costPerToken || 0.001;
+  }
+
+  serializeAgent() {
+    return {
+      agentType: 'cli',
+      cliBackend: this.cliBackend,
+      cliProvider: this.cliProvider ? {
+        id: this.cliProvider.id,
+        name: this.cliProvider.name,
+        provider: this.cliProvider.provider,
+        model: this.cliProvider.model,
+      } : null,
+      fallbackProvider: this.fallbackProvider ? {
+        id: this.fallbackProvider.id,
+        name: this.fallbackProvider.name,
+        provider: this.fallbackProvider.provider,
+        model: this.fallbackProvider.model,
+        category: this.fallbackProvider.category,
+        costPerToken: this.fallbackProvider.costPerToken,
+        enabled: this.fallbackProvider.enabled,
+      } : null,
+      provider: this.provider ? {
+        id: this.provider.id,
+        name: this.provider.name,
+        provider: this.provider.provider,
+        model: this.provider.model,
+        category: this.provider.category,
+        costPerToken: this.provider.costPerToken,
+        enabled: this.provider.enabled,
+      } : null,
+    };
+  }
+
+  /**
+   * Restore CLIAgent from serialized data.
+   */
+  static deserialize(data, providerRegistry) {
+    let fallbackProvider = data.fallbackProvider || null;
+    if (fallbackProvider?.id && providerRegistry) {
+      fallbackProvider = providerRegistry.getById(fallbackProvider.id) || fallbackProvider;
+    }
+    let provider = data.provider || null;
+    if (provider?.id && providerRegistry) {
+      provider = providerRegistry.getById(provider.id) || provider;
+    }
+    let cliProvider = data.cliProvider || null;
+    if (cliProvider?.id && providerRegistry) {
+      cliProvider = providerRegistry.getById(cliProvider.id) || cliProvider;
+    }
+
+    return new CLIAgent({
+      cliBackend: data.cliBackend,
+      cliProvider,
+      fallbackProvider: fallbackProvider || provider,
+      provider: provider || fallbackProvider,
+    });
+  }
+}

package/src/core/agent/index.js

@@ -0,0 +1,60 @@
+/**
+ * Agent module — pure communication engine layer.
+ *
+ * Agents handle ONLY: LLM/CLI/Web communication, provider management, availability.
+ * Business logic (identity, memory, tasks, org) lives in the Employee layer.
+ *
+ * Usage:
+ *   import { createAgent, LLMAgent, CLIAgent, WebAgent } from './agent/index.js';
+ */
+
+import { BaseAgent } from './base-agent.js';
+import { LLMAgent } from './llm-agent/index.js';
+import { CLIAgent } from './cli-agent/index.js';
+import { WebAgent } from './web-agent/index.js';
+
+/**
+ * Create an agent from config. Auto-picks LLMAgent, CLIAgent, or WebAgent.
+ * @param {object} config
+ * @returns {BaseAgent}
+ */
+export function createAgent(config) {
+  if (config.cliBackend) {
+    return new CLIAgent({
+      ...config,
+      fallbackProvider: config.provider,
+    });
+  }
+  if (config.provider?.isWeb) {
+    return new WebAgent(config);
+  }
+  return new LLMAgent(config);
+}
+
+/**
+ * Deserialize an agent from saved data. Auto-detects type.
+ * @param {object} data
+ * @param {object} [providerRegistry]
+ * @returns {BaseAgent}
+ */
+export function deserializeAgent(data, providerRegistry) {
+  if (data.agentType === 'cli' || data.cliBackend || data.brain?.type === 'cli') {
+    // Legacy brain data conversion
+    if (!data.cliBackend && data.brain?.backendId) {
+      data.cliBackend = data.brain.backendId;
+    }
+    if (!data.cliProvider && data.brain?.cliProvider) {
+      data.cliProvider = data.brain.cliProvider;
+    }
+    if (!data.fallbackProvider && data.brain?.fallbackProvider) {
+      data.fallbackProvider = data.brain.fallbackProvider;
+    }
+    return CLIAgent.deserialize(data, providerRegistry);
+  }
+  if (data.agentType === 'web' || data.provider?.isWeb) {
+    return WebAgent.deserialize(data, providerRegistry);
+  }
+  return LLMAgent.deserialize(data, providerRegistry);
+}
+
+export { BaseAgent, LLMAgent, CLIAgent, WebAgent };

package/src/core/agent/llm-agent/client.js

@@ -0,0 +1,320 @@
+/**
+ * Unified LLM Client - Makes real API calls to various model providers
+ * 
+ * Supports: OpenAI/GPT, Anthropic/Claude, DeepSeek, and other OpenAI-compatible APIs
+ * as well as image models like DALL-E, Midjourney
+ */
+import OpenAI from 'openai';
+import { auditLogger, AuditCategory, AuditLevel } from '../../system/audit.js';
+import { hookRegistry, HookEvent } from '../../../lib/hooks.js';
+
+/**
+ * Create an API client based on provider configuration
+ * @param {object} provider - Provider config object
+ * @returns {object} API client instance
+ */
+function createClient(provider) {
+  const { id, apiKey } = provider;
+
+  // OpenAI series (GPT, DALL-E)
+  if (id.startsWith('openai-')) {
+    return new OpenAI({ apiKey });
+  }
+
+  // Anthropic Claude - via OpenAI-compatible interface
+  if (id.startsWith('anthropic-')) {
+    return new OpenAI({
+      apiKey,
+      baseURL: 'https://api.anthropic.com/v1',
+      defaultHeaders: {
+        'anthropic-version': '2023-06-01',
+        'x-api-key': apiKey,
+      },
+    });
+  }
+
+  // DeepSeek - OpenAI-compatible interface
+  if (id.startsWith('deepseek-')) {
+    return new OpenAI({
+      apiKey,
+      baseURL: 'https://api.deepseek.com',
+    });
+  }
+
+  // Qwen (Tongyi Qianwen) - Alibaba Cloud DashScope OpenAI-compatible interface
+  if (id.startsWith('qwen-')) {
+    return new OpenAI({
+      apiKey,
+      baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+    });
+  }
+
+  // Default: use OpenAI-compatible interface
+  return new OpenAI({ apiKey });
+}
+
+/**
+ * Get model name for a given provider
+ */
+function getModelName(provider) {
+  const modelMap = {
+    'openai-gpt4': 'gpt-4-turbo',
+    'openai-gpt35': 'gpt-3.5-turbo',
+    'anthropic-claude': 'claude-3-5-sonnet-20241022',
+    'deepseek-v3': 'deepseek-chat',
+    'qwen-max': 'qwen-max',
+  };
+  return modelMap[provider.id] || provider.model || 'gpt-4-turbo';
+}
+
+/**
+ * Unified LLM communication client
+ */
+export class LLMClient {
+  constructor() {
+    // Cache created client instances
+    this.clients = new Map();
+  }
+
+  /**
+   * Get or create an API client
+   */
+  _getClient(provider) {
+    if (!provider.apiKey) {
+      throw new Error(`Provider ${provider.name} has no API Key configured`);
+    }
+    if (!this.clients.has(provider.id)) {
+      this.clients.set(provider.id, createClient(provider));
+    }
+    return this.clients.get(provider.id);
+  }
+
+  /**
+   * Send chat messages (general text models)
+   * 
+   * @param {object} provider - Provider config
+   * @param {Array<{role: string, content: string}>} messages - Message list
+   * @param {object} [options] - Extra options
+   * @param {string[]} [options.tools] - Available tool definitions
+   * @param {number} [options.temperature] - Temperature
+   * @param {number} [options.maxTokens] - Max tokens
+   * @returns {Promise<{content: string, toolCalls: Array|null, usage: object}>}
+   */
+  async chat(provider, messages, options = {}) {
+    const client = this._getClient(provider);
+    const model = getModelName(provider);
+
+    const requestParams = {
+      model,
+      messages,
+      temperature: options.temperature ?? 0.7,
+      max_tokens: options.maxTokens ?? 4096,
+    };
+
+    // Add tool definitions to request if provided
+    if (options.tools && options.tools.length > 0) {
+      requestParams.tools = options.tools;
+      requestParams.tool_choice = 'auto';
+    }
+
+    const startTime = Date.now();
+    try {
+      // Fire hook: LLM request start
+      hookRegistry.trigger(HookEvent.LLM_REQUEST_START, {
+        providerId: provider.id, model, agentId: options._agentId,
+      });
+
+      const response = await client.chat.completions.create(requestParams);
+      const choice = response.choices[0];
+      const latency = Date.now() - startTime;
+
+      // Audit log the LLM request
+      auditLogger.log({
+        category: AuditCategory.LLM_REQUEST,
+        level: AuditLevel.INFO,
+        agentId: options._agentId || 'system',
+        agentName: options._agentName || '',
+        action: `LLM call: ${provider.name} (${model}) - ${latency}ms`,
+        details: { providerId: provider.id, model, latency, usage: response.usage },
+      });
+
+      // Fire hook: LLM request end + token usage
+      hookRegistry.trigger(HookEvent.LLM_REQUEST_END, {
+        providerId: provider.id, model, latency,
+        usage: response.usage, agentId: options._agentId,
+      });
+      if (response.usage) {
+        hookRegistry.trigger(HookEvent.LLM_TOKEN_USAGE, {
+          providerId: provider.id, model,
+          promptTokens: response.usage.prompt_tokens || 0,
+          completionTokens: response.usage.completion_tokens || 0,
+          totalTokens: response.usage.total_tokens || 0,
+        });
+      }
+
+      return {
+        content: choice.message.content || '',
+        toolCalls: choice.message.tool_calls || null,
+        finishReason: choice.finish_reason,
+        usage: response.usage || {},
+      };
+    } catch (error) {
+      // Fire hook: LLM error
+      hookRegistry.trigger(HookEvent.LLM_ERROR, {
+        providerId: provider.id, model, error: error.message,
+        agentId: options._agentId,
+      });
+      console.error(`[LLMClient] Call to ${provider.name} failed:`, error.message);
+      throw new Error(`LLM call failed (${provider.name}): ${error.message}`);
+    }
+  }
+
+  /**
+   * Multi-turn conversation (with tool call loop)
+   * Core method for Agent task execution: send message -> model may call tools -> execute tools -> continue conversation
+   * 
+   * @param {object} provider - Provider config
+   * @param {Array} messages - Initial messages
+   * @param {object} toolExecutor - Tool executor { definitions, execute(name, args) }
+   * @param {object} [options] - Options
+   * @param {number} [options.maxIterations] - Max tool call loop iterations
+   * @returns {Promise<{content: string, toolResults: Array, messages: Array}>}
+   */
+  async chatWithTools(provider, messages, toolExecutor, options = {}) {
+    const maxIterations = options.maxIterations || 5;    const onToolCall = options.onToolCall || null;  // Callback: notify on tool call
+    const onLLMCall = options.onLLMCall || null;    // Callback: notify on each LLM call
+    const conversationMessages = [...messages];
+    const toolResults = [];
+
+    for (let i = 0; i < maxIterations; i++) {
+      // Notify: about to call LLM
+      if (onLLMCall) {
+        try { onLLMCall({ iteration: i + 1, maxIterations }); } catch {}
+      }
+
+      const response = await this.chat(provider, conversationMessages, {
+        tools: toolExecutor.definitions,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+      });
+
+      // If no tool calls, return final result
+      if (!response.toolCalls || response.toolCalls.length === 0) {
+        return {
+          content: response.content,
+          toolResults,
+          messages: conversationMessages,
+          usage: response.usage,
+        };
+      }
+
+      // Process tool calls
+      conversationMessages.push({
+        role: 'assistant',
+        content: response.content,
+        tool_calls: response.toolCalls,
+      });
+
+      for (const toolCall of response.toolCalls) {
+        const { name, arguments: argsStr } = toolCall.function;
+        let args;
+        try {
+          args = JSON.parse(argsStr);
+        } catch (parseErr) {
+          console.warn(`  ⚠️ [Tool Call] Failed to parse arguments for ${name}: ${argsStr?.slice(0, 200)}`);
+          try {
+            const cleaned = (argsStr || '{}').replace(/,\s*}/g, '}').replace(/,\s*]/g, ']').replace(/'/g, '"');
+            args = JSON.parse(cleaned);
+          } catch {
+            args = {};
+          }
+        }
+
+        console.log(`  🔧 [Tool Call] ${name}(${JSON.stringify(args).slice(0, 100)}...)`);
+
+        // Notify: calling tool
+        if (onToolCall) {
+          try { onToolCall({ tool: name, args, status: 'start' }); } catch {}
+        }
+
+        let result;
+        try {
+          result = await toolExecutor.execute(name, args);
+          toolResults.push({ tool: name, args, result, success: true });
+          if (onToolCall) {
+            try { onToolCall({ tool: name, args, status: 'done', success: true }); } catch {}
+          }
+        } catch (error) {
+          result = `Tool execution error: ${error.message}`;
+          toolResults.push({ tool: name, args, error: error.message, success: false });
+          if (onToolCall) {
+            try { onToolCall({ tool: name, args, status: 'error', error: error.message }); } catch {}
+          }
+        }
+
+        conversationMessages.push({
+          role: 'tool',
+          tool_call_id: toolCall.id,
+          content: typeof result === 'string' ? result : JSON.stringify(result),
+        });
+      }
+    }
+
+    // Exceeded max iterations, make one final call without tools
+    const finalResponse = await this.chat(provider, conversationMessages, {
+      temperature: options.temperature,
+      maxTokens: options.maxTokens,
+    });
+
+    return {
+      content: finalResponse.content,
+      toolResults,
+      messages: conversationMessages,
+      usage: finalResponse.usage,
+    };
+  }
+
+  /**
+   * Generate image (image models)
+   * 
+   * @param {object} provider - Provider config
+   * @param {string} prompt - Image description
+   * @param {object} [options] - Options
+   * @returns {Promise<{url: string, revisedPrompt: string}>}
+   */
+  async generateImage(provider, prompt, options = {}) {
+    const client = this._getClient(provider);
+
+    try {
+      const response = await client.images.generate({
+        model: provider.model || 'dall-e-3',
+        prompt,
+        n: 1,
+        size: options.size || '1024x1024',
+        quality: options.quality || 'standard',
+      });
+
+      return {
+        url: response.data[0].url,
+        revisedPrompt: response.data[0].revised_prompt || prompt,
+      };
+    } catch (error) {
+      console.error(`[LLMClient] Image generation failed (${provider.name}):`, error.message);
+      throw new Error(`Image generation failed (${provider.name}): ${error.message}`);
+    }
+  }
+
+  /**
+   * Clear cached client (call when provider API Key is updated)
+   */
+  clearClient(providerId) {
+    this.clients.delete(providerId);
+  }
+
+  clearAll() {
+    this.clients.clear();
+  }
+}
+
+// Global singleton
+export const llmClient = new LLMClient();

package/src/core/agent/llm-agent/index.js

@@ -0,0 +1,97 @@
+import { BaseAgent } from '../base-agent.js';
+import { llmClient } from './client.js';
+
+/**
+ * LLMAgent — Communication engine powered by API-based LLM models.
+ *
+ * Pure communication layer: handles chat, tool-calling, provider management.
+ * No business logic (identity, memory, tasks) — that's the Employee layer.
+ */
+export class LLMAgent extends BaseAgent {
+  /**
+   * @param {object} config
+   * @param {object} config.provider - Provider config from ProviderRegistry
+   */
+  constructor(config) {
+    super();
+    this.provider = config.provider;
+  }
+
+  get agentType() {
+    return 'llm';
+  }
+
+  isAvailable() {
+    return !!(this.provider && this.provider.enabled && this.provider.apiKey);
+  }
+
+  canChat() {
+    return this.isAvailable();
+  }
+
+  async chat(messages, options = {}) {
+    if (!this.isAvailable()) {
+      throw new Error(`LLMAgent provider "${this.provider?.name}" is not available`);
+    }
+    return await llmClient.chat(this.provider, messages, options);
+  }
+
+  async chatWithTools(messages, toolExecutor, options = {}) {
+    if (!this.isAvailable()) {
+      throw new Error(`LLMAgent provider "${this.provider?.name}" is not available`);
+    }
+    return await llmClient.chatWithTools(this.provider, messages, toolExecutor, options);
+  }
+
+  getDisplayInfo() {
+    return {
+      name: this.provider?.name || 'Unknown LLM',
+      provider: this.provider?.provider || 'Unknown',
+      model: this.provider?.model || 'unknown',
+      type: 'llm',
+      category: this.provider?.category || 'general',
+    };
+  }
+
+  getProviderDisplayInfo() {
+    return {
+      id: this.provider?.id,
+      name: this.provider?.name,
+      provider: this.provider?.provider,
+    };
+  }
+
+  switchProvider(newProvider) {
+    this.provider = newProvider;
+  }
+
+  getCostPerToken() {
+    return this.provider?.costPerToken || 0.001;
+  }
+
+  serializeAgent() {
+    return {
+      agentType: 'llm',
+      provider: this.provider ? {
+        id: this.provider.id,
+        name: this.provider.name,
+        provider: this.provider.provider,
+        model: this.provider.model,
+        category: this.provider.category,
+        costPerToken: this.provider.costPerToken,
+        enabled: this.provider.enabled,
+      } : null,
+    };
+  }
+
+  /**
+   * Restore LLMAgent from serialized data.
+   */
+  static deserialize(data, providerRegistry) {
+    let provider = data.provider;
+    if (providerRegistry && data.provider?.id) {
+      provider = providerRegistry.getById(data.provider.id) || data.provider;
+    }
+    return new LLMAgent({ provider });
+  }
+}