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

package/src/responses/methods.js

@@ -1,23 +1,187 @@
 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;
+  _node.status({
+    fill: "green",
+    shape: "dot",
+    text: "OpenaiApi.status.streaming",
+  });
+  for await (const chunk of response) {
+    if (typeof chunk === "object") {
+      const newMsg = { ...msg, payload: chunk };
+      _node.send(newMsg);
+    }
+  }
+  _node.status({});
+}
 
 async function createModelResponse(parameters) {
-  const { _node, ...params } = parameters;
   const openai = new OpenAI(this.clientParams);
   const response = await openai.responses.create(parameters.payload);
 
-  if (params.payload.stream) {
-    _node.status({
-      fill: "green",
-      shape: "dot",
-      text: "OpenaiApi.status.streaming",
-    });
-    for await (const chunk of response) {
-      if (typeof chunk === "object") {
-        const newMsg = { ...parameters.msg, payload: chunk };
-        _node.send(newMsg);
-      }
-    }
-    _node.status({});
+  if (parameters.payload.stream) {
+    await streamResponse(parameters, response);
   } else {
     return response;
   }
@@ -28,13 +192,32 @@ async function getModelResponse(parameters) {
   const { response_id, ...params } = parameters.payload;
   const response = await openai.responses.retrieve(response_id, params);
 
-  return response;
+  if (params.stream) {
+    await streamResponse(parameters, response);
+  } else {
+    return response;
+  }
 }
 
 async function deleteModelResponse(parameters) {
   const openai = new OpenAI(this.clientParams);
   const { response_id, ...params } = parameters.payload;
-  const response = await openai.responses.del(response_id, params);
+  const response = await openai.responses.delete(response_id, params);
+
+  return response;
+}
+
+async function cancelModelResponse(parameters) {
+  const openai = new OpenAI(this.clientParams);
+  const { response_id, ...params } = parameters.payload;
+  const response = await openai.responses.cancel(response_id, params);
+
+  return response;
+}
+
+async function compactModelResponse(parameters) {
+  const openai = new OpenAI(this.clientParams);
+  const response = await openai.responses.compact(parameters.payload);
 
   return response;
 }
@@ -47,9 +230,44 @@ async function listInputItems(parameters) {
   return [...list.data];
 }
 
+async function countInputTokens(parameters) {
+  const openai = new OpenAI(this.clientParams);
+  const response = await openai.responses.inputTokens.count(parameters.payload);
+
+  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,
   deleteModelResponse,
+  cancelModelResponse,
+  compactModelResponse,
   listInputItems,
+  countInputTokens,
+  manageModelResponseWebSocket,
 };

package/src/responses/template.html

@@ -14,9 +14,29 @@
         data-i18n="OpenaiApi.parameters.deleteModelResponse"
         ></option>
 
+        <option
+        value="cancelModelResponse"
+        data-i18n="OpenaiApi.parameters.cancelModelResponse"
+        ></option>
+
+        <option
+        value="compactModelResponse"
+        data-i18n="OpenaiApi.parameters.compactModelResponse"
+        ></option>
+
         <option
         value="listInputItems"
         data-i18n="OpenaiApi.parameters.listInputItems"
         ></option>
 
-      </optgroup>
+        <option
+        value="countInputTokens"
+        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,
+};