@inductiv/node-red-openai-api 6.22.0 → 6.27.0

package/src/responses/methods.js

@@ -1,4 +1,164 @@
 const OpenAI = require("openai").OpenAI;
+const { ResponsesWebSocket } = require("./websocket.js");
+
+function getResponsesWebSocketConnections(node) {
+  if (!node._responsesWebSocketConnections) {
+    node._responsesWebSocketConnections = new Map();
+  }
+
+  return node._responsesWebSocketConnections;
+}
+
+function ensureResponsesWebSocketCleanup(node) {
+  if (node._responsesWebSocketCleanupRegistered) {
+    return;
+  }
+
+  if (typeof node.registerCleanupHandler !== "function") {
+    throw new Error("OpenAI API node does not support cleanup registration");
+  }
+
+  node._responsesWebSocketCleanupRegistered = true;
+  node.registerCleanupHandler(async () => {
+    const connections = getResponsesWebSocketConnections(node);
+    const closeOperations = [];
+
+    for (const connection of connections.values()) {
+      closeOperations.push(
+        connection.close({
+          code: 1000,
+          reason: "Node-RED node closed",
+        })
+      );
+    }
+
+    await Promise.all(closeOperations);
+    connections.clear();
+  });
+}
+
+function requireConnectionId(payload) {
+  if (typeof payload.connection_id !== "string" || payload.connection_id.trim() === "") {
+    throw new Error("msg.payload.connection_id must be a non-empty string");
+  }
+
+  return payload.connection_id;
+}
+
+function createResponsesWebSocketEventMessage(connectionId, event) {
+  return {
+    payload: event,
+    openai: {
+      transport: "responses.websocket",
+      direction: "server",
+      connection_id: connectionId,
+      event_type: event.type,
+    },
+  };
+}
+
+function attachResponsesWebSocketListeners(node, connectionId, connection) {
+  connection.on("event", (event) => {
+    node.send(createResponsesWebSocketEventMessage(connectionId, event));
+  });
+
+  connection.on("error", (error) => {
+    node.error(error);
+  });
+
+  connection.on("close", () => {
+    const connections = getResponsesWebSocketConnections(node);
+    connections.delete(connectionId);
+  });
+}
+
+async function connectResponsesWebSocket(parameters) {
+  const node = parameters._node;
+  const payload = parameters.payload || {};
+  const connectionId = requireConnectionId(payload);
+  const connections = getResponsesWebSocketConnections(node);
+
+  if (connections.has(connectionId)) {
+    throw new Error(
+      `Responses websocket connection '${connectionId}' is already open on this node`
+    );
+  }
+
+  ensureResponsesWebSocketCleanup(node);
+
+  const connection = new ResponsesWebSocket(this.clientParams);
+  const connectionDetails = await connection.open();
+
+  attachResponsesWebSocketListeners(node, connectionId, connection);
+  connections.set(connectionId, connection);
+
+  return {
+    object: "response.websocket.connection",
+    action: "connect",
+    connection_id: connectionId,
+    url: connectionDetails.url,
+  };
+}
+
+async function sendResponsesWebSocketEvent(parameters) {
+  const node = parameters._node;
+  const payload = parameters.payload || {};
+  const connectionId = requireConnectionId(payload);
+  const connections = getResponsesWebSocketConnections(node);
+  const connection = connections.get(connectionId);
+
+  if (!connection) {
+    throw new Error(
+      `Responses websocket connection '${connectionId}' is not open on this node`
+    );
+  }
+
+  if (!payload.event || typeof payload.event !== "object" || Array.isArray(payload.event)) {
+    throw new Error("msg.payload.event must be an object");
+  }
+
+  if (payload.event.type !== "response.create") {
+    throw new Error("msg.payload.event.type must be 'response.create'");
+  }
+
+  connection.send(payload.event);
+
+  return {
+    object: "response.websocket.client_event",
+    action: "send",
+    connection_id: connectionId,
+    event_type: payload.event.type,
+  };
+}
+
+async function closeResponsesWebSocket(parameters) {
+  const node = parameters._node;
+  const payload = parameters.payload || {};
+  const connectionId = requireConnectionId(payload);
+  const connections = getResponsesWebSocketConnections(node);
+  const connection = connections.get(connectionId);
+
+  if (!connection) {
+    throw new Error(
+      `Responses websocket connection '${connectionId}' is not open on this node`
+    );
+  }
+
+  const closeDetails = await connection.close({
+    code: payload.code,
+    reason: payload.reason,
+  });
+
+  connections.delete(connectionId);
+
+  return {
+    object: "response.websocket.connection",
+    action: "close",
+    connection_id: connectionId,
+    code: closeDetails.code,
+    reason: closeDetails.reason,
+  };
+}
 
 async function streamResponse(parameters, response) {
   const { _node, msg } = parameters;
@@ -77,6 +237,30 @@ async function countInputTokens(parameters) {
   return response;
 }
 
+async function manageModelResponseWebSocket(parameters) {
+  const payload = parameters.payload || {};
+
+  if (typeof payload.action !== "string" || payload.action.trim() === "") {
+    throw new Error(
+      "msg.payload.action must be one of 'connect', 'send', or 'close'"
+    );
+  }
+
+  if (payload.action === "connect") {
+    return connectResponsesWebSocket.call(this, parameters);
+  }
+
+  if (payload.action === "send") {
+    return sendResponsesWebSocketEvent.call(this, parameters);
+  }
+
+  if (payload.action === "close") {
+    return closeResponsesWebSocket.call(this, parameters);
+  }
+
+  throw new Error("msg.payload.action must be one of 'connect', 'send', or 'close'");
+}
+
 module.exports = {
   createModelResponse,
   getModelResponse,
@@ -85,4 +269,5 @@ module.exports = {
   compactModelResponse,
   listInputItems,
   countInputTokens,
+  manageModelResponseWebSocket,
 };

package/src/responses/template.html

@@ -34,4 +34,9 @@
         data-i18n="OpenaiApi.parameters.countInputTokens"
         ></option>
 
+        <option
+        value="manageModelResponseWebSocket"
+        data-i18n="OpenaiApi.parameters.manageModelResponseWebSocket"
+        ></option>
+
       </optgroup>

package/src/responses/websocket.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const EventEmitter = require("node:events");
+const { WebSocket } = require("ws");
+
+function buildResponsesWebSocketURL(clientParams) {
+  const baseURL = clientParams.baseURL || "https://api.openai.com/v1";
+  const path = "/responses";
+  const url = new URL(baseURL + (baseURL.endsWith("/") ? path.slice(1) : path));
+  const defaultQuery = clientParams.defaultQuery || {};
+
+  for (const [key, value] of Object.entries(defaultQuery)) {
+    if (value !== undefined && value !== null) {
+      url.searchParams.set(key, value);
+    }
+  }
+
+  if (url.protocol === "https:") {
+    url.protocol = "wss:";
+  } else if (url.protocol === "http:") {
+    url.protocol = "ws:";
+  }
+
+  return url;
+}
+
+function buildResponsesWebSocketHeaders(clientParams) {
+  const headers = {};
+  const defaultHeaders = clientParams.defaultHeaders || {};
+  const hasAuthorizationOverride = Object.prototype.hasOwnProperty.call(
+    defaultHeaders,
+    "Authorization"
+  );
+
+  for (const [headerName, headerValue] of Object.entries(defaultHeaders)) {
+    if (headerValue !== undefined && headerValue !== null) {
+      headers[headerName] = headerValue;
+    }
+  }
+
+  if (!clientParams.defaultQuery && !hasAuthorizationOverride) {
+    headers.Authorization = `Bearer ${clientParams.apiKey}`;
+  }
+
+  if (clientParams.organization) {
+    headers["OpenAI-Organization"] = clientParams.organization;
+  }
+
+  return headers;
+}
+
+function createEventParseError(error) {
+  const parseError = new Error("Could not parse Responses websocket event");
+  parseError.cause = error;
+  return parseError;
+}
+
+class ResponsesWebSocket extends EventEmitter {
+  constructor(clientParams) {
+    super();
+    this.clientParams = clientParams;
+    this.url = buildResponsesWebSocketURL(clientParams);
+    this.headers = buildResponsesWebSocketHeaders(clientParams);
+    this.socket = null;
+  }
+
+  async open() {
+    if (this.socket) {
+      throw new Error("Responses websocket connection is already open");
+    }
+
+    const socket = new WebSocket(this.url, { headers: this.headers });
+
+    await new Promise((resolve, reject) => {
+      socket.once("open", () => {
+        this.socket = socket;
+        this.attachSocketListeners(socket);
+        resolve();
+      });
+      socket.once("error", reject);
+    });
+
+    return {
+      url: this.url.toString(),
+    };
+  }
+
+  attachSocketListeners(socket) {
+    socket.on("message", (data) => {
+      let event;
+
+      try {
+        event = JSON.parse(data.toString());
+      } catch (error) {
+        this.emit("error", createEventParseError(error));
+        return;
+      }
+
+      this.emit("event", event);
+    });
+
+    socket.on("error", (error) => {
+      this.emit("error", error);
+    });
+
+    socket.on("close", (code, reason) => {
+      if (this.socket === socket) {
+        this.socket = null;
+      }
+
+      this.emit("close", {
+        code,
+        reason: reason.toString(),
+      });
+    });
+  }
+
+  send(event) {
+    if (!this.socket) {
+      throw new Error("Responses websocket connection is not open");
+    }
+
+    this.socket.send(JSON.stringify(event));
+  }
+
+  async close(props = {}) {
+    if (!this.socket) {
+      throw new Error("Responses websocket connection is not open");
+    }
+
+    const socket = this.socket;
+    const closeCode = props.code ?? 1000;
+    const closeReason = props.reason ?? "OK";
+
+    await new Promise((resolve, reject) => {
+      socket.once("close", resolve);
+      socket.once("error", reject);
+      socket.close(closeCode, closeReason);
+    });
+
+    return {
+      code: closeCode,
+      reason: closeReason,
+    };
+  }
+}
+
+module.exports = {
+  ResponsesWebSocket,
+};