neoagent 1.0.0

package/server/services/ai/models.js

@@ -0,0 +1,46 @@
+const { GrokProvider } = require('./providers/grok');
+const { OpenAIProvider } = require('./providers/openai');
+const { GoogleProvider } = require('./providers/google');
+
+const SUPPORTED_MODELS = [
+    {
+        id: 'grok-4-1-fast-reasoning',
+        label: 'Grok 4.1 (Personality / Default)',
+        provider: 'grok',
+        purpose: 'general'
+    },
+    {
+        id: 'gpt-5-nano',
+        label: 'GPT-5 Nano (Fast / Subagents)',
+        provider: 'openai',
+        purpose: 'fast'
+    },
+    {
+        id: 'gpt-5-mini',
+        label: 'GPT-5 Mini (Planning / Complex)',
+        provider: 'openai',
+        purpose: 'planning'
+    },
+    {
+        id: 'gemini-3.1-flash-lite-preview',
+        label: 'Gemini 3.1 Flash Lite (Preview)',
+        provider: 'google',
+        purpose: 'general'
+    }
+];
+
+function createProviderInstance(providerStr) {
+    if (providerStr === 'grok') {
+        return new GrokProvider({ apiKey: process.env.XAI_API_KEY });
+    } else if (providerStr === 'openai') {
+        return new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY });
+    } else if (providerStr === 'google') {
+        return new GoogleProvider({ apiKey: process.env.GOOGLE_AI_KEY });
+    }
+    throw new Error(`Unknown provider: ${providerStr}`);
+}
+
+module.exports = {
+    SUPPORTED_MODELS,
+    createProviderInstance
+};

package/server/services/ai/multiStep.js

@@ -0,0 +1,112 @@
+const { v4: uuidv4 } = require('uuid');
+const db = require('../../db/database');
+const { AgentEngine } = require('./engine');
+
+class MultiStepOrchestrator {
+  constructor(engine, io) {
+    this.io = io;
+    this.engine = engine;
+    this.activeOrchestrations = new Map();
+  }
+
+  async planAndExecute(userId, task, options = {}) {
+    const orchestrationId = uuidv4();
+    const app = options.app;
+
+    this.activeOrchestrations.set(orchestrationId, {
+      userId,
+      task,
+      status: 'planning',
+      steps: [],
+      currentStep: 0
+    });
+
+    this.emit(userId, 'orchestration:start', { orchestrationId, task });
+
+    try {
+      const result = await this.engine.run(userId, task, {
+        runId: orchestrationId,
+        conversationId: options.conversationId,
+        app,
+        triggerType: options.triggerType || 'user',
+        triggerSource: options.triggerSource || 'web',
+        context: options.context,
+        stream: options.stream
+      });
+
+      this.activeOrchestrations.delete(orchestrationId);
+      this.emit(userId, 'orchestration:complete', {
+        orchestrationId,
+        result: result.content,
+        totalTokens: result.totalTokens,
+        iterations: result.iterations
+      });
+
+      return result;
+    } catch (err) {
+      this.activeOrchestrations.delete(orchestrationId);
+      this.emit(userId, 'orchestration:error', { orchestrationId, error: err.message });
+      throw err;
+    }
+  }
+
+  async runParallel(userId, tasks, options = {}) {
+    const groupId = uuidv4();
+    const app = options.app;
+    const results = [];
+
+    this.emit(userId, 'parallel:start', { groupId, taskCount: tasks.length });
+
+    const promises = tasks.map(async (task, index) => {
+      try {
+        const result = await this.engine.run(userId, task, {
+          app,
+          triggerType: options.triggerType || 'user',
+          triggerSource: options.triggerSource || 'parallel',
+          context: options.context
+        });
+        return { index, status: 'completed', result };
+      } catch (err) {
+        return { index, status: 'failed', error: err.message };
+      }
+    });
+
+    const settled = await Promise.allSettled(promises);
+    for (const item of settled) {
+      if (item.status === 'fulfilled') {
+        results.push(item.value);
+      } else {
+        results.push({ status: 'failed', error: item.reason?.message });
+      }
+    }
+
+    this.emit(userId, 'parallel:complete', { groupId, results });
+    return results;
+  }
+
+  stop(orchestrationId) {
+    const orch = this.activeOrchestrations.get(orchestrationId);
+    if (orch) {
+      this.engine.stopRun(orchestrationId);
+      this.activeOrchestrations.delete(orchestrationId);
+    }
+  }
+
+  getActive() {
+    return Array.from(this.activeOrchestrations.entries()).map(([id, orch]) => ({
+      id,
+      userId: orch.userId,
+      task: orch.task,
+      status: orch.status,
+      currentStep: orch.currentStep
+    }));
+  }
+
+  emit(userId, event, data) {
+    if (this.io) {
+      this.io.to(`user:${userId}`).emit(event, data);
+    }
+  }
+}
+
+module.exports = { MultiStepOrchestrator };

package/server/services/ai/providers/anthropic.js

@@ -0,0 +1,181 @@
+const Anthropic = require('@anthropic-ai/sdk');
+const { BaseProvider } = require('./base');
+
+class AnthropicProvider extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'anthropic';
+    this.models = [
+      'claude-sonnet-4-20250514',
+      'claude-3-5-sonnet-20241022',
+      'claude-3-5-haiku-20241022',
+      'claude-3-opus-20240229'
+    ];
+    this.contextWindows = {
+      'claude-sonnet-4-20250514': 200000,
+      'claude-3-5-sonnet-20241022': 200000,
+      'claude-3-5-haiku-20241022': 200000,
+      'claude-3-opus-20240229': 200000
+    };
+    this.client = new Anthropic({
+      apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY
+    });
+  }
+
+  getContextWindow(model) {
+    return this.contextWindows[model] || 200000;
+  }
+
+  formatTools(tools) {
+    return tools.map(tool => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.parameters || { type: 'object', properties: {} }
+    }));
+  }
+
+  convertMessages(messages) {
+    let system = '';
+    const converted = [];
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        system += (system ? '\n\n' : '') + msg.content;
+        continue;
+      }
+
+      if (msg.role === 'tool') {
+        converted.push({
+          role: 'user',
+          content: [{
+            type: 'tool_result',
+            tool_use_id: msg.tool_call_id,
+            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+          }]
+        });
+        continue;
+      }
+
+      if (msg.role === 'assistant' && msg.tool_calls) {
+        const content = [];
+        if (msg.content) content.push({ type: 'text', text: msg.content });
+        for (const tc of msg.tool_calls) {
+          content.push({
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments || '{}')
+          });
+        }
+        converted.push({ role: 'assistant', content });
+        continue;
+      }
+
+      converted.push({
+        role: msg.role === 'assistant' ? 'assistant' : 'user',
+        content: msg.content
+      });
+    }
+
+    return { system, messages: converted };
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const { system, messages: converted } = this.convertMessages(messages);
+
+    const params = {
+      model,
+      max_tokens: options.maxTokens || 16384,
+      messages: converted
+    };
+
+    if (system) params.system = system;
+    if (tools.length > 0) params.tools = this.formatTools(tools);
+
+    const response = await this.client.messages.create(params);
+
+    let content = '';
+    const toolCalls = [];
+
+    for (const block of response.content) {
+      if (block.type === 'text') {
+        content += block.text;
+      } else if (block.type === 'tool_use') {
+        toolCalls.push({
+          id: block.id,
+          type: 'function',
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+
+    return {
+      content,
+      toolCalls,
+      finishReason: response.stop_reason === 'tool_use' ? 'tool_calls' : 'stop',
+      usage: {
+        promptTokens: response.usage.input_tokens,
+        completionTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+      },
+      model: response.model
+    };
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const { system, messages: converted } = this.convertMessages(messages);
+
+    const params = {
+      model,
+      max_tokens: options.maxTokens || 16384,
+      messages: converted,
+      stream: true
+    };
+
+    if (system) params.system = system;
+    if (tools.length > 0) params.tools = this.formatTools(tools);
+
+    const stream = await this.client.messages.stream(params);
+
+    let content = '';
+    let currentToolCalls = [];
+    let currentToolIndex = -1;
+
+    for await (const event of stream) {
+      if (event.type === 'content_block_start') {
+        if (event.content_block.type === 'tool_use') {
+          currentToolIndex++;
+          currentToolCalls.push({
+            id: event.content_block.id,
+            type: 'function',
+            function: { name: event.content_block.name, arguments: '' }
+          });
+        }
+      } else if (event.type === 'content_block_delta') {
+        if (event.delta.type === 'text_delta') {
+          content += event.delta.text;
+          yield { type: 'content', content: event.delta.text };
+        } else if (event.delta.type === 'input_json_delta') {
+          if (currentToolCalls[currentToolIndex]) {
+            currentToolCalls[currentToolIndex].function.arguments += event.delta.partial_json;
+          }
+        }
+      } else if (event.type === 'message_stop') {
+        yield {
+          type: 'done',
+          content,
+          toolCalls: currentToolCalls,
+          finishReason: currentToolCalls.length > 0 ? 'tool_calls' : 'stop',
+          usage: null
+        };
+      }
+    }
+  }
+}
+
+module.exports = { AnthropicProvider };

package/server/services/ai/providers/base.js

@@ -0,0 +1,40 @@
+class BaseProvider {
+  constructor(config = {}) {
+    this.config = config;
+    this.name = 'base';
+    this.models = [];
+  }
+
+  getDefaultModel() {
+    return this.models[0] || '';
+  }
+
+  formatTools(tools) {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters || { type: 'object', properties: {} }
+      }
+    }));
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    throw new Error('chat() not implemented');
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    throw new Error('stream() not implemented');
+  }
+
+  countTokensEstimate(text) {
+    return Math.ceil(text.length / 4);
+  }
+
+  getContextWindow(model) {
+    return 128000;
+  }
+}
+
+module.exports = { BaseProvider };

package/server/services/ai/providers/google.js

@@ -0,0 +1,187 @@
+const { GoogleGenerativeAI } = require('@google/generative-ai');
+const { BaseProvider } = require('./base');
+
+class GoogleProvider extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'google';
+    this.models = [
+      'gemini-2.0-flash',
+      'gemini-2.0-pro',
+      'gemini-1.5-pro',
+      'gemini-1.5-flash',
+      'gemini-3.1-flash-lite-preview'
+    ];
+    this.contextWindows = {
+      'gemini-2.0-flash': 1048576,
+      'gemini-2.0-pro': 2097152,
+      'gemini-1.5-pro': 2097152,
+      'gemini-1.5-flash': 1048576,
+      'gemini-3.1-flash-lite-preview': 1048576
+    };
+    this.genAI = new GoogleGenerativeAI(config.apiKey || process.env.GOOGLE_AI_KEY);
+  }
+
+  getContextWindow(model) {
+    return this.contextWindows[model] || 1048576;
+  }
+
+  formatTools(tools) {
+    return [{
+      functionDeclarations: tools.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters || { type: 'object', properties: {} }
+      }))
+    }];
+  }
+
+  convertMessages(messages) {
+    let systemInstruction = '';
+    const history = [];
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        systemInstruction += (systemInstruction ? '\n\n' : '') + msg.content;
+        continue;
+      }
+      if (msg.role === 'tool') {
+        history.push({
+          role: 'function',
+          parts: [{
+            functionResponse: {
+              name: msg.name || 'tool',
+              response: { result: msg.content }
+            }
+          }]
+        });
+        continue;
+      }
+      if (msg.role === 'assistant' && msg.tool_calls) {
+        const parts = [];
+        if (msg.content) parts.push({ text: msg.content });
+        for (const tc of msg.tool_calls) {
+          const functionCallPart = {
+            functionCall: {
+              name: tc.function.name,
+              args: JSON.parse(tc.function.arguments || '{}')
+            }
+          };
+          if (tc.function.thought_signature) {
+            functionCallPart.thoughtSignature = tc.function.thought_signature;
+          }
+          parts.push(functionCallPart);
+        }
+        history.push({ role: 'model', parts });
+        continue;
+      }
+      history.push({
+        role: msg.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: msg.content || '' }]
+      });
+    }
+
+    return { systemInstruction, history };
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const { systemInstruction, history } = this.convertMessages(messages);
+
+    const genModel = this.genAI.getGenerativeModel({
+      model,
+      systemInstruction: systemInstruction || undefined,
+      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+    });
+
+    const lastMessage = history.pop();
+    const chat = genModel.startChat({ history });
+    const result = await chat.sendMessage(lastMessage.parts);
+    const response = result.response;
+
+    let content = '';
+    const toolCalls = [];
+
+    for (const candidate of response.candidates || []) {
+      for (const part of candidate.content?.parts || []) {
+        if (part.text) content += part.text;
+        if (part.functionCall) {
+          toolCalls.push({
+            id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            type: 'function',
+            function: {
+              name: part.functionCall.name,
+              arguments: JSON.stringify(part.functionCall.args || {}),
+              thought_signature: part.thoughtSignature
+            }
+          });
+        }
+      }
+    }
+
+    const usage = response.usageMetadata;
+    return {
+      content,
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+      usage: usage ? {
+        promptTokens: usage.promptTokenCount || 0,
+        completionTokens: usage.candidatesTokenCount || 0,
+        totalTokens: usage.totalTokenCount || 0
+      } : null,
+      model
+    };
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const { systemInstruction, history } = this.convertMessages(messages);
+
+    const genModel = this.genAI.getGenerativeModel({
+      model,
+      systemInstruction: systemInstruction || undefined,
+      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+    });
+
+    const lastMessage = history.pop();
+    const chat = genModel.startChat({ history });
+    const result = await chat.sendMessageStream(lastMessage.parts);
+
+    let content = '';
+    const toolCalls = [];
+
+    for await (const chunk of result.stream) {
+      const text = chunk.text();
+      if (text) {
+        content += text;
+        yield { type: 'content', content: text };
+      }
+
+      for (const candidate of chunk.candidates || []) {
+        for (const part of candidate.content?.parts || []) {
+          if (part.functionCall) {
+            toolCalls.push({
+              id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+              type: 'function',
+              function: {
+                name: part.functionCall.name,
+                arguments: JSON.stringify(part.functionCall.args || {}),
+                thought_signature: part.thoughtSignature
+              }
+            });
+          }
+        }
+      }
+    }
+
+    yield {
+      type: 'done',
+      content,
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+      usage: null
+    };
+  }
+}
+
+module.exports = { GoogleProvider };

package/server/services/ai/providers/grok.js

@@ -0,0 +1,121 @@
+const OpenAI = require('openai');
+const { BaseProvider } = require('./base');
+
+class GrokProvider extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'grok';
+    this.client = new OpenAI({
+      apiKey: config.apiKey || process.env.XAI_API_KEY,
+      baseURL: 'https://api.x.ai/v1'
+    });
+  }
+
+  getContextWindow(model) {
+    return 131072; // grok-4 context window
+  }
+
+  _buildParams(model, messages, tools, options) {
+    const params = {
+      model,
+      messages,
+      max_tokens: options.maxTokens || 16384
+    };
+
+    // grok-4-1-fast-reasoning is a reasoning model: no temperature
+    const isReasoning = model.includes('reasoning') || model.startsWith('grok-4');
+    if (!isReasoning) {
+      params.temperature = options.temperature ?? 0.9;
+    }
+
+    if (tools && tools.length > 0) {
+      params.tools = this.formatTools(tools);
+      params.tool_choice = 'auto';
+    }
+
+    return params;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || 'grok-4-1-fast-reasoning';
+    const params = this._buildParams(model, messages, tools, options);
+
+    const response = await this.client.chat.completions.create(params);
+    return this.normalizeResponse(response);
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || 'grok-4-1-fast-reasoning';
+    const params = { ...this._buildParams(model, messages, tools, options), stream: true };
+
+    const stream = await this.client.chat.completions.create(params);
+
+    let toolCalls = [];
+    let content = '';
+
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (!delta) continue;
+
+      if (delta.content) {
+        content += delta.content;
+        yield { type: 'content', content: delta.content };
+      }
+
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (!toolCalls[tc.index]) {
+            toolCalls[tc.index] = { id: tc.id || '', type: 'function', function: { name: tc.function?.name || '', arguments: '' } };
+          }
+          if (tc.id) toolCalls[tc.index].id = tc.id;
+          if (tc.function?.name) toolCalls[tc.index].function.name = tc.function.name;
+          if (tc.function?.arguments) toolCalls[tc.index].function.arguments += tc.function.arguments;
+        }
+      }
+
+      const finishReason = chunk.choices[0]?.finish_reason;
+      if (finishReason === 'tool_calls' || (finishReason === 'stop' && toolCalls.length > 0)) {
+        yield { type: 'tool_calls', toolCalls, content };
+        return;
+      }
+      if (finishReason === 'stop') {
+        yield { type: 'done', content };
+        return;
+      }
+    }
+
+    if (toolCalls.length > 0) {
+      yield { type: 'tool_calls', toolCalls, content };
+    } else {
+      yield { type: 'done', content };
+    }
+  }
+
+  normalizeResponse(response) {
+    const choice = response.choices[0];
+    const msg = choice.message;
+    return {
+      content: msg.content || '',
+      toolCalls: msg.tool_calls?.map(tc => ({
+        id: tc.id,
+        type: 'function',
+        function: { name: tc.function.name, arguments: tc.function.arguments }
+      })) || [],
+      finishReason: choice.finish_reason,
+      usage: response.usage
+    };
+  }
+
+  formatTools(tools) {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }));
+  }
+}
+
+module.exports = { GrokProvider };