@cpwc/node-red-contrib-ai-intent 3.1.0-alpha

package/utilities/conversationHistory.js

@@ -0,0 +1,68 @@
+const {CONVERSATION_CONTEXT, ROLES} = require("../constants");
+
+class ConversationHistory {
+    constructor(nodeDB, conversationId) {
+        this.conversationId = conversationId;
+        this.nodeDB = nodeDB;
+        this.conversation = []
+
+        if(!nodeDB){
+            throw new Error("nodeDB does not exist");
+        }else if(conversationId){
+            const allConversations = nodeDB.getValueFromGlobalContext(CONVERSATION_CONTEXT) || {}
+            this.conversation = allConversations[conversationId] || []
+        }
+    }
+
+    addSystemMessage(content){
+        if(!content){
+            return false
+        }
+
+        const entry = {role: ROLES.System, content }
+
+        if(this.conversation[0]?.role === ROLES.System){
+            this.conversation[0] = entry
+        }else{
+            this.conversation = [entry, ...this.conversation]
+        }
+
+        this.saveHistory()
+    }
+
+    addUserMessage(content){
+        if(!content){
+            return false
+        }
+
+        const entry = {role: ROLES.User, content }
+        this.conversation.push(entry)
+        this.saveHistory()
+    }
+    addAssistantMessage(content){
+        if(!content){
+            return false
+        }
+
+        const entry = {role: ROLES.Assistant, content }
+        this.conversation.push(entry)
+        this.saveHistory()
+    }
+
+    clearHistory(){
+        this.conversation = []
+        this.saveHistory()
+    }
+
+     saveHistory(){
+        if(this.conversationId){
+            const allConversations = this.nodeDB.getValueFromGlobalContext(CONVERSATION_CONTEXT) || {}
+            allConversations[this.conversationId] = this.conversation
+            this.nodeDB.setValueToGlobalContext(allConversations, CONVERSATION_CONTEXT)
+        }
+     }
+}
+
+module.exports = {
+    ConversationHistory,
+};

package/utilities/format.js

@@ -0,0 +1,94 @@
+const Sugar = require("sugar");
+
+class Format {
+   createConsistentPayload(content){
+        return {
+            args: {
+                response: content
+            },
+        };
+    };
+
+    formatPayloadForLocalAI  (msg){
+        const { tool_calls = [], content } = msg;
+        const output = [];
+        const payload = this.createConsistentPayload(content);
+
+       if(tool_calls.length){
+           tool_calls.forEach((answer) => {
+
+               const payload = this.createConsistentPayload(answer.content);
+
+               if (answer.function) {
+                   const deepCopyPayload = Sugar.Object.clone(payload, true);
+
+                   deepCopyPayload.args = {
+                       ...answer.function.arguments,
+                   };
+                   deepCopyPayload.nodeName = answer.function.name;
+                   output.push(deepCopyPayload);
+
+               } else {
+                   output.push(payload);
+               }
+           });
+       }else{
+           output.push(payload);
+       }
+
+        return output
+    };
+
+    formatPayloadForOpenAI (choices) {
+        const output = [];
+        choices.forEach((answer) => {
+            const { content = "", tool_calls } = answer.message;
+            const payload = this.createConsistentPayload(content);
+
+            if (tool_calls) {
+                tool_calls.forEach((tool) => {
+                    const deepCopyPayload = Sugar.Object.clone(payload, true);
+
+                    if (tool.type === "function") {
+                        deepCopyPayload.args = {
+                            ...JSON.parse(tool.function.arguments),
+                        };
+                        deepCopyPayload.nodeName = tool.function.name;
+                        output.push(deepCopyPayload);
+                    }
+                });
+            } else {
+                output.push(payload);
+            }
+        });
+
+        return output;
+    };
+
+    formatPayloadForGeminiAI (msg) {
+        const output = [];
+        const { functions = [], text } = msg;
+        const payload = this.createConsistentPayload(text);
+
+        if (functions.length > 0) {
+            functions.forEach((tool) => {
+                const { name, args } = tool;
+                output.push({
+                    args: {
+                        ...payload.args,
+                        ...args,
+                    },
+                    nodeName: name,
+                });
+            });
+        } else {
+            output.push(payload);
+        }
+
+        return output;
+    };
+}
+
+module.exports = {
+    Format,
+};

package/utilities/gemini-controller.js

@@ -0,0 +1,243 @@
+const { TOOL_CHOICE } = require("../constants");
+const { ChatLedger } = require("./chat-ledger");
+const { ContextDatabase } = require("../globalUtils");
+
+class GeminiController {
+  constructor(node, config, msg, RED) {
+    this.msg = msg;
+    this.node = node;
+    this.config = config;
+    this.apiProperties = getChatCompletionProps(msg, config, node);
+
+    const registeredIntentFunctions = this.getRegisteredIntentFunctions(RED);
+    const rawIntents = this.getRawIntents(RED);
+
+    this.tools = [
+      ...this.apiProperties.tools,
+      ...registeredIntentFunctions,
+    ].filter(Boolean);
+
+    this.tools = convertToolsToGeminiCompatibleTools(this.tools);
+
+    const toolProperties = determineToolProperties(
+      rawIntents,
+      this.tools,
+      this.apiProperties.tool_choice
+    );
+
+    this.toolProperties = validateToolProperties(toolProperties, node);
+    this.tools;
+  }
+
+  mergeResponseWithMessage = (payload, request) => {
+    const { user, system, tools, ...rest } = this.msg;
+    const ledger = new ChatLedger(this.config.conversation_id, this.node);
+    const response = {
+      functions: payload.functions,
+      message: { role: "assistant", content: payload.text },
+    };
+    const fullConversation = ledger.addResponseToConversationAndSave(
+      request,
+      response,
+      this.node.type
+    );
+
+    return {
+      ...rest,
+      payload: response,
+      _debug: {
+        ...request,
+        type: this.node.type,
+        fullConversation,
+        conversation_id: this.config.conversation_id,
+      },
+    };
+  };
+
+  /**
+   * Converts the raw intents into functions that the LLM can use.
+   * @param {*} node
+   * @returns
+   */
+  getRegisteredIntentFunctions = (RED) => {
+    const intents = this.getRawIntents(RED);
+    return createFunctionsFromContext(intents);
+  };
+
+  /**
+   * This will return all stored Registered Intents throughout the entire system
+   * and Tool Nodes that are attached directly to this flow
+   * This will return:
+   *  type RawIntent = {
+   *    [node_id]: node // could be Registered Intent or Tool node
+   *  }
+   */
+  getRawIntents = (RED) => {
+    const context = new ContextDatabase(RED);
+    return context.getNodeStore() || {};
+  };
+}
+
+/**
+ * If no tools exist, then remove tools and toolChoice from the payload
+ */
+const validateToolProperties = (toolProperties, node) => {
+  if (!toolProperties.tools?.functionDeclarations?.length) {
+    const { toolChoice, ...rest } = toolProperties;
+
+    if (toolChoice && toolChoice !== "none") {
+      node.warn(
+        "Removing tools from payload since no tools are available. Flow will continue."
+      );
+    }
+
+    return rest;
+  }
+  return toolProperties;
+};
+
+/**
+ * combines various properties from `msg` and `config` to return all the properties needed for OpenAI API request
+ * @param {Record<string,any>} msg
+ * @param {Record<string, any>} config
+ * @returns
+ */
+const getChatCompletionProps = (msg, config, node) => {
+  const model = msg.payload?.model || config.model;
+  const temperature = Number(msg.payload?.temperature || config.temperature);
+  const max_tokens = Number(msg.payload?.max_tokens || config.max_tokens);
+  const top_p = Number(msg.payload?.top_p || config.top_p);
+  const top_k = Number(msg.payload?.top_k || config.top_k);
+  const tools = msg?.tools || [];
+  const tool_choice = msg.payload?.tool_choice || config?.tool_choice || "auto";
+  const ledger = new ChatLedger(config.conversation_id, node);
+  const messages = ledger.combineExistingMessages(msg.user, msg.system);
+  const { updated, original } = convertChatToGeminiCompatibleChat(messages);
+  const history = [...updated];
+  const nextMessage = history.pop();
+  const message = nextMessage?.parts[0]?.text || "";
+
+  return {
+    model,
+    temperature,
+    maxOutputTokens: max_tokens,
+    topP: top_p,
+    topK: top_k,
+    messages: original, // contains  the full chat in it's original form
+    history, // contains the gemini compatible chat w/o the user's current message (the last message in the array)
+    message,
+    tool_choice,
+    tools,
+  };
+};
+
+const convertChatToGeminiCompatibleChat = (messages = []) => {
+  const original = [...messages];
+  const updated = messages.map((message) => {
+    let role = message.role;
+    // Gemini doesn't seem to have a system role. We wil convert it to a user
+    if (role === "system") {
+      role = "user";
+    }
+
+    return { role, parts: [{ text: message.content }] };
+  });
+  return { original, updated };
+};
+
+const convertToolsToGeminiCompatibleTools = (tools = []) => {
+  return {
+    functionDeclarations: tools.map((tool) => {
+      return tool.function;
+    }),
+  };
+};
+
+/**
+ * converts the registered intents stored in the context into functions that can be used by the LLM.
+ * The registered intent will be ignored if excludeFromOpenAi is set to true.
+ * rawIntents may have tool nodes included so the values need to be filtered by the node type.
+ * rawIntents have the following shape:
+ *
+ * type RawIntents = {
+ *  [node_id]: node // node could be Registered Intent or Tool node
+ * }
+ */
+const createFunctionsFromContext = (rawIntents = {}) => {
+  return (
+    Object.values(rawIntents)
+      .filter((payload) => {
+        return payload.type === "Register Intent";
+      })
+      .map((payload) => {
+        if (payload.excludeFromOpenAi) {
+          return undefined;
+        }
+
+        return {
+          type: "function",
+          function: {
+            name: payload.name,
+            description: payload.description,
+            parameters: {
+              type: "object",
+              properties: {
+                isRegisteredIntent: { type: "string", enum: ["true"] },
+                response: {
+                  type: "string",
+                  description: "A friendly response to the given command",
+                },
+              },
+              required: ["isRegisteredIntent", "response"],
+            },
+          },
+        };
+      })
+      .filter(Boolean) || []
+  );
+};
+
+/**
+ * Based on the tool_choice the tool properties will be created. This is based off
+ * https://cookbook.openai.com/examples/how_to_call_functions_with_chat_models
+ *
+ * @param {Object} context - contains all the saved nodes that represents functions
+ * @param {*} tools - All the tools to be sent as functions
+ * @param {*} toolChoice - Specifies which tools to use
+ * @returns
+ */
+const determineToolProperties = (
+  context = {},
+  tools = [],
+  toolChoice = TOOL_CHOICE.Auto
+) => {
+  const props = {
+    tools,
+    tool_choice: toolChoice,
+  };
+  if (toolChoice === TOOL_CHOICE.None) {
+    // No tools chosen
+    props.tools = [];
+    return props;
+  } else if (
+    toolChoice === TOOL_CHOICE.Auto ||
+    toolChoice === TOOL_CHOICE.Any
+  ) {
+    // set the choice to auto or any
+    return props;
+  } else if (context[toolChoice]?.name) {
+    // A specific tool was chosen
+    props.tool_choice = TOOL_CHOICE.Any;
+    props.allowedFunctionNames = [context[toolChoice].name];
+    return props;
+  }
+  // Something funky happened so we will use auto instead
+  return {
+    tools,
+    tool_choice: TOOL_CHOICE.Auto,
+  };
+};
+
+module.exports = {
+  GeminiController,
+};

package/utilities/global-context.js

@@ -0,0 +1,30 @@
+class GlobalContext {
+  constructor(node) {
+    if (!node) {
+      throw new Error(
+        "Fatal Error: Cannot access global context without a node."
+      );
+    }
+    this.node = node;
+  }
+
+  setValueToGlobalContext = (value, key) => {
+    const globalContext = getGlobalContext(this.node);
+
+    globalContext.set(key, value);
+  };
+
+  getValueFromGlobalContext = (key) => {
+    const globalContext = getGlobalContext(this.node);
+
+    return globalContext.get(key);
+  };
+}
+
+const getGlobalContext = (node) => {
+  return node.context().global;
+};
+
+module.exports = {
+  GlobalContext,
+};

package/utilities/validateSchema.js

@@ -0,0 +1,74 @@
+const Ajv = require("ajv");
+const addFormats = require("ajv-formats");
+
+// Initialize AJV
+const ajv = new Ajv({ allErrors: true });
+addFormats(ajv); // Add extra format validations
+
+/**
+ * Validate the user schema against OpenAI function calling requirements.
+ * @param {object} userSchema - The schema to validate.
+ * @returns {object} { isValid: boolean, errorMsg: string }
+ */
+function validateOpenAISchema(userSchema) {
+    // Ensure root schema type is "object"
+    if (userSchema.type !== "object") {
+        return { isValid: false, errorMsg: "OpenAI function calling requires `type: object` at the root level." };
+    }
+
+    // Ensure the schema has a "properties" field and it is an object
+    if (!userSchema.properties || typeof userSchema.properties !== "object") {
+        return { isValid: false, errorMsg: "OpenAI function calling requires a `properties` field with key-value pairs." };
+    }
+
+    // Validate each property inside the schema
+    for (const [key, value] of Object.entries(userSchema.properties)) {
+        if (typeof value !== "object") {
+            return { isValid: false, errorMsg: `Property '${key}' must be an object with type definitions.` };
+        }
+
+        // Check if type is defined and valid
+        const validTypes = ["string", "number", "integer", "boolean", "array", "object"];
+        if (!value.type || !validTypes.includes(value.type)) {
+            return { isValid: false, errorMsg: `Property '${key}' must have a valid type (string, number, integer, boolean, array, object).` };
+        }
+
+        // If `enum` is present, ensure it is an array with at least one item
+        if (value.enum) {
+            if (!Array.isArray(value.enum) || value.enum.length === 0) {
+                return { isValid: false, errorMsg: `Property '${key}' has an invalid "enum". It must be a non-empty array.` };
+            }
+        }
+    }
+
+    // If `required` is present, ensure it is an array of existing properties
+    if (userSchema.required) {
+        if (!Array.isArray(userSchema.required) || !userSchema.required.every((reqKey) => userSchema.properties.hasOwnProperty(reqKey))) {
+            return { isValid: false, errorMsg: `"required" field must be an array of existing property keys.` };
+        }
+    }
+
+    return { isValid: true, errorMsg: "" };
+}
+
+// // Example: User-Submitted JSON Schema
+// const userSchema = {
+//     type: "object",
+//     properties: {
+//         query: { type: "string" },
+//         max_results: { type: "integer", minimum: 1 },
+//         mode: { type: "string", enum: ["fast", "slow", "balanced"] } // Example of an enum
+//     },
+//     required: ["query"],
+//     additionalProperties: false
+// };
+//
+// // Run validation
+// const result = validateOpenAISchema(userSchema);
+// console.log(result);
+
+
+
+module.exports = {
+    validateOpenAISchema
+}