goblin-agents 1.0.4 → 2.1.0

package/config.js

@@ -7,28 +7,4 @@ module.exports = [
     message: 'Agents version',
     default: 2,
   },
-  {
-    type: 'input',
-    name: 'defaultProfile',
-    message: 'Agents default profile',
-    default: null,
-  },
-  {
-    type: 'input',
-    name: 'defaultSettings',
-    message: 'Agents default setting',
-    default: null,
-  },
-  {
-    type: 'input',
-    name: 'profiles',
-    message: 'Agents profiles for overriding settings',
-    default: {},
-  },
-  {
-    type: 'input',
-    name: 'settings',
-    message: 'Settings by name',
-    default: {},
-  },
 ];

package/lib/llm/aiAgent.js

@@ -13,7 +13,7 @@ const {
 } = require('xcraft-core-stones');
 const {getMutex} = require('xcraft-core-utils/lib/locks.js');
 const LLMProvider = require('./providers.js');
-const {OCR_SYSTEM_PROMPT, getPDFImages} = require('./utils.js');
+const {OCR_SYSTEM_PROMPT, getPDFImages, splitThinkTags} = require('./utils.js');
 
 class MessageShape {
   role = enumeration('assistant', 'user', 'tool');
@@ -98,6 +98,37 @@ function vectorToSqlLiteral(vec) {
   return hex;
 }
 
+/**
+ * Convertit un vecteur float32 normalisé [-1,1]
+ * en int8 [-128,127] et retourne une chaîne hex
+ * pour stockage en SQL.
+ *
+ * @param {Array|Float32Array} vec - vecteur normalisé
+ * @returns {string} - représentation hex
+ */
+function vectorToSqlLiteralInt8(vec) {
+  const dimensions = vec.length;
+  const qvec = new Int8Array(dimensions);
+
+  // Quantization uniforme
+  const step = 2.0 / 255.0;
+  for (let i = 0; i < dimensions; i++) {
+    qvec[i] = Math.round((vec[i] + 1.0) / step - 128);
+  }
+
+  // Vue mémoire en octets non signés
+  const view = new Uint8Array(qvec.buffer, qvec.byteOffset, qvec.byteLength);
+
+  // Conversion en hex
+  let hex = '';
+  for (let i = 0; i < view.length; i++) {
+    const byte = view[i];
+    hex += byte < 16 ? '0' + byte.toString(16) : byte.toString(16);
+  }
+
+  return hex;
+}
+
 class AiAgentShape {
   id = id('aiAgent');
   version = number;
@@ -114,6 +145,8 @@ class AiAgentShape {
   tools = option(array(object));
   toolServiceId = option(string);
   usability = enumeration('disabled', 'experimental', 'stable', 'deprecated');
+  reasoning = option(boolean);
+  vectorQuality = option(enumeration('f32', 'int8'));
   meta = MetaShape;
 }
 
@@ -123,15 +156,17 @@ class AiAgentState extends Elf.Sculpt(AiAgentShape) {}
 const defaultValues = {
   name: 'agent',
   role: 'assistant',
-  prompt: '',
-  provider: 'ollama',
-  model: 'mistral-small',
+  provider: 'open-ai',
+  model: '',
   options: {},
   host: 'http://127.0.0.1:11434',
   headers: {},
   format: null,
+  toolServiceId: null,
   tools: null,
+  reasoning: false,
   usability: 'disabled',
+  vectorQuality: 'f32',
 };
 
 class AiAgentLogic extends Elf.Archetype {
@@ -149,8 +184,10 @@ class AiAgentLogic extends Elf.Archetype {
     host: defaultValues.host,
     headers: defaultValues.headers,
     format: defaultValues.format,
+    toolServiceId: defaultValues.toolServiceId,
     tools: defaultValues.tools,
     usability: defaultValues.usability,
+    vectorQuality: 'f32',
     meta: {
       status: 'published',
     },
@@ -240,6 +277,11 @@ class AiAgentLogic extends Elf.Archetype {
     state._state.set(path, newValue);
   }
 
+  publish() {
+    const {state} = this;
+    state.meta.status = 'published';
+  }
+
   trash() {
     const {state} = this;
     state.meta.status = 'trashed';
@@ -300,7 +342,7 @@ class AiAgent extends Elf {
     }
 
     const Instance = LLMProvider.get(this.state.provider);
-    this._provider = new Instance(this.state.host, this.state.headers);
+    this._provider = new Instance(this.state.host, this.state.headers.toJS());
     this._conf = {provider, host, headersStr};
   }
 
@@ -332,14 +374,20 @@ class AiAgent extends Elf {
     if (this.state.options) {
       options = this.state.options.toJS();
     }
-    return await this._provider.gen({
+    const res = await this._provider.gen({
       model: this.state.model,
+      reasoning: this.state.reasoning,
       prompt,
       system: this.state.prompt,
       format: this.state.format?.toJS(),
       options,
       stream: false,
     });
+    const {thinks, cleanText} = splitThinkTags(res);
+    for (const think of thinks) {
+      this.log.dbg(`🧐 ${think}`);
+    }
+    return cleanText;
   }
 
   async reset(contextId, save = false) {
@@ -380,6 +428,7 @@ class AiAgent extends Elf {
       ];
       const result = await this._provider.chat({
         model: this.state.model,
+        reasoning: this.state.reasoning,
         messages,
       });
       descriptions.push(result.message.content);
@@ -396,7 +445,11 @@ class AiAgent extends Elf {
       model: this.state.model,
       input: rawText,
     });
-    return vectorToSqlLiteral(vectors);
+    let vectorToSql = vectorToSqlLiteral;
+    if (this.state.vectorQuality === 'int8') {
+      vectorToSql = vectorToSqlLiteralInt8;
+    }
+    return vectorToSql(vectors);
   }
 
   async embedInBatch(rawTexts = []) {
@@ -412,22 +465,24 @@ class AiAgent extends Elf {
       model: this.state.model,
       input: rawTexts,
     });
-    return res.map((v) => vectorToSqlLiteral(v));
+    let vectorToSql = vectorToSqlLiteral;
+    if (this.state.vectorQuality === 'int8') {
+      vectorToSql = vectorToSqlLiteralInt8;
+    }
+    return res.map((v) => vectorToSql(v));
   }
 
   async set(contextId, messages) {
     this.logic.set(contextId, messages);
   }
 
-  async chat(contextId, question, userDesktopId, sessionId = null) {
+  async chat(contextId, question, userDesktopId) {
     await this._loadProvider();
     const contextMessages = this.state.messages[contextId] || [];
     const messages = [
       {role: 'system', content: this.state.prompt},
       ...Array.from(contextMessages).map((m) => m._state.toJS()), //history
     ];
-    //add new question
-    messages.push({role: 'user', content: question});
 
     let options;
     if (this.state.options) {
@@ -435,67 +490,88 @@ class AiAgent extends Elf {
       options = pState?.options;
     }
 
-    if (!sessionId) {
+    if (question) {
       this.logic.chat(contextId, 'user', question);
-      sessionId = Elf.uuid();
-      this.log.dbg(`🐈 Chat session started : ${sessionId}`);
+      //add new question
+      messages.push({role: 'user', content: question});
     }
 
-    const result = await this._provider.chat({
+    this.log.dbg(`🐈 Chat session started : ${contextId}`);
+
+    const chatCompletionRequest = {
       model: this.state.model,
       messages,
       options,
       format: this.state.format?.toJS(),
       tools: this.state.tools?.toJS(),
-    });
+      reasoning: this.state.reasoning,
+    };
+
+    const result = await this._provider.chat(chatCompletionRequest);
 
     if (this.state.toolServiceId && this.state.tools) {
       const used = await this.callTools(
         contextId,
         result.message,
-        userDesktopId,
-        sessionId
+        userDesktopId
       );
       if (used) {
-        return await this.chat(contextId, question, userDesktopId, sessionId);
+        //leave for a second turn
+        this.log.dbg(`🐈 Chat session ended : ${contextId}`);
+        return true;
       }
     }
 
     //keep agent response
-    this.logic.chat(contextId, 'assistant', result.message.content);
+    const {thinks, cleanText} = splitThinkTags(result.message.content);
+    this.logic.chat(contextId, 'assistant', cleanText);
+    for (const think of thinks) {
+      this.log.dbg(`🧐 ${think}`);
+    }
+    this.log.dbg(`🐈 Chat session ended : ${contextId}`);
 
-    return result.message.content;
+    return cleanText;
   }
 
-  async callTools(contextId, message, userDesktopId, sessionId) {
-    const {tool_calls} = message;
+  async callTools(contextId, message, userDesktopId) {
+    const {tool_calls, content} = message;
     if (!tool_calls || !userDesktopId) {
       return false;
     }
-    this.logic.callTools(contextId, tool_calls);
+    this.logic.callTools(contextId, content, tool_calls);
     for (const tool of tool_calls) {
       const {
         id,
         function: {name},
       } = tool;
+
       let result = '';
+      let toolArguments = {};
+      if (
+        tool.function.arguments &&
+        typeof tool.function.arguments === 'string'
+      ) {
+        toolArguments = JSON.parse(tool.function.arguments);
+      } else if (
+        tool.function.arguments &&
+        typeof tool.function.arguments === 'object'
+      ) {
+        toolArguments = tool.function.arguments;
+      }
       try {
         const payload = {
           id: this.state.toolServiceId,
           desktopId: userDesktopId,
-          ...JSON.parse(tool.function.arguments),
+          contextId,
+          ...toolArguments,
         };
         const toolNamespace = this.state.toolServiceId?.split('@', 1)[0];
         const toolCmd = `${toolNamespace}.${name}`;
-        this.log.dbg(
-          `🔧 Tool call: ${toolCmd}(${JSON.stringify(
-            payload
-          )}) sid: ${sessionId}`
-        );
+        this.log.dbg(`🔧 Tool call: ${toolCmd}(${JSON.stringify(payload)})`);
         result = await this.quest.cmd(toolCmd, payload);
         await this.addToolMessage(contextId, id, name, result);
       } catch (err) {
-        this.log.dbg(`🔧 Tool error : ${err} sid: ${sessionId}`);
+        this.log.dbg(`🔧 Tool error : ${err}`);
       }
     }
     return true;
@@ -527,6 +603,7 @@ class AiAgent extends Elf {
     const response = await this._provider.chat({
       model: this.state.model,
       messages,
+      reasoning: this.state.reasoning,
       options,
       stream: true,
     });
@@ -559,6 +636,7 @@ class AiAgent extends Elf {
       model: this.state.model,
       prompt,
       system: resumePrompt,
+      reasoning: this.state.reasoning,
       options,
       stream: false,
     });
@@ -584,6 +662,7 @@ class AiAgent extends Elf {
       model: this.state.model,
       messages,
       options,
+      reasoning: this.state.reasoning,
       format: {
         type: 'object',
         properties: {
@@ -683,20 +762,34 @@ class AiAgent extends Elf {
     ];
   }
 
+  async getToolChatContextHistory(contextId) {
+    const contextMessages = this.state.messages[contextId] || [];
+    return [
+      ...Array.from(contextMessages)
+        .map((m) => m._state.toJS())
+        .filter((m) => {
+          if (m.role === 'tool' && !m.tool_calls) {
+            return m;
+          }
+        }),
+    ];
+  }
+
   async getBaseSettings() {
     const {provider, host, headers, model} = this.state.toJS();
     return {provider, host, headers, model};
   }
 
-  async getUsability() {
-    return this.state.usability;
-  }
-
   async trash() {
     this.logic.trash();
     await this.persist();
   }
 
+  async publish() {
+    this.logic.publish();
+    await this.persist();
+  }
+
   delete() {}
 }
 

package/lib/llm/providers.js

@@ -49,7 +49,15 @@ class OllamaProvider extends LLMProvider {
   }
 
   async chat(chatRequest) {
-    const {model, messages, options, format, tools, stream} = chatRequest;
+    const {
+      model,
+      messages,
+      options,
+      format,
+      tools,
+      stream,
+      reasoning,
+    } = chatRequest;
     const useFormat = !!format;
     const chat = await this.#ollama.chat({
       model,
@@ -58,6 +66,7 @@ class OllamaProvider extends LLMProvider {
       format,
       tools,
       stream,
+      think: reasoning,
     });
     if (useFormat) {
       chat.message.content = JSON.parse(chat.message.content);
@@ -68,7 +77,15 @@ class OllamaProvider extends LLMProvider {
   }
 
   async gen(genRequest) {
-    const {model, system, prompt, format, options, stream} = genRequest;
+    const {
+      model,
+      system,
+      prompt,
+      format,
+      options,
+      stream,
+      reasoning,
+    } = genRequest;
     const useFormat = !!format;
     const gen = await this.#ollama.generate({
       model,
@@ -77,6 +94,7 @@ class OllamaProvider extends LLMProvider {
       format,
       options,
       stream,
+      think: reasoning,
     });
     if (useFormat) {
       return JSON.parse(gen.response);
@@ -120,6 +138,7 @@ class OpenAIProvider extends LLMProvider {
   }
 
   async chat(chatRequest) {
+    delete chatRequest.reasoning; //not yet supported
     if (chatRequest.options) {
       chatRequest = {...chatRequest, ...chatRequest.options};
       delete chatRequest.options;
@@ -145,6 +164,7 @@ class OpenAIProvider extends LLMProvider {
           },
         },
       };
+
       delete chatRequest.format;
     }
     const query = `${this.#baseUrl}/chat/completions`;

package/lib/llm/utils.js

@@ -90,7 +90,7 @@ const splitLongText = (text, maxLength, baseId) => {
   return segments;
 };
 
-const html2chunks = async (html, chunkSize = 300, chunkOverlap = 0) => {
+const html2chunks = async (html, chunkSize = 300, chunkOverlap = 50) => {
   const textSplitter = RecursiveCharacterTextSplitter.fromLanguage('html', {
     chunkSize,
     chunkOverlap,
@@ -237,44 +237,38 @@ function groupSentences(text, maxSize) {
 }
 
 function buildPromptFromArticlesMulti(
-  initialQuestion,
-  questionsWithArticles,
-  maxTotalTokens
+  articles,
+  maxTotalTokens,
+  dbg = () => null
 ) {
-  let prompt = '[CONTEXT]\n\n';
-  let currentTokenCount = estimateTokenCount(prompt);
-
   const buffer = 16000; // Réserve de tokens pour l'instruction + réponse
-  const maxTokensPerQuestion = Math.floor(
-    (maxTotalTokens - buffer) / questionsWithArticles.length
-  );
-
-  for (const {articles} of questionsWithArticles) {
-    let section = '';
-    let sectionTokenCount = estimateTokenCount(section);
-    for (const article of articles) {
-      const {title, sourceId, description} = article;
-      const articleBlock = `\n# ${title} \n## Lien: ${sourceId}\n\n${description}\n`;
-      const tokensForArticle = estimateTokenCount(articleBlock);
-
-      if (sectionTokenCount + tokensForArticle > maxTokensPerQuestion) {
-        break;
-      }
-
-      section += articleBlock;
-      sectionTokenCount += tokensForArticle;
-    }
+  const maxTokens = Math.floor(maxTotalTokens - buffer);
+
+  let sections = [];
+  let sectionTokenCount = 0;
+  for (const article of articles) {
+    const {kind, title, sourceId, distance, combinedScore, chunk} = article;
+    const articleBlock = JSON.stringify({
+      kind,
+      title,
+      url: sourceId.startsWith('http') ? sourceId : null,
+      distance,
+      combinedScore,
+      chunk,
+    });
+    dbg(articleBlock);
+    const tokensForArticle = estimateTokenCount(articleBlock);
 
-    if (currentTokenCount + sectionTokenCount > maxTotalTokens - buffer) {
+    if (sectionTokenCount + tokensForArticle > maxTokens) {
+      dbg('MAX TOKEN REACHED');
       break;
     }
 
-    prompt += section;
-    currentTokenCount += sectionTokenCount;
+    sections.push(articleBlock);
+    sectionTokenCount += tokensForArticle;
   }
-  const questionContext = '[QUESTION]\n\n' + initialQuestion;
-  prompt += questionContext;
-  return prompt.trim();
+
+  return `[${sections.join(',')}]`;
 }
 
 /**
@@ -302,12 +296,17 @@ function chunkArray(array, size) {
  * @returns {Promise<object>} A map of embeddings structured as:
  *    { [contentId]: { [key]: { chunk, embedding } } }
  */
-async function embedChunksInBatch(agent, allChunks, batchSize = 50) {
+async function embedChunksInBatch(
+  agent,
+  allChunks,
+  batchSize = 50,
+  prefix = 'passage: '
+) {
   const embeddingsByContent = {};
 
   for (let start = 0; start < allChunks.length; start += batchSize) {
     const currentBatch = allChunks.slice(start, start + batchSize);
-    const inputTexts = currentBatch.map(({chunk}) => chunk);
+    const inputTexts = currentBatch.map(({chunk}) => `${prefix}${chunk}`);
     const embeddedVectors = await agent.embedInBatch(inputTexts);
 
     for (let i = 0; i < embeddedVectors.length; i++) {
@@ -328,6 +327,26 @@ async function embedChunksInBatch(agent, allChunks, batchSize = 50) {
   return embeddingsByContent;
 }
 
+function splitThinkTags(input) {
+  const thinkRegex = /<think>([\s\S]*?)<\/think>/g;
+  let match;
+  const thinks = [];
+  let cleanText = input;
+
+  // Extraire toutes les sections <think>...</think>
+  while ((match = thinkRegex.exec(input)) !== null) {
+    thinks.push(match[1].trim());
+  }
+
+  // Supprimer les balises et leur contenu du texte
+  cleanText = cleanText.replace(thinkRegex, '').trim();
+
+  return {
+    thinks, // Tableau avec le contenu des balises <think>
+    cleanText, // Texte sans balises <think>
+  };
+}
+
 module.exports = {
   chunkArray,
   embedChunksInBatch,
@@ -342,4 +361,5 @@ module.exports = {
   sliceText,
   groupSentences,
   buildPromptFromArticlesMulti,
+  splitThinkTags,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goblin-agents",
-  "version": "1.0.4",
+  "version": "2.1.0",
   "description": "AI Agents framework",
   "author": "Epsitec SA",
   "contributors": [