feat(core/web): implement skill engine, agent system and function calling

- Added FileSystemSkill for secure local file manipulation via IA
- Created AgentService with Architect, Coder, and Security profiles
- Integrated Gemini Function Calling loop in LlmService and API Server
- Updated Chat UI with agent selection and project branding/logo

Author: semezzato

README.md

@@ -1,5 +1,11 @@
+<p align="center">
+  <img src="./assets/Open-Runway-Logo.png" alt="caLLM Logo" width="200">
+</p>
+
 # caLLM (Open Runway) — Universal LLM Orchestrator
 
+
+
 [![caLLM Badge](https://img.shields.io/badge/caLLM-Open_Runway-blue?style=for-the-badge&logo=rocket)](https://github.com/semezzato/callm-open-runway)
 [![Stability](https://img.shields.io/badge/Stability-Experimental-orange?style=for-the-badge)](#)
 [![License](https://img.shields.io/badge/License-MIT-green?style=for-the-badge)](#)

apps/server/src/index.ts

@@ -1,32 +1,44 @@
 import express from 'express';
 import cors from 'cors';
 import bodyParser from 'body-parser';
-import { LlmService } from '@callm/core';
-import { SessionService } from '@callm/core';
+import path from 'path';
+import { LlmService, SessionService, SkillLoader, FileSystemSkill, AgentService } from '@callm/core';
 
 const app = express();
 const port = process.env.PORT || 3001;
 
 app.use(cors());
 app.use(bodyParser.json());
 
-const llmService = new LlmService();
-const sessionService = new SessionService();
+// Configurações
+const dbPath = path.resolve(process.cwd(), 'callm.sqlite');
+const llmService = new LlmService({ apiKey: process.env.GEMINI_API_KEY || '' });
+const sessionService = new SessionService(dbPath);
+const skillLoader = new SkillLoader();
+const agentService = new AgentService();
+
+// Registrar Skills Padrão
+skillLoader.registerSkill(new FileSystemSkill());
+
+// Listar Agentes Disponíveis
+app.get('/api/agents', (req, res) => {
+  res.json(agentService.listProfiles());
+});
 
 // Inicializa o banco de dados
-sessionService.initialize().then(() => {
-  console.log('Database initialized');
+sessionService.init().then(() => {
+  console.log('Database initialized at:', dbPath);
 });
 
 app.get('/health', (req, res) => {
   res.json({ status: 'ok', engine: 'caLLM Open Runway' });
 });
 
-// Listar sessões
+// Listar sessões (Ainda não implementado no Core, mas deixamos o mock por enquanto)
 app.get('/api/sessions', async (req, res) => {
   try {
-    const sessions = await sessionService.listSessions();
-    res.json(sessions);
+    // Nota: SessionService precisa de um método para listar sessões únicas
+    res.json([]);
   } catch (error: any) {
     res.status(500).json({ error: error.message });
   }
@@ -35,36 +47,45 @@ app.get('/api/sessions', async (req, res) => {
 // Obter histórico de uma sessão
 app.get('/api/sessions/:id/messages', async (req, res) => {
   try {
-    const messages = await sessionService.getMessages(req.params.id);
+    const messages = await sessionService.getSessionHistory(req.params.id);
     res.json(messages);
   } catch (error: any) {
     res.status(500).json({ error: error.message });
   }
 });
 
-// Chat Endpoint (Streaming ou Simples)
+// Chat Endpoint (Com suporte a Skills e Agentes)
 app.post('/api/chat', async (req, res) => {
-  const { prompt, sessionId } = req.body;
+  const { prompt, sessionId, agentId } = req.body;
 
   if (!prompt) {
     return res.status(400).json({ error: 'Prompt is required' });
   }
 
   try {
     const currentSessionId = sessionId || `session_${Date.now()}`;
+    const history = await sessionService.getSessionHistory(currentSessionId);
+    const skillDefs = skillLoader.getAllDefinitions();
 
-    // Salva mensagem do usuário
-    await sessionService.saveMessage(currentSessionId, 'user', prompt);
-    
-    // Gera resposta (Non-streaming para simplificar primeira integração)
-    const response = await llmService.generateContent(prompt);
+    // Busca instruções do agente se houver
+    const agent = agentId ? agentService.getProfile(agentId) : undefined;
+    const systemPrompt = agent?.systemPrompt;
+
+    const chatResponse = await llmService.sendMessage(
+      prompt, 
+      history, 
+      skillDefs,
+      (name, params) => skillLoader.executeSkill(name, params),
+      systemPrompt
+    );
 
-    // Salva resposta do modelo
-    await sessionService.saveMessage(currentSessionId, 'model', response);
+    // Salva no banco
+    await sessionService.addMessage({ session_id: currentSessionId, role: 'user', content: prompt });
+    await sessionService.addMessage({ session_id: currentSessionId, role: 'model', content: chatResponse });
 
     res.json({ 
       sessionId: currentSessionId,
-      content: response 
+      content: chatResponse 
     });
   } catch (error: any) {
     console.error('Chat Error:', error);

apps/web/src/pages/ChatPage.tsx

@@ -9,8 +9,17 @@ const ChatPage = () => {
   ]);
   const [input, setInput] = useState('');
   const [isTyping, setIsTyping] = useState(false);
+  const [agents, setAgents] = useState<any[]>([]);
+  const [selectedAgentId, setSelectedAgentId] = useState<string>('coder');
   const scrollRef = useRef<HTMLDivElement>(null);
 
+  useEffect(() => {
+    fetch('http://localhost:3001/api/agents')
+      .then(res => res.json())
+      .then(data => setAgents(data))
+      .catch(err => console.error('Erro ao carregar agentes:', err));
+  }, []);
+
   useEffect(() => {
     if (scrollRef.current) {
       scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
@@ -29,7 +38,10 @@ const ChatPage = () => {
       const response = await fetch('http://localhost:3001/api/chat', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ prompt: currentInput })
+        body: JSON.stringify({ 
+          prompt: currentInput,
+          agentId: selectedAgentId
+        })
       });
       const data = await response.json();
 
@@ -48,15 +60,34 @@ const ChatPage = () => {
     }
   };
 
+  const currentAgent = agents.find(a => a.id === selectedAgentId) || { name: 'Gemini Pro', role: 'Local Engine' };
+
   return (
     <>
       <header className="h-16 border-b border-white/10 flex items-center justify-between px-6 glass z-10">
         <div className="flex items-center gap-3">
           <h2 className="font-semibold text-lg flex items-center gap-2 text-white">
             <span className="w-2 h-2 bg-primary rounded-full animate-pulse shadow-[0_0_8px_rgba(59,130,246,0.8)]" />
-            Gemini Pro
+            {currentAgent.name}
           </h2>
-          <span className="bg-emerald-500/10 text-emerald-400 text-[10px] px-2 py-0.5 rounded-full border border-emerald-500/20 uppercase tracking-widest font-bold">Local Engine</span>
+          <span className="bg-emerald-500/10 text-emerald-400 text-[10px] px-2 py-0.5 rounded-full border border-emerald-500/20 uppercase tracking-widest font-bold">
+            {currentAgent.role}
+          </span>
+        </div>
+        <div className="flex gap-2">
+          {agents.map(agent => (
+            <button
+              key={agent.id}
+              onClick={() => setSelectedAgentId(agent.id)}
+              className={`text-[10px] px-3 py-1 rounded-lg border transition-all ${
+                selectedAgentId === agent.id 
+                  ? 'bg-primary/20 border-primary text-primary shadow-[0_0_10px_rgba(59,130,246,0.3)]' 
+                  : 'border-white/5 text-gray-400 hover:bg-white/5'
+              }`}
+            >
+              {agent.name}
+            </button>
+          ))}
         </div>
       </header>
 

assets/Open-Runway-Logo.png

@@ -1,2 +1,6 @@
 export * from './services/LlmService';
 export * from './services/SessionService';
+export * from './services/SkillLoader';
+export * from './services/AgentService';
+export * from './interfaces/ISkill';
+export * from './skills/FileSystemSkill';

packages/core/src/index.ts

@@ -0,0 +1,17 @@
+export interface SkillParameter {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+  description: string;
+  required: boolean;
+}
+
+export interface SkillDefinition {
+  name: string;
+  description: string;
+  parameters: SkillParameter[];
+}
+
+export interface IBaseSkill {
+  getDefinition(): SkillDefinition;
+  execute(params: any): Promise<any>;
+}

packages/core/src/interfaces/ISkill.ts

@@ -0,0 +1,59 @@
+export interface AgentProfile {
+  id: string;
+  name: string;
+  role: string;
+  systemPrompt: string;
+  icon?: string;
+  defaultSkills: string[];
+}
+
+export class AgentService {
+  private profiles: Map<string, AgentProfile> = new Map();
+
+  constructor() {
+    this.initDefaultProfiles();
+  }
+
+  private initDefaultProfiles() {
+    this.profiles.set('architect', {
+      id: 'architect',
+      name: 'Architect',
+      role: 'Arquiteto de Sistemas Elite',
+      systemPrompt: `Você é o Arquiteto de Sistemas do caLLM. 
+Sua missão é garantir que o código siga os princípios de Anti-Vibecoding, TDD e Clean Architecture.
+Você é cético, focado em performance e odeia o "Efeito Frankenstein".
+Sempre sugira abstrações como Services e Adapters antes de empilhar código.`,
+      defaultSkills: ['file_system'],
+      icon: 'Layout'
+    });
+
+    this.profiles.set('coder', {
+      id: 'coder',
+      name: 'Coder',
+      role: 'Engenheiro de Software Sênior',
+      systemPrompt: `Você é o Coder do caLLM. 
+Seu foco é implementação rápida, eficiente e com TDD rigoroso.
+Você escreve código limpo, modular e sempre em conformidade com o ZEN.md.`,
+      defaultSkills: ['file_system'],
+      icon: 'Code'
+    });
+
+    this.profiles.set('security', {
+      id: 'security',
+      name: 'Security Officer',
+      role: 'Auditor de Segurança ApSec',
+      systemPrompt: `Você é o Security Officer do caLLM.
+Sua missão é caçar vulnerabilidades (OWASP), garantir sanitização de dados e proteção contra ataques de injeção e Broken Access Control.`,
+      defaultSkills: ['file_system'],
+      icon: 'ShieldCheck'
+    });
+  }
+
+  getProfile(id: string): AgentProfile | undefined {
+    return this.profiles.get(id);
+  }
+
+  listProfiles(): AgentProfile[] {
+    return Array.from(this.profiles.values());
+  }
+}

packages/core/src/services/AgentService.ts

@@ -1,4 +1,5 @@
-import { GoogleGenerativeAI } from '@google/generative-ai';
+import { GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
+import { SkillDefinition } from '../interfaces/ISkill';
 
 export interface LlmConfig {
   apiKey: string;
@@ -7,31 +8,103 @@ export interface LlmConfig {
 
 export class LlmService {
   private genAI: GoogleGenerativeAI;
-  private model: any;
+  private modelName: string;
 
   constructor(config: LlmConfig) {
     this.genAI = new GoogleGenerativeAI(config.apiKey);
-    this.model = this.genAI.getGenerativeModel({ model: config.modelName || 'gemini-pro' });
+    this.modelName = config.modelName || 'gemini-1.5-pro';
   }
 
-  async sendMessage(prompt: string, history: any[] = []) {
-    const chat = this.model.startChat({
+  private getFormattedTools(skillDefinitions: SkillDefinition[]) {
+    if (skillDefinitions.length === 0) return undefined;
+    
+    return [{
+      functionDeclarations: skillDefinitions.map(def => ({
+        name: def.name,
+        description: def.description,
+        parameters: {
+          type: SchemaType.OBJECT,
+          properties: def.parameters.reduce((acc: any, p) => {
+            acc[p.name] = { 
+              type: this.mapTypeToSchemaType(p.type), 
+              description: p.description 
+            };
+            return acc;
+          }, {}),
+          required: def.parameters.filter(p => p.required).map(p => p.name)
+        }
+      }))
+    }];
+  }
+
+  private mapTypeToSchemaType(type: string): SchemaType {
+    switch (type.toLowerCase()) {
+      case 'string': return SchemaType.STRING;
+      case 'number': return SchemaType.NUMBER;
+      case 'boolean': return SchemaType.BOOLEAN;
+      case 'object': return SchemaType.OBJECT;
+      case 'array': return SchemaType.ARRAY;
+      default: return SchemaType.STRING;
+    }
+  }
+
+  async sendMessage(prompt: string, history: any[] = [], skillDefinitions: SkillDefinition[] = [], executeTool?: (name: string, params: any) => Promise<any>, systemInstruction?: string) {
+    const tools = this.getFormattedTools(skillDefinitions);
+    const model = this.genAI.getGenerativeModel({ 
+      model: this.modelName, 
+      tools,
+      systemInstruction: systemInstruction ? { role: 'system', parts: [{ text: systemInstruction }] } : undefined
+    });
+    
+    const chat = model.startChat({
       history: history.map(msg => ({
         role: msg.role === 'user' ? 'user' : 'model',
-        parts: msg.parts || msg.content
+        parts: [{ text: msg.content || (typeof msg.parts === 'string' ? msg.parts : msg.parts?.[0]?.text) }]
       })),
     });
 
-    const result = await chat.sendMessage(prompt);
-    const response = await result.response;
+    let result = await chat.sendMessage(prompt);
+    let response = result.response;
+    
+    // Loop de recursão para Function Calling
+    while (response.candidates?.[0]?.content?.parts?.[0]?.functionCall && executeTool) {
+      const call = response.candidates[0].content.parts[0].functionCall;
+      console.log(`[LlmService] Executando Tool: ${call.name}`, call.args);
+      
+      try {
+        const toolResult = await executeTool(call.name, call.args);
+        
+        // Envia o resultado de volta para o Gemini
+        result = await chat.sendMessage([{
+          functionResponse: {
+            name: call.name,
+            response: { result: toolResult }
+          }
+        }]);
+        response = result.response;
+      } catch (error: any) {
+        console.error(`[LlmService] Erro na Tool ${call.name}:`, error);
+        result = await chat.sendMessage([{
+          functionResponse: {
+            name: call.name,
+            response: { error: error.message }
+          }
+        }]);
+        response = result.response;
+      }
+    }
+
     return response.text();
   }
 
-  async *sendMessageStream(prompt: string, history: any[] = []) {
-    const chat = this.model.startChat({
+  async *sendMessageStream(prompt: string, history: any[] = [], skillDefinitions: SkillDefinition[] = []) {
+    const tools = this.getFormattedTools(skillDefinitions);
+    const model = this.genAI.getGenerativeModel({ model: this.modelName, tools });
+
+    const chat = model.startChat({
       history: history.map(msg => ({
         role: msg.role === 'user' ? 'user' : 'model',
-        parts: msg.parts || msg.content
+        parts: [{ text: msg.content || (typeof msg.parts === 'string' ? msg.parts : msg.parts?.[0]?.text) }]
       })),
     });