goblin-agents 2.5.0 → 3.0.1

package/lib/llm/aiAgent.js

@@ -150,6 +150,11 @@ class AiAgentShape {
   role = string; //agent role
   prompt = string; //default system prompt
   contexts = record(string, string); //additionnal system prompt context
+  reasonings = record(
+    string,
+    enumeration(false, true, 'low', 'medium', 'high')
+  ); //contextuals reasonings levels
+  models = record(string, string); //contextuals models
   provider = enumeration('ollama', 'open-ai');
   model = string;
   otherModels = array(string);
@@ -161,7 +166,7 @@ class AiAgentShape {
   tools = option(array(object));
   toolServiceId = option(string);
   usability = enumeration('disabled', 'experimental', 'stable', 'deprecated');
-  reasoning = option(boolean);
+  reasoning = option(enumeration(false, true, 'low', 'medium', 'high'));
   vectorQuality = option(enumeration('f32', 'int8'));
   meta = MetaShape;
 }
@@ -201,6 +206,8 @@ class AiAgentLogic extends Elf.Archetype {
     otherModels: defaultValues.otherModels,
     messages: {},
     contexts: {},
+    reasonings: {},
+    models: {},
     options: defaultValues.options,
     host: defaultValues.host,
     headers: defaultValues.headers,
@@ -239,6 +246,12 @@ class AiAgentLogic extends Elf.Archetype {
     if (state.contexts[contextId]) {
       delete state.contexts[contextId];
     }
+    if (state.models[contextId]) {
+      delete state.models[contextId];
+    }
+    if (state.reasonings[contextId]) {
+      delete state.reasonings[contextId];
+    }
   }
 
   set(contextId, messages) {
@@ -246,9 +259,11 @@ class AiAgentLogic extends Elf.Archetype {
     state.messages[contextId] = messages;
   }
 
-  setContext(contextId, context) {
+  setContext(contextId, context, model, reasoning) {
     const {state} = this;
     state.contexts[contextId] = context;
+    state.models[contextId] = model || this.state.model;
+    state.reasonings[contextId] = reasoning || this.state.reasoning;
   }
 
   chat(contextId, role, content) {
@@ -579,8 +594,15 @@ class AiAgent extends Elf {
     this.logic.set(contextId, messages);
   }
 
-  async setContext(contextId, context) {
-    this.logic.setContext(contextId, context);
+  /**
+   * Set chat session context, model and level of reasoning
+   * @param {*} contextId
+   * @param {string} context
+   * @param {string} model
+   * @param {string} reasoning
+   */
+  async setContext(contextId, context, model, reasoning) {
+    this.logic.setContext(contextId, context, model, reasoning);
   }
 
   async chat(contextId, question, userDesktopId) {
@@ -591,7 +613,9 @@ class AiAgent extends Elf {
 
     await this._loadProvider();
     const contextMessages = this.state.messages[contextId] || [];
-    const context = this.state.contexts[contextId];
+    const context = this.state.contexts[contextId] || null;
+    const reasoning = this.state.reasonings[contextId] || this.state.reasoning;
+    const model = this.state.models[contextId] || this.state.model;
 
     let systemPrompt = this.state.prompt || '';
     if (context) {
@@ -623,12 +647,12 @@ ${context}
     this.log.dbg(`🐈 Chat session started : ${contextId}`);
 
     const chatCompletionRequest = {
-      model: this.state.model,
+      model,
+      reasoning,
       messages,
       options,
       format: this.state.format?.toJS(),
       tools: this.state.tools?.toJS(),
-      reasoning: this.state.reasoning,
     };
 
     const result = await this._provider.chat(chatCompletionRequest);
@@ -716,47 +740,6 @@ ${context}
     this.logic.addToolMessage(contextId, toolId, toolName, answer);
   }
 
-  async ask(contextId, question, questionId) {
-    if (this.state.provider !== 'ollama') {
-      throw new Error('Streaming API not impl.');
-    }
-
-    await this._mutex.lock(this.id);
-    this.quest.defer(() => this._mutex.unlock(this.id));
-
-    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) {
-      const pState = this.state._state.toJS();
-      options = pState?.options;
-    }
-    const response = await this._provider.chat({
-      model: this.state.model,
-      messages,
-      reasoning: this.state.reasoning,
-      options,
-      stream: true,
-    });
-
-    let agentResponse = '';
-    for await (const part of response) {
-      agentResponse += part.message.content;
-      this.quest.evt(`<${questionId}>`, {part: part.message.content});
-    }
-
-    //keep agent response
-    this.logic.ask(contextId, question, agentResponse);
-  }
-
   async resumeExchange(resumePrompt, contextId) {
     await this._mutex.lock(this.id);
     this.quest.defer(() => this._mutex.unlock(this.id));
@@ -778,7 +761,7 @@ ${context}
       model: this.state.model,
       prompt,
       system: resumePrompt,
-      reasoning: this.state.reasoning,
+      reasoning: 'low',
       options,
       stream: false,
     });
@@ -814,7 +797,7 @@ ${context}
       model: this.state.model,
       prompt,
       system: CONVERSATION_TITLE_PROMPT,
-      reasoning: this.state.reasoning,
+      reasoning: 'low',
       options,
       stream: false,
     });
@@ -822,68 +805,6 @@ ${context}
     return cleanText(title).trim();
   }
 
-  async react(reactPrompt, contextId, question) {
-    await this._mutex.lock(this.id);
-    this.quest.defer(() => this._mutex.unlock(this.id));
-
-    await this._loadProvider();
-    const feedId = await this.newQuestFeed();
-    const contextMessages = this.state.messages[contextId] || [];
-    const messages = [
-      {role: 'system', content: reactPrompt},
-      ...Array.from(contextMessages).map((m) => m._state.toJS()), //history
-      {role: 'user', content: question},
-    ];
-    this.log.dbg('ReAct Question:', question);
-
-    let options;
-    if (this.state.options) {
-      options = this.state.options.toJS();
-    }
-
-    const answer = await this._provider.chat({
-      model: this.state.model,
-      messages,
-      options,
-      reasoning: this.state.reasoning,
-      format: {
-        type: 'object',
-        properties: {
-          observation: {type: 'string'},
-          thought: {type: 'string'},
-          action: {type: 'string'},
-          agentId: {type: 'string'},
-          result: {type: 'string'},
-        },
-        required: ['observation', 'thought', 'action', 'agentId', 'result'],
-      },
-    });
-    if (!answer.message.content) {
-      await this.addAssistantMessage(
-        contextId,
-        'Génération stoppée. Impossible de répondre.'
-      );
-      return;
-    }
-    const {agentId, action, result, observation} = answer.message.content;
-    this.log.dbg('ReAct Observation:', observation);
-    this.log.dbg('ReAct Action:', action);
-    // Ajoute l'observation
-    await this.addAssistantMessage(contextId, observation);
-    // Si un agent est nécessaire, appel de l'agent externe
-    if (agentId) {
-      const result = await this.callAgent(
-        contextId,
-        agentId,
-        `${observation} -> ${action}`,
-        feedId
-      );
-      return {agentId, action, result, observation};
-    }
-
-    return {agentId, action, result, observation};
-  }
-
   async callAgent(contextId, agentId, action, feedId) {
     this.log.dbg(`🥸 calling "${agentId}" with action: "${action}"`);
     const exist = await this.cryo.isPersisted(AiAgentLogic.db, agentId);

package/lib/llm/providers/opanAi.js

@@ -13,7 +13,6 @@ class OpenAIProvider extends LLMProvider {
   }
 
   async chat(chatRequest) {
-    delete chatRequest.reasoning; //not yet supported
     if (chatRequest.options) {
       chatRequest = {...chatRequest, ...chatRequest.options};
       delete chatRequest.options;
@@ -24,6 +23,12 @@ class OpenAIProvider extends LLMProvider {
     if (!chatRequest.format) {
       delete chatRequest.format;
     }
+    if (chatRequest.reasoning !== undefined) {
+      if (chatRequest.reasoning) {
+        chatRequest.reasoning_effort = chatRequest.reasoning;
+      }
+      delete chatRequest.reasoning;
+    }
     const useFormat = chatRequest?.format !== undefined;
     if (useFormat) {
       chatRequest.response_format = {
@@ -69,7 +74,16 @@ class OpenAIProvider extends LLMProvider {
   }
 
   async gen(genRequest) {
-    const {model, system, prompt, format, tools, options, stream} = genRequest;
+    const {
+      model,
+      system,
+      prompt,
+      format,
+      tools,
+      options,
+      stream,
+      reasoning,
+    } = genRequest;
     const chatRequest = {
       model,
       messages: [
@@ -80,6 +94,7 @@ class OpenAIProvider extends LLMProvider {
       format,
       tools,
       stream,
+      reasoning,
     };
     const chat = await this.chat(chatRequest);
     return chat.message.content;

package/package.json

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