totem-llm 0.1.0

package/server/utils/agents/aibitat/providers/cohere.js

@@ -0,0 +1,269 @@
+const { CohereClientV2 } = require("cohere-ai");
+const Provider = require("./ai-provider");
+const InheritMultiple = require("./helpers/classes");
+const UnTooled = require("./helpers/untooled");
+const { v4 } = require("uuid");
+const { safeJsonParse } = require("../../../http");
+
+/**
+ * The agent provider for the Cohere AI provider.
+ * Uses the v2 API which supports OpenAI-compatible message format and vision.
+ */
+class CohereProvider extends InheritMultiple([Provider, UnTooled]) {
+  model;
+
+  constructor(config = {}) {
+    const { model = process.env.COHERE_MODEL_PREF || "command-r-08-2024" } =
+      config;
+    super();
+    const client = new CohereClientV2({
+      token: process.env.COHERE_API_KEY,
+    });
+    this._client = client;
+    this.model = model;
+    this.verbose = true;
+  }
+
+  get client() {
+    return this._client;
+  }
+
+  get supportsAgentStreaming() {
+    return true;
+  }
+
+  /**
+   * Whether this provider supports native OpenAI-compatible tool calling.
+   * Override in subclass and return true to use native tool calling instead of UnTooled.
+   * @returns {boolean|Promise<boolean>}
+   */
+  supportsNativeToolCalling() {
+    return false;
+  }
+
+  /**
+   * Format a message with attachments for Cohere's v2 API.
+   * Cohere SDK uses camelCase (imageUrl) instead of snake_case (image_url).
+   * @param {Object} message - Message with potential attachments
+   * @returns {Object} Formatted message for Cohere SDK
+   */
+  formatMessageWithAttachments(message) {
+    if (!message.attachments || message.attachments.length === 0) {
+      return message;
+    }
+
+    const content = [{ type: "text", text: message.content }];
+    for (const attachment of message.attachments) {
+      content.push({
+        type: "image_url",
+        imageUrl: {
+          url: attachment.contentString,
+        },
+      });
+    }
+
+    const { attachments: _, ...rest } = message;
+    return {
+      ...rest,
+      content,
+    };
+  }
+
+  /**
+   * Stream a chat completion using the Cohere v2 API.
+   * The v2 API accepts OpenAI-compatible message format directly,
+   * including multimodal content arrays for vision support.
+   * @param {Object} options - Options containing messages array
+   * @returns {AsyncIterable} Stream of events from Cohere
+   */
+  async #handleFunctionCallStream({ messages = [] }) {
+    return await this.client.chatStream({
+      model: this.model,
+      messages: messages,
+    });
+  }
+
+  async streamingFunctionCall(
+    messages,
+    functions,
+    chatCb = null,
+    eventHandler = null
+  ) {
+    const history = [...messages].filter((msg) =>
+      ["user", "assistant"].includes(msg.role)
+    );
+    if (history[history.length - 1]?.role !== "user") return null;
+
+    const msgUUID = v4();
+    let textResponse = "";
+    const historyMessages = this.buildToolCallMessages(history, functions);
+    const stream = await chatCb({ messages: historyMessages });
+
+    eventHandler?.("reportStreamEvent", {
+      type: "statusResponse",
+      uuid: v4(),
+      content: "Agent is thinking...",
+    });
+
+    for await (const event of stream) {
+      if (event.type !== "content-delta") continue;
+      const text = event.delta?.message?.content?.text || "";
+      if (!text) continue;
+      textResponse += text;
+      eventHandler?.("reportStreamEvent", {
+        type: "statusResponse",
+        uuid: msgUUID,
+        content: text,
+      });
+    }
+
+    const call = safeJsonParse(textResponse, null);
+    if (call === null)
+      return { toolCall: null, text: textResponse, uuid: msgUUID };
+
+    const { valid, reason } = this.validFuncCall(call, functions);
+    if (!valid) {
+      this.providerLog(`Invalid function tool call: ${reason}.`);
+      eventHandler?.("reportStreamEvent", {
+        type: "removeStatusResponse",
+        uuid: msgUUID,
+        content:
+          "The model attempted to make an invalid function call - it was ignored.",
+      });
+      return { toolCall: null, text: null, uuid: msgUUID };
+    }
+
+    const { isDuplicate, reason: duplicateReason } =
+      this.deduplicator.isDuplicate(call.name, call.arguments);
+    if (isDuplicate) {
+      this.providerLog(
+        `Cannot call ${call.name} again because ${duplicateReason}.`
+      );
+      eventHandler?.("reportStreamEvent", {
+        type: "removeStatusResponse",
+        uuid: msgUUID,
+        content:
+          "The model tried to call a function with the same arguments as a previous call - it was ignored.",
+      });
+      return { toolCall: null, text: null, uuid: msgUUID };
+    }
+
+    eventHandler?.("reportStreamEvent", {
+      uuid: `${msgUUID}:tool_call_invocation`,
+      type: "toolCallInvocation",
+      content: `Parsed Tool Call: ${call.name}(${JSON.stringify(call.arguments)})`,
+    });
+    return { toolCall: call, text: null, uuid: msgUUID };
+  }
+
+  /**
+   * Stream a chat completion from the LLM with tool calling
+   * Override the inherited `stream` method since Cohere uses a different API format.
+   *
+   * @param {any[]} messages - The messages to send to the LLM.
+   * @param {any[]} functions - The functions to use in the LLM.
+   * @param {function} eventHandler - The event handler to use to report stream events.
+   * @returns {Promise<{ functionCall: any, textResponse: string }>} - The result of the chat completion.
+   */
+  async stream(messages, functions = [], eventHandler = null) {
+    this.providerLog(
+      "CohereProvider.stream - will process this chat completion."
+    );
+    // eslint-disable-next-line
+    try {
+      let completion = { content: "" };
+      if (functions.length > 0) {
+        const {
+          toolCall,
+          text,
+          uuid: msgUUID,
+        } = await this.streamingFunctionCall(
+          messages,
+          functions,
+          this.#handleFunctionCallStream.bind(this),
+          eventHandler
+        );
+
+        if (toolCall !== null) {
+          this.providerLog(`Valid tool call found - running ${toolCall.name}.`);
+          this.deduplicator.trackRun(toolCall.name, toolCall.arguments, {
+            cooldown: this.isMCPTool(toolCall, functions),
+          });
+          return {
+            result: null,
+            functionCall: {
+              name: toolCall.name,
+              arguments: toolCall.arguments,
+            },
+            cost: 0,
+          };
+        }
+
+        if (text) {
+          this.providerLog(
+            `No tool call found in the response - will send as a full text response.`
+          );
+          completion.content = text;
+          eventHandler?.("reportStreamEvent", {
+            type: "removeStatusResponse",
+            uuid: msgUUID,
+            content: "No tool call found in the response",
+          });
+          eventHandler?.("reportStreamEvent", {
+            type: "statusResponse",
+            uuid: v4(),
+            content: "Done thinking.",
+          });
+          eventHandler?.("reportStreamEvent", {
+            type: "fullTextResponse",
+            uuid: v4(),
+            content: text,
+          });
+        }
+      }
+
+      if (!completion?.content) {
+        eventHandler?.("reportStreamEvent", {
+          type: "statusResponse",
+          uuid: v4(),
+          content: "Done thinking.",
+        });
+
+        this.providerLog(
+          "Will assume chat completion without tool call inputs."
+        );
+        const msgUUID = v4();
+        completion = { content: "" };
+        const stream = await this.#handleFunctionCallStream({
+          messages: this.cleanMsgs(messages),
+        });
+
+        for await (const chunk of stream) {
+          if (chunk.type !== "content-delta") continue;
+          const text = chunk.delta?.message?.content?.text || "";
+          if (!text) continue;
+          completion.content += text;
+          eventHandler?.("reportStreamEvent", {
+            type: "textResponseChunk",
+            uuid: msgUUID,
+            content: text,
+          });
+        }
+      }
+
+      this.deduplicator.reset("runs");
+      return {
+        textResponse: completion.content,
+        cost: 0,
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  getCost(_usage) {
+    return 0;
+  }
+}
+
+module.exports = CohereProvider;

package/server/utils/agents/aibitat/providers/cometapi.js

@@ -0,0 +1,104 @@
+const OpenAI = require("openai");
+const Provider = require("./ai-provider.js");
+const InheritMultiple = require("./helpers/classes.js");
+const UnTooled = require("./helpers/untooled.js");
+
+/**
+ * The agent provider for the CometAPI provider.
+ */
+class CometApiProvider extends InheritMultiple([Provider, UnTooled]) {
+  model;
+
+  constructor(config = {}) {
+    const { model = "gpt-5-mini" } = config;
+    super();
+    const client = new OpenAI({
+      baseURL: "https://api.cometapi.com/v1",
+      apiKey: process.env.COMETAPI_LLM_API_KEY,
+      maxRetries: 3,
+      defaultHeaders: {
+        "HTTP-Referer": "https://anythingllm.com",
+        "X-CometAPI-Source": "anythingllm",
+      },
+    });
+
+    this._client = client;
+    this.model = model;
+    this.verbose = true;
+  }
+
+  get client() {
+    return this._client;
+  }
+
+  get supportsAgentStreaming() {
+    return false;
+  }
+
+  /**
+   * Whether this provider supports native OpenAI-compatible tool calling.
+   * Override in subclass and return true to use native tool calling instead of UnTooled.
+   * @returns {boolean|Promise<boolean>}
+   */
+  supportsNativeToolCalling() {
+    return false;
+  }
+
+  async #handleFunctionCallChat({ messages = [] }) {
+    return await this.client.chat.completions
+      .create({
+        model: this.model,
+        messages,
+      })
+      .then((result) => {
+        if (!result.hasOwnProperty("choices"))
+          throw new Error("CometAPI chat: No results!");
+        if (result.choices.length === 0)
+          throw new Error("CometAPI chat: No results length!");
+        return result.choices[0].message.content;
+      })
+      .catch((_) => {
+        return null;
+      });
+  }
+
+  async #handleFunctionCallStream({ messages = [] }) {
+    return await this.client.chat.completions.create({
+      model: this.model,
+      stream: true,
+      messages,
+    });
+  }
+
+  async stream(messages, functions = [], eventHandler = null) {
+    return await UnTooled.prototype.stream.call(
+      this,
+      messages,
+      functions,
+      this.#handleFunctionCallStream.bind(this),
+      eventHandler
+    );
+  }
+
+  async complete(messages, functions = []) {
+    return await UnTooled.prototype.complete.call(
+      this,
+      messages,
+      functions,
+      this.#handleFunctionCallChat.bind(this)
+    );
+  }
+
+  /**
+   * Get the cost of the completion.
+   *
+   * @param _usage The completion to get the cost for.
+   * @returns The cost of the completion.
+   * Stubbed since CometAPI has no cost basis.
+   */
+  getCost() {
+    return 0;
+  }
+}
+
+module.exports = CometApiProvider;

package/server/utils/agents/aibitat/providers/deepseek.js

@@ -0,0 +1,223 @@
+const OpenAI = require("openai");
+const Provider = require("./ai-provider.js");
+const InheritMultiple = require("./helpers/classes.js");
+const UnTooled = require("./helpers/untooled.js");
+const { tooledStream, tooledComplete } = require("./helpers/tooled.js");
+const { RetryError } = require("../error.js");
+const { toValidNumber } = require("../../../http/index.js");
+
+class DeepSeekProvider extends InheritMultiple([Provider, UnTooled]) {
+  model;
+
+  constructor(config = {}) {
+    super();
+    const { model = "deepseek-chat" } = config;
+    const client = new OpenAI({
+      baseURL: "https://api.deepseek.com/v1",
+      apiKey: process.env.DEEPSEEK_API_KEY ?? null,
+      maxRetries: 3,
+    });
+
+    this._client = client;
+    this.model = model;
+    this.verbose = true;
+    this.maxTokens = process.env.DEEPSEEK_MAX_TOKENS
+      ? toValidNumber(process.env.DEEPSEEK_MAX_TOKENS, 1024)
+      : 1024;
+  }
+
+  get client() {
+    return this._client;
+  }
+
+  get supportsAgentStreaming() {
+    return true;
+  }
+
+  /**
+   * All current DeepSeek models (deepseek-chat and deepseek-reasoner)
+   * support native OpenAI-compatible tool calling.
+   * @returns {boolean}
+   */
+  supportsNativeToolCalling() {
+    return true;
+  }
+
+  /**
+   * DeepSeek models do not support vision/image inputs.
+   * Strip attachments from messages to prevent API errors.
+   * @param {Object} message - Message with potential attachments
+   * @returns {Object} Message without attachments
+   */
+  formatMessageWithAttachments(message) {
+    const { attachments: _, ...rest } = message;
+    return rest;
+  }
+
+  /**
+   * Check if the model is a thinking model
+   * because we need to inject reasoning content into the messages
+   * or else the DeepSeek API will return an error for specific models.
+   * There is no official way to predetect if a model will require this
+   * so we have to hardcode the list of thinking models.
+   * @returns {boolean}
+   */
+  get #isThinkingModel() {
+    return [
+      "deepseek-reasoner",
+      "deepseek-v4-flash",
+      "deepseek-v4-pro",
+    ].includes(this.model);
+  }
+
+  get #tooledOptions() {
+    return {
+      provider: this,
+      ...(this.#isThinkingModel ? { injectReasoningContent: true } : {}),
+    };
+  }
+
+  async #handleFunctionCallChat({ messages = [] }) {
+    return await this.client.chat.completions
+      .create({
+        model: this.model,
+        messages,
+        max_tokens: this.maxTokens,
+      })
+      .then((result) => {
+        if (!result.hasOwnProperty("choices"))
+          throw new Error("DeepSeek chat: No results!");
+        if (result.choices.length === 0)
+          throw new Error("DeepSeek chat: No results length!");
+        return result.choices[0].message.content;
+      })
+      .catch((_) => {
+        return null;
+      });
+  }
+
+  async #handleFunctionCallStream({ messages = [] }) {
+    return await this.client.chat.completions.create({
+      model: this.model,
+      stream: true,
+      messages,
+    });
+  }
+
+  /**
+   * Strip attachments from all messages since DeepSeek doesn't support vision.
+   * @param {Array} messages - Array of messages
+   * @returns {Array} Messages with attachments removed
+   */
+  #stripAttachments(messages) {
+    let hasAttachments = false;
+    const stripped = messages.map((msg) => {
+      if (msg.attachments && msg.attachments.length > 0) {
+        hasAttachments = true;
+        const { attachments: _, ...rest } = msg;
+        return rest;
+      }
+      return msg;
+    });
+    if (hasAttachments) {
+      this.providerLog(
+        "DeepSeek does not support vision - stripped image attachments from messages."
+      );
+    }
+    return stripped;
+  }
+
+  async stream(messages, functions = [], eventHandler = null) {
+    const useNative = functions.length > 0 && this.supportsNativeToolCalling();
+    const cleanedMessages = this.#stripAttachments(messages);
+
+    if (!useNative) {
+      return await UnTooled.prototype.stream.call(
+        this,
+        cleanedMessages,
+        functions,
+        this.#handleFunctionCallStream.bind(this),
+        eventHandler
+      );
+    }
+
+    this.providerLog(
+      "Provider.stream (tooled) - will process this chat completion."
+    );
+
+    try {
+      return await tooledStream(
+        this.client,
+        this.model,
+        cleanedMessages,
+        functions,
+        eventHandler,
+        this.#tooledOptions
+      );
+    } catch (error) {
+      console.error(error.message, error);
+      if (error instanceof OpenAI.AuthenticationError) throw error;
+      if (
+        error instanceof OpenAI.RateLimitError ||
+        error instanceof OpenAI.InternalServerError ||
+        error instanceof OpenAI.APIError
+      ) {
+        throw new RetryError(error.message);
+      }
+      throw error;
+    }
+  }
+
+  async complete(messages, functions = []) {
+    const useNative = functions.length > 0 && this.supportsNativeToolCalling();
+    const cleanedMessages = this.#stripAttachments(messages);
+
+    if (!useNative) {
+      return await UnTooled.prototype.complete.call(
+        this,
+        cleanedMessages,
+        functions,
+        this.#handleFunctionCallChat.bind(this)
+      );
+    }
+
+    try {
+      const result = await tooledComplete(
+        this.client,
+        this.model,
+        cleanedMessages,
+        functions,
+        this.getCost.bind(this),
+        this.#tooledOptions
+      );
+
+      if (result.retryWithError) {
+        return this.complete([...messages, result.retryWithError], functions);
+      }
+
+      return result;
+    } catch (error) {
+      if (error instanceof OpenAI.AuthenticationError) throw error;
+      if (
+        error instanceof OpenAI.RateLimitError ||
+        error instanceof OpenAI.InternalServerError ||
+        error instanceof OpenAI.APIError
+      ) {
+        throw new RetryError(error.message);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get the cost of the completion.
+   *
+   * @param _usage The completion to get the cost for.
+   * @returns The cost of the completion.
+   */
+  getCost(_usage) {
+    return 0;
+  }
+}
+
+module.exports = DeepSeekProvider;

package/server/utils/agents/aibitat/providers/dellProAiStudio.js

@@ -0,0 +1,106 @@
+const OpenAI = require("openai");
+const Provider = require("./ai-provider.js");
+const InheritMultiple = require("./helpers/classes.js");
+const UnTooled = require("./helpers/untooled.js");
+const {
+  DellProAiStudioLLM,
+} = require("../../../AiProviders/dellProAiStudio/index.js");
+
+/**
+ * The agent provider for Dell Pro AI Studio.
+ */
+class DellProAiStudioProvider extends InheritMultiple([Provider, UnTooled]) {
+  model;
+
+  /**
+   *
+   * @param {{model?: string}} config
+   */
+  constructor(config = {}) {
+    super();
+    const model = config?.model || process.env.DPAIS_LLM_MODEL_PREF;
+    const client = new OpenAI({
+      baseURL: DellProAiStudioLLM.parseBasePath(), // Will use process.env.DPAIS_LLM_BASE_PATH if not provided
+      apiKey: null,
+    });
+
+    this._client = client;
+    this.model = model;
+    this.verbose = true;
+  }
+
+  get client() {
+    return this._client;
+  }
+
+  get supportsAgentStreaming() {
+    return true;
+  }
+
+  /**
+   * Whether this provider supports native OpenAI-compatible tool calling.
+   * Override in subclass and return true to use native tool calling instead of UnTooled.
+   * @returns {boolean|Promise<boolean>}
+   */
+  supportsNativeToolCalling() {
+    return false;
+  }
+
+  async #handleFunctionCallChat({ messages = [] }) {
+    return await this.client.chat.completions
+      .create({
+        model: this.model,
+        messages,
+      })
+      .then((result) => {
+        if (!result.hasOwnProperty("choices"))
+          throw new Error("DellProAiStudio chat: No results!");
+        if (result.choices.length === 0)
+          throw new Error("DellProAiStudio chat: No results length!");
+        return result.choices[0].message.content;
+      })
+      .catch((_) => {
+        return null;
+      });
+  }
+
+  async #handleFunctionCallStream({ messages = [] }) {
+    return await this.client.chat.completions.create({
+      model: this.model,
+      stream: true,
+      messages,
+    });
+  }
+
+  async stream(messages, functions = [], eventHandler = null) {
+    return await UnTooled.prototype.stream.call(
+      this,
+      messages,
+      functions,
+      this.#handleFunctionCallStream.bind(this),
+      eventHandler
+    );
+  }
+
+  async complete(messages, functions = []) {
+    return await UnTooled.prototype.complete.call(
+      this,
+      messages,
+      functions,
+      this.#handleFunctionCallChat.bind(this)
+    );
+  }
+
+  /**
+   * Get the cost of the completion.
+   *
+   * @param _usage The completion to get the cost for.
+   * @returns The cost of the completion.
+   * Stubbed since LMStudio has no cost basis.
+   */
+  getCost(_usage) {
+    return 0;
+  }
+}
+
+module.exports = DellProAiStudioProvider;