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

package/test/openai-methods-mapping.test.js

@@ -1,5 +1,8 @@
 "use strict";
 
+// This file is the broad API surface sanity check.
+// It proves our method wrappers, examples, and help text still line up with the OpenAI SDK contract.
+
 const assert = require("node:assert/strict");
 const fs = require("node:fs");
 const path = require("node:path");
@@ -158,6 +161,298 @@ test("responses methods map delete/cancel/compact/input-items/input-tokens to Op
   ]);
 });
 
+test("responses create forwards phase, prompt_cache_key, tool_search, defer_loading, computer, and gpt-5.4 payloads", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.responses = {
+        create: async (payload) => {
+          calls.push({ method: "responses.create", payload });
+          return { id: "resp_123", status: "completed" };
+        },
+      };
+    }
+  }
+
+  const requestPayload = {
+    model: "gpt-5.4",
+    prompt_cache_key: "responses-agentic-demo-v1",
+    input: [
+      {
+        type: "message",
+        role: "assistant",
+        phase: "commentary",
+        content: [{ type: "output_text", text: "Planning the response." }],
+      },
+      {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: "Summarize the release work." }],
+      },
+    ],
+    tools: [
+      { type: "tool_search" },
+      {
+        type: "function",
+        name: "lookup_release_ticket",
+        description: "Look up a release ticket by id.",
+        parameters: {
+          type: "object",
+          properties: {
+            ticket_id: { type: "string" },
+          },
+          required: ["ticket_id"],
+          additionalProperties: false,
+        },
+        strict: true,
+        defer_loading: true,
+      },
+      { type: "computer" },
+    ],
+  };
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/responses/methods.js");
+    delete require.cache[modulePath];
+    const responsesMethods = require("../src/responses/methods.js");
+
+    const clientContext = { clientParams: { apiKey: "sk-test", baseURL: "https://api.example.com/v1" } };
+
+    const response = await responsesMethods.createModelResponse.call(clientContext, {
+      payload: requestPayload,
+    });
+
+    assert.deepEqual(response, { id: "resp_123", status: "completed" });
+
+    delete require.cache[modulePath];
+  });
+
+  const createCalls = calls.filter((entry) => entry.method === "responses.create");
+  assert.deepEqual(createCalls, [
+    {
+      method: "responses.create",
+      payload: requestPayload,
+    },
+  ]);
+});
+
+test("responses example flows remain valid JSON and cover the documented agentic payload shapes", () => {
+  const phaseExamplePath = path.join(
+    __dirname,
+    "..",
+    "examples",
+    "responses",
+    "phase.json"
+  );
+  const toolSearchExamplePath = path.join(
+    __dirname,
+    "..",
+    "examples",
+    "responses",
+    "tool-search.json"
+  );
+  const computerUseExamplePath = path.join(
+    __dirname,
+    "..",
+    "examples",
+    "responses",
+    "computer-use.json"
+  );
+  const websocketExamplePath = path.join(
+    __dirname,
+    "..",
+    "examples",
+    "responses",
+    "websocket.json"
+  );
+
+  const phaseExample = JSON.parse(fs.readFileSync(phaseExamplePath, "utf8"));
+  const toolSearchExample = JSON.parse(
+    fs.readFileSync(toolSearchExamplePath, "utf8")
+  );
+  const computerUseExample = JSON.parse(
+    fs.readFileSync(computerUseExamplePath, "utf8")
+  );
+  const websocketExample = JSON.parse(
+    fs.readFileSync(websocketExamplePath, "utf8")
+  );
+
+  [phaseExample, toolSearchExample, computerUseExample].forEach((flow) => {
+    assert.ok(Array.isArray(flow));
+    const openaiNode = flow.find((entry) => entry.type === "OpenAI API");
+    const commentNodes = flow.filter((entry) => entry.type === "comment");
+    assert.ok(openaiNode);
+    assert.equal(openaiNode.method, "createModelResponse");
+    assert.ok(commentNodes.length >= 1);
+  });
+
+  const phaseInjectNode = phaseExample.find(
+    (entry) => entry.type === "inject" && entry.name === "Create Phased Response"
+  );
+  const toolSearchInjectNode = toolSearchExample.find(
+    (entry) =>
+      entry.type === "inject" && entry.name === "Create Tool Search Request"
+  );
+  const computerCreateInjectNode = computerUseExample.find(
+    (entry) => entry.type === "inject" && entry.name === "Create Computer Request"
+  );
+  const computerFollowupInjectNode = computerUseExample.find(
+    (entry) =>
+      entry.type === "inject" &&
+      entry.name === "Submit Computer Screenshot (edit placeholders)"
+  );
+
+  assert.ok(phaseInjectNode);
+  assert.ok(toolSearchInjectNode);
+  assert.ok(computerCreateInjectNode);
+  assert.ok(computerFollowupInjectNode);
+
+  const phaseMessage = JSON.parse(
+    phaseInjectNode.props.find((prop) => prop.p === "ai.input[0]").v
+  );
+  const toolSearchTool = JSON.parse(
+    toolSearchInjectNode.props.find((prop) => prop.p === "ai.tools[0]").v
+  );
+  const deferredMcpTool = JSON.parse(
+    toolSearchInjectNode.props.find((prop) => prop.p === "ai.tools[1]").v
+  );
+  const computerTool = JSON.parse(
+    computerCreateInjectNode.props.find((prop) => prop.p === "ai.tools[0]").v
+  );
+  const computerCallOutput = JSON.parse(
+    computerFollowupInjectNode.props.find((prop) => prop.p === "ai.input[0]").v
+  );
+
+  assert.equal(
+    phaseInjectNode.props.find((prop) => prop.p === "ai.prompt_cache_key").v,
+    "responses-phase-example-v1"
+  );
+  assert.equal(phaseMessage.phase, "commentary");
+  assert.equal(toolSearchTool.type, "tool_search");
+  assert.equal(deferredMcpTool.defer_loading, true);
+  assert.equal(computerTool.type, "computer");
+  assert.equal(computerCallOutput.type, "computer_call_output");
+  assert.equal(computerCallOutput.output.type, "computer_screenshot");
+
+  assert.ok(Array.isArray(websocketExample));
+  const websocketOpenaiNode = websocketExample.find(
+    (entry) => entry.type === "OpenAI API"
+  );
+  const websocketCommentNodes = websocketExample.filter(
+    (entry) => entry.type === "comment"
+  );
+  const connectInjectNode = websocketExample.find(
+    (entry) =>
+      entry.type === "inject" && entry.name === "Connect Responses WebSocket"
+  );
+  const sendInjectNode = websocketExample.find(
+    (entry) =>
+      entry.type === "inject" && entry.name === "Send response.create Event"
+  );
+  const closeInjectNode = websocketExample.find(
+    (entry) =>
+      entry.type === "inject" && entry.name === "Close Responses WebSocket"
+  );
+
+  assert.ok(websocketOpenaiNode);
+  assert.equal(websocketOpenaiNode.method, "manageModelResponseWebSocket");
+  assert.ok(websocketCommentNodes.length >= 2);
+  assert.ok(connectInjectNode);
+  assert.ok(sendInjectNode);
+  assert.ok(closeInjectNode);
+  assert.equal(
+    connectInjectNode.props.find((prop) => prop.p === "ai.action").v,
+    "connect"
+  );
+  assert.equal(
+    sendInjectNode.props.find((prop) => prop.p === "ai.action").v,
+    "send"
+  );
+  assert.equal(
+    closeInjectNode.props.find((prop) => prop.p === "ai.action").v,
+    "close"
+  );
+  assert.deepEqual(
+    JSON.parse(sendInjectNode.props.find((prop) => prop.p === "ai.event").v),
+    {
+      type: "response.create",
+      model: "gpt-5.4",
+      input: "Say hello from Responses websocket mode in one sentence.",
+    }
+  );
+});
+
+test("responses help documents websocket lifecycle contract", () => {
+  const responsesHelpPath = path.join(__dirname, "..", "src", "responses", "help.html");
+  const responsesHelp = fs.readFileSync(responsesHelpPath, "utf8");
+
+  assert.match(responsesHelp, /Manage Model Response WebSocket/);
+  assert.match(responsesHelp, /msg\.payload\.action/);
+  assert.match(responsesHelp, /connect<\/code>, <code>send<\/code>, or <code>close<\/code>/);
+  assert.match(responsesHelp, /msg\.openai/);
+  assert.match(responsesHelp, /custom auth headers and query-string auth/);
+});
+
+test("realtime example flow remains valid JSON and documents the nested session contract", () => {
+  const realtimeExamplePath = path.join(
+    __dirname,
+    "..",
+    "examples",
+    "realtime",
+    "client-secrets.json"
+  );
+
+  const realtimeExample = JSON.parse(fs.readFileSync(realtimeExamplePath, "utf8"));
+  assert.ok(Array.isArray(realtimeExample));
+
+  const openaiNode = realtimeExample.find((entry) => entry.type === "OpenAI API");
+  const commentNodes = realtimeExample.filter((entry) => entry.type === "comment");
+  const explainerComment = realtimeExample.find(
+    (entry) => entry.type === "comment" && entry.name === "What is a client secret?"
+  );
+  const realtimeInjectNode = realtimeExample.find(
+    (entry) =>
+      entry.type === "inject" &&
+      entry.name === "Create Realtime 1.5 Client Secret"
+  );
+  const audioInjectNode = realtimeExample.find(
+    (entry) =>
+      entry.type === "inject" &&
+      entry.name === "Create Audio 1.5 Client Secret"
+  );
+
+  assert.ok(openaiNode);
+  assert.equal(openaiNode.method, "createRealtimeClientSecret");
+  assert.ok(commentNodes.length >= 3);
+  assert.ok(explainerComment);
+  assert.match(explainerComment.info, /not your long-lived OpenAI API key/);
+  assert.ok(realtimeInjectNode);
+  assert.ok(audioInjectNode);
+
+  assert.equal(
+    realtimeInjectNode.props.find((prop) => prop.p === "ai.session.type").v,
+    "realtime"
+  );
+  assert.equal(
+    realtimeInjectNode.props.find((prop) => prop.p === "ai.session.model").v,
+    "gpt-realtime-1.5"
+  );
+  assert.equal(
+    audioInjectNode.props.find((prop) => prop.p === "ai.session.type").v,
+    "realtime"
+  );
+  assert.equal(
+    audioInjectNode.props.find((prop) => prop.p === "ai.session.model").v,
+    "gpt-audio-1.5"
+  );
+  assert.equal(
+    realtimeInjectNode.props.find((prop) => prop.p === "ai.expires_after.seconds").v,
+    "600"
+  );
+});
+
 test("responses retrieve streams chunks when stream=true", async () => {
   const calls = [];
 
@@ -876,7 +1171,7 @@ test("videos methods map to OpenAI SDK videos endpoints", async () => {
   ]);
 });
 
-test("realtime methods map to OpenAI SDK realtime endpoints", async () => {
+test("realtime methods map to OpenAI SDK realtime endpoints and pass newer model ids through unchanged", async () => {
   const calls = [];
 
   class FakeOpenAI {
@@ -886,7 +1181,11 @@ test("realtime methods map to OpenAI SDK realtime endpoints", async () => {
         clientSecrets: {
           create: async (body) => {
             calls.push({ method: "realtime.clientSecrets.create", body });
-            return { client_secret: { value: "rt_secret_1", expires_at: 123 } };
+            return {
+              expires_at: 123,
+              session: body.session,
+              value: "ek_rt_secret_1",
+            };
           },
         },
         calls: {
@@ -914,13 +1213,34 @@ test("realtime methods map to OpenAI SDK realtime endpoints", async () => {
 
     const clientContext = { clientParams: { apiKey: "sk-test" } };
 
+    const clientSecretPayload = {
+      expires_after: {
+        anchor: "created_at",
+        seconds: 600,
+      },
+      session: {
+        type: "realtime",
+        model: "gpt-realtime-1.5",
+        instructions: "Speak clearly and keep responses concise.",
+        output_modalities: ["audio"],
+      },
+    };
     const secret = await realtimeMethods.createRealtimeClientSecret.call(clientContext, {
-      payload: { model: "gpt-realtime" },
+      payload: clientSecretPayload,
+    });
+    assert.deepEqual(secret, {
+      expires_at: 123,
+      session: clientSecretPayload.session,
+      value: "ek_rt_secret_1",
     });
-    assert.deepEqual(secret, { client_secret: { value: "rt_secret_1", expires_at: 123 } });
 
     const accepted = await realtimeMethods.acceptRealtimeCall.call(clientContext, {
-      payload: { call_id: "call_1", type: "realtime", model: "gpt-realtime" },
+      payload: {
+        call_id: "call_1",
+        type: "realtime",
+        model: "gpt-audio-1.5",
+        output_modalities: ["audio"],
+      },
     });
     assert.deepEqual(accepted, { call_id: "call_1", status: "accepted" });
 
@@ -946,12 +1266,27 @@ test("realtime methods map to OpenAI SDK realtime endpoints", async () => {
   assert.deepEqual(realtimeCalls, [
     {
       method: "realtime.clientSecrets.create",
-      body: { model: "gpt-realtime" },
+      body: {
+        expires_after: {
+          anchor: "created_at",
+          seconds: 600,
+        },
+        session: {
+          type: "realtime",
+          model: "gpt-realtime-1.5",
+          instructions: "Speak clearly and keep responses concise.",
+          output_modalities: ["audio"],
+        },
+      },
     },
     {
       method: "realtime.calls.accept",
       callId: "call_1",
-      body: { type: "realtime", model: "gpt-realtime" },
+      body: {
+        type: "realtime",
+        model: "gpt-audio-1.5",
+        output_modalities: ["audio"],
+      },
     },
     {
       method: "realtime.calls.hangup",
@@ -1176,6 +1511,10 @@ test("editor templates and locale expose latest methods", () => {
   assert.match(evalsHelp, /⋙ List Eval Run Output Items/);
   assert.match(realtimeHelp, /⋙ Create Realtime Client Secret/);
   assert.match(realtimeHelp, /⋙ Reject Realtime Call/);
+  assert.match(realtimeHelp, /msg\.payload\.session/);
+  assert.match(realtimeHelp, /session\.model/);
+  assert.match(realtimeHelp, /gpt-realtime-1\.5/);
+  assert.match(realtimeHelp, /gpt-audio-1\.5/);
   assert.match(skillsHelp, /⋙ Create Skill/);
   assert.match(skillsHelp, /⋙ List Skill Versions/);
   assert.match(videosHelp, /⋙ Download Video Content/);

package/test/openai-node-auth-routing.test.js

@@ -1,5 +1,8 @@
 "use strict";
 
+// This file keeps the Service Host auth rules honest.
+// It checks that header auth, query auth, and default Authorization behavior are all routed the way this node promises.
+
 const assert = require("node:assert/strict");
 const EventEmitter = require("node:events");
 const test = require("node:test");