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

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

@@ -0,0 +1,1220 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+function withMockedOpenAI(FakeOpenAI, callback) {
+  const openaiModule = require("openai");
+  const originalDescriptor = Object.getOwnPropertyDescriptor(openaiModule, "OpenAI");
+
+  Object.defineProperty(openaiModule, "OpenAI", {
+    value: FakeOpenAI,
+    configurable: true,
+    enumerable: true,
+    writable: true,
+  });
+
+  const run = async () => {
+    try {
+      return await callback();
+    } finally {
+      if (originalDescriptor) {
+        Object.defineProperty(openaiModule, "OpenAI", originalDescriptor);
+      }
+    }
+  };
+
+  return run();
+}
+
+test("responses methods map delete/cancel/compact/input-items/input-tokens to OpenAI SDK", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.responses = {
+        delete: async (responseId, options) => {
+          calls.push({ method: "responses.delete", responseId, options });
+          return { id: responseId, deleted: true };
+        },
+        cancel: async (responseId, options) => {
+          calls.push({ method: "responses.cancel", responseId, options });
+          return { id: responseId, status: "cancelled" };
+        },
+        compact: async (payload) => {
+          calls.push({ method: "responses.compact", payload });
+          return { id: "compaction_1", object: "response.compaction" };
+        },
+        inputItems: {
+          list: async (responseId, options) => {
+            calls.push({ method: "responses.inputItems.list", responseId, options });
+            return {
+              data: [{ id: "item_1" }, { id: "item_2" }],
+            };
+          },
+        },
+        inputTokens: {
+          count: async (payload) => {
+            calls.push({ method: "responses.inputTokens.count", payload });
+            return { object: "response.input_tokens", input_tokens: 42 };
+          },
+        },
+      };
+    }
+  }
+
+  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 deleteResponse = await responsesMethods.deleteModelResponse.call(clientContext, {
+      payload: {
+        response_id: "resp_123",
+      },
+    });
+    assert.deepEqual(deleteResponse, { id: "resp_123", deleted: true });
+
+    const cancelResponse = await responsesMethods.cancelModelResponse.call(clientContext, {
+      payload: {
+        response_id: "resp_123",
+      },
+    });
+    assert.deepEqual(cancelResponse, { id: "resp_123", status: "cancelled" });
+
+    const compactResponse = await responsesMethods.compactModelResponse.call(clientContext, {
+      payload: {
+        model: "gpt-5.2",
+        input: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      },
+    });
+    assert.deepEqual(compactResponse, {
+      id: "compaction_1",
+      object: "response.compaction",
+    });
+
+    const inputItems = await responsesMethods.listInputItems.call(clientContext, {
+      payload: {
+        response_id: "resp_123",
+        order: "desc",
+        include: ["message.input_image.image_url"],
+      },
+    });
+    assert.deepEqual(inputItems, [{ id: "item_1" }, { id: "item_2" }]);
+
+    const inputTokenCount = await responsesMethods.countInputTokens.call(clientContext, {
+      payload: {
+        model: "gpt-4.1-mini",
+        input: "hello",
+      },
+    });
+    assert.deepEqual(inputTokenCount, {
+      object: "response.input_tokens",
+      input_tokens: 42,
+    });
+
+    delete require.cache[modulePath];
+  });
+
+  const responseCalls = calls.filter((entry) => entry.method !== "ctor");
+  assert.deepEqual(responseCalls, [
+    {
+      method: "responses.delete",
+      responseId: "resp_123",
+      options: {},
+    },
+    {
+      method: "responses.cancel",
+      responseId: "resp_123",
+      options: {},
+    },
+    {
+      method: "responses.compact",
+      payload: {
+        model: "gpt-5.2",
+        input: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      },
+    },
+    {
+      method: "responses.inputItems.list",
+      responseId: "resp_123",
+      options: {
+        order: "desc",
+        include: ["message.input_image.image_url"],
+      },
+    },
+    {
+      method: "responses.inputTokens.count",
+      payload: {
+        model: "gpt-4.1-mini",
+        input: "hello",
+      },
+    },
+  ]);
+});
+
+test("responses retrieve streams chunks when stream=true", async () => {
+  const calls = [];
+
+  async function* createFakeStream() {
+    yield { type: "response.in_progress", sequence_number: 1 };
+    yield { type: "response.completed", sequence_number: 2 };
+  }
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.responses = {
+        retrieve: async (responseId, options) => {
+          calls.push({ method: "responses.retrieve", responseId, options });
+          if (options.stream) {
+            return createFakeStream();
+          }
+          return { id: responseId, status: "completed" };
+        },
+      };
+    }
+  }
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/responses/methods.js");
+    delete require.cache[modulePath];
+    const responsesMethods = require("../src/responses/methods.js");
+
+    const sentMessages = [];
+    const statuses = [];
+    const node = {
+      send: (msg) => sentMessages.push(msg),
+      status: (status) => statuses.push(status),
+    };
+
+    const clientContext = { clientParams: { apiKey: "sk-test" } };
+
+    const streamResult = await responsesMethods.getModelResponse.call(clientContext, {
+      _node: node,
+      msg: { topic: "t1" },
+      payload: {
+        response_id: "resp_stream",
+        stream: true,
+      },
+    });
+    assert.equal(streamResult, undefined);
+
+    assert.deepEqual(sentMessages, [
+      {
+        topic: "t1",
+        payload: { type: "response.in_progress", sequence_number: 1 },
+      },
+      {
+        topic: "t1",
+        payload: { type: "response.completed", sequence_number: 2 },
+      },
+    ]);
+
+    assert.deepEqual(statuses, [
+      {
+        fill: "green",
+        shape: "dot",
+        text: "OpenaiApi.status.streaming",
+      },
+      {},
+    ]);
+
+    const retrieveResponse = await responsesMethods.getModelResponse.call(clientContext, {
+      _node: node,
+      msg: { topic: "t1" },
+      payload: {
+        response_id: "resp_non_stream",
+      },
+    });
+    assert.deepEqual(retrieveResponse, { id: "resp_non_stream", status: "completed" });
+
+    delete require.cache[modulePath];
+  });
+
+  const retrieveCalls = calls.filter((entry) => entry.method === "responses.retrieve");
+  assert.deepEqual(retrieveCalls, [
+    {
+      method: "responses.retrieve",
+      responseId: "resp_stream",
+      options: { stream: true },
+    },
+    {
+      method: "responses.retrieve",
+      responseId: "resp_non_stream",
+      options: {},
+    },
+  ]);
+});
+
+test("conversation methods map to OpenAI SDK conversations endpoints", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+
+      this.conversations = {
+        create: async (body) => {
+          calls.push({ method: "conversations.create", body });
+          return { id: "conv_new" };
+        },
+        retrieve: async (conversationId, options) => {
+          calls.push({ method: "conversations.retrieve", conversationId, options });
+          return { id: conversationId };
+        },
+        update: async (conversationId, body) => {
+          calls.push({ method: "conversations.update", conversationId, body });
+          return { id: conversationId, updated: true };
+        },
+        delete: async (conversationId, options) => {
+          calls.push({ method: "conversations.delete", conversationId, options });
+          return { id: conversationId, deleted: true };
+        },
+        items: {
+          create: async (conversationId, body) => {
+            calls.push({ method: "conversations.items.create", conversationId, body });
+            return { id: "item_new" };
+          },
+          retrieve: async (itemId, options) => {
+            calls.push({ method: "conversations.items.retrieve", itemId, options });
+            return { id: itemId };
+          },
+          list: async (conversationId, options) => {
+            calls.push({ method: "conversations.items.list", conversationId, options });
+            return { data: [{ id: "item_1" }, { id: "item_2" }] };
+          },
+          delete: async (itemId, options) => {
+            calls.push({ method: "conversations.items.delete", itemId, options });
+            return { id: itemId, deleted: true };
+          },
+        },
+      };
+    }
+  }
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/conversations/methods.js");
+    delete require.cache[modulePath];
+    const conversationMethods = require("../src/conversations/methods.js");
+
+    const clientContext = { clientParams: { apiKey: "sk-test" } };
+
+    const created = await conversationMethods.createConversation.call(clientContext, {
+      payload: { metadata: { app: "node-red" } },
+    });
+    assert.deepEqual(created, { id: "conv_new" });
+
+    const fetched = await conversationMethods.getConversation.call(clientContext, {
+      payload: { conversation_id: "conv_1", include: ["items"] },
+    });
+    assert.deepEqual(fetched, { id: "conv_1" });
+
+    const updated = await conversationMethods.modifyConversation.call(clientContext, {
+      payload: { conversation_id: "conv_1", metadata: { env: "dev" } },
+    });
+    assert.deepEqual(updated, { id: "conv_1", updated: true });
+
+    const deleted = await conversationMethods.deleteConversation.call(clientContext, {
+      payload: { conversation_id: "conv_1" },
+    });
+    assert.deepEqual(deleted, { id: "conv_1", deleted: true });
+
+    const createdItem = await conversationMethods.createConversationItem.call(clientContext, {
+      payload: {
+        conversation_id: "conv_1",
+        item: { role: "user", content: [{ type: "text", text: "hello" }] },
+      },
+    });
+    assert.deepEqual(createdItem, { id: "item_new" });
+
+    const fetchedItem = await conversationMethods.getConversationItem.call(clientContext, {
+      payload: {
+        conversation_id: "conv_1",
+        item_id: "item_1",
+      },
+    });
+    assert.deepEqual(fetchedItem, { id: "item_1" });
+
+    const listedItems = await conversationMethods.listConversationItems.call(clientContext, {
+      payload: {
+        conversation_id: "conv_1",
+        limit: 2,
+      },
+    });
+    assert.deepEqual(listedItems, [{ id: "item_1" }, { id: "item_2" }]);
+
+    const deletedItem = await conversationMethods.deleteConversationItem.call(clientContext, {
+      payload: {
+        conversation_id: "conv_1",
+        item_id: "item_1",
+      },
+    });
+    assert.deepEqual(deletedItem, { id: "item_1", deleted: true });
+
+    delete require.cache[modulePath];
+  });
+
+  assert.equal(calls.some((entry) => entry.method === "conversations.create"), true);
+  assert.equal(calls.some((entry) => entry.method === "conversations.items.list"), true);
+  assert.equal(calls.some((entry) => entry.method === "conversations.items.delete"), true);
+});
+
+test("skills methods map to OpenAI SDK skills endpoints", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.skills = {
+        create: async (body) => {
+          calls.push({ method: "skills.create", body });
+          return { id: "skill_new" };
+        },
+        retrieve: async (skillId, options) => {
+          calls.push({ method: "skills.retrieve", skillId, options });
+          return { id: skillId };
+        },
+        update: async (skillId, body) => {
+          calls.push({ method: "skills.update", skillId, body });
+          return { id: skillId, updated: true };
+        },
+        delete: async (skillId, options) => {
+          calls.push({ method: "skills.delete", skillId, options });
+          return { id: skillId, deleted: true };
+        },
+        list: async (options) => {
+          calls.push({ method: "skills.list", options });
+          return { data: [{ id: "skill_1" }, { id: "skill_2" }] };
+        },
+        content: {
+          retrieve: async (skillId, options) => {
+            calls.push({ method: "skills.content.retrieve", skillId, options });
+            return { id: skillId, object: "skill.content" };
+          },
+        },
+        versions: {
+          create: async (skillId, body) => {
+            calls.push({ method: "skills.versions.create", skillId, body });
+            return { id: "skill_version_new", skill_id: skillId };
+          },
+          retrieve: async (version, options) => {
+            calls.push({ method: "skills.versions.retrieve", version, options });
+            return { id: "skill_version_1", version };
+          },
+          list: async (skillId, options) => {
+            calls.push({ method: "skills.versions.list", skillId, options });
+            return { data: [{ id: "sv_1" }, { id: "sv_2" }] };
+          },
+          delete: async (version, options) => {
+            calls.push({ method: "skills.versions.delete", version, options });
+            return { deleted: true, version };
+          },
+          content: {
+            retrieve: async (version, options) => {
+              calls.push({ method: "skills.versions.content.retrieve", version, options });
+              return { object: "skill.version.content", version };
+            },
+          },
+        },
+      };
+    }
+  }
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/skills/methods.js");
+    delete require.cache[modulePath];
+    const skillMethods = require("../src/skills/methods.js");
+
+    const clientContext = { clientParams: { apiKey: "sk-test" } };
+
+    const listed = await skillMethods.listSkills.call(clientContext, {
+      payload: { order: "desc", limit: 2 },
+    });
+    assert.deepEqual(listed, [{ id: "skill_1" }, { id: "skill_2" }]);
+
+    const created = await skillMethods.createSkill.call(clientContext, {
+      payload: { files: ["./skill.zip"] },
+    });
+    assert.deepEqual(created, { id: "skill_new" });
+
+    const fetched = await skillMethods.getSkill.call(clientContext, {
+      payload: { skill_id: "skill_1" },
+    });
+    assert.deepEqual(fetched, { id: "skill_1" });
+
+    const updated = await skillMethods.modifySkill.call(clientContext, {
+      payload: { skill_id: "skill_1", default_version: "2" },
+    });
+    assert.deepEqual(updated, { id: "skill_1", updated: true });
+
+    const deleted = await skillMethods.deleteSkill.call(clientContext, {
+      payload: { skill_id: "skill_1" },
+    });
+    assert.deepEqual(deleted, { id: "skill_1", deleted: true });
+
+    const content = await skillMethods.getSkillContent.call(clientContext, {
+      payload: { skill_id: "skill_1" },
+    });
+    assert.deepEqual(content, { id: "skill_1", object: "skill.content" });
+
+    const listedVersions = await skillMethods.listSkillVersions.call(clientContext, {
+      payload: { skill_id: "skill_1", order: "asc" },
+    });
+    assert.deepEqual(listedVersions, [{ id: "sv_1" }, { id: "sv_2" }]);
+
+    const createdVersion = await skillMethods.createSkillVersion.call(clientContext, {
+      payload: { skill_id: "skill_1", default: true, files: ["./v2.zip"] },
+    });
+    assert.deepEqual(createdVersion, { id: "skill_version_new", skill_id: "skill_1" });
+
+    const fetchedVersion = await skillMethods.getSkillVersion.call(clientContext, {
+      payload: { skill_id: "skill_1", version: "2" },
+    });
+    assert.deepEqual(fetchedVersion, { id: "skill_version_1", version: "2" });
+
+    const deletedVersion = await skillMethods.deleteSkillVersion.call(clientContext, {
+      payload: { skill_id: "skill_1", version: "2" },
+    });
+    assert.deepEqual(deletedVersion, { deleted: true, version: "2" });
+
+    const versionContent = await skillMethods.getSkillVersionContent.call(clientContext, {
+      payload: { skill_id: "skill_1", version: "2" },
+    });
+    assert.deepEqual(versionContent, { object: "skill.version.content", version: "2" });
+
+    delete require.cache[modulePath];
+  });
+
+  const skillCalls = calls.filter((entry) => entry.method !== "ctor");
+  assert.deepEqual(skillCalls, [
+    {
+      method: "skills.list",
+      options: { order: "desc", limit: 2 },
+    },
+    {
+      method: "skills.create",
+      body: { files: ["./skill.zip"] },
+    },
+    {
+      method: "skills.retrieve",
+      skillId: "skill_1",
+      options: {},
+    },
+    {
+      method: "skills.update",
+      skillId: "skill_1",
+      body: { default_version: "2" },
+    },
+    {
+      method: "skills.delete",
+      skillId: "skill_1",
+      options: {},
+    },
+    {
+      method: "skills.content.retrieve",
+      skillId: "skill_1",
+      options: {},
+    },
+    {
+      method: "skills.versions.list",
+      skillId: "skill_1",
+      options: { order: "asc" },
+    },
+    {
+      method: "skills.versions.create",
+      skillId: "skill_1",
+      body: { default: true, files: ["./v2.zip"] },
+    },
+    {
+      method: "skills.versions.retrieve",
+      version: "2",
+      options: { skill_id: "skill_1" },
+    },
+    {
+      method: "skills.versions.delete",
+      version: "2",
+      options: { skill_id: "skill_1" },
+    },
+    {
+      method: "skills.versions.content.retrieve",
+      version: "2",
+      options: { skill_id: "skill_1" },
+    },
+  ]);
+});
+
+test("evals methods map to OpenAI SDK evals endpoints", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.evals = {
+        create: async (body) => {
+          calls.push({ method: "evals.create", body });
+          return { id: "eval_new" };
+        },
+        retrieve: async (evalId, options) => {
+          calls.push({ method: "evals.retrieve", evalId, options });
+          return { id: evalId };
+        },
+        update: async (evalId, body) => {
+          calls.push({ method: "evals.update", evalId, body });
+          return { id: evalId, updated: true };
+        },
+        delete: async (evalId, options) => {
+          calls.push({ method: "evals.delete", evalId, options });
+          return { id: evalId, deleted: true };
+        },
+        list: async (options) => {
+          calls.push({ method: "evals.list", options });
+          return { data: [{ id: "eval_1" }, { id: "eval_2" }] };
+        },
+        runs: {
+          create: async (evalId, body) => {
+            calls.push({ method: "evals.runs.create", evalId, body });
+            return { id: "run_new", eval_id: evalId };
+          },
+          retrieve: async (runId, options) => {
+            calls.push({ method: "evals.runs.retrieve", runId, options });
+            return { id: runId };
+          },
+          list: async (evalId, options) => {
+            calls.push({ method: "evals.runs.list", evalId, options });
+            return { data: [{ id: "run_1" }, { id: "run_2" }] };
+          },
+          delete: async (runId, options) => {
+            calls.push({ method: "evals.runs.delete", runId, options });
+            return { id: runId, deleted: true };
+          },
+          cancel: async (runId, options) => {
+            calls.push({ method: "evals.runs.cancel", runId, options });
+            return { id: runId, status: "cancelled" };
+          },
+          outputItems: {
+            retrieve: async (outputItemId, options) => {
+              calls.push({
+                method: "evals.runs.outputItems.retrieve",
+                outputItemId,
+                options,
+              });
+              return { id: outputItemId };
+            },
+            list: async (runId, options) => {
+              calls.push({ method: "evals.runs.outputItems.list", runId, options });
+              return { data: [{ id: "out_1" }, { id: "out_2" }] };
+            },
+          },
+        },
+      };
+    }
+  }
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/evals/methods.js");
+    delete require.cache[modulePath];
+    const evalMethods = require("../src/evals/methods.js");
+
+    const clientContext = { clientParams: { apiKey: "sk-test" } };
+
+    const listedEvals = await evalMethods.listEvals.call(clientContext, {
+      payload: { order: "desc", limit: 2 },
+    });
+    assert.deepEqual(listedEvals, [{ id: "eval_1" }, { id: "eval_2" }]);
+
+    const createdEval = await evalMethods.createEval.call(clientContext, {
+      payload: {
+        name: "Support quality eval",
+        data_source_config: { type: "custom", schema: { type: "object" } },
+        testing_criteria: [],
+      },
+    });
+    assert.deepEqual(createdEval, { id: "eval_new" });
+
+    const fetchedEval = await evalMethods.getEval.call(clientContext, {
+      payload: { eval_id: "eval_1" },
+    });
+    assert.deepEqual(fetchedEval, { id: "eval_1" });
+
+    const updatedEval = await evalMethods.modifyEval.call(clientContext, {
+      payload: { eval_id: "eval_1", name: "Updated eval" },
+    });
+    assert.deepEqual(updatedEval, { id: "eval_1", updated: true });
+
+    const deletedEval = await evalMethods.deleteEval.call(clientContext, {
+      payload: { eval_id: "eval_1" },
+    });
+    assert.deepEqual(deletedEval, { id: "eval_1", deleted: true });
+
+    const listedRuns = await evalMethods.listEvalRuns.call(clientContext, {
+      payload: { eval_id: "eval_1", limit: 2 },
+    });
+    assert.deepEqual(listedRuns, [{ id: "run_1" }, { id: "run_2" }]);
+
+    const createdRun = await evalMethods.createEvalRun.call(clientContext, {
+      payload: {
+        eval_id: "eval_1",
+        data_source: {
+          type: "jsonl",
+          source: { type: "file_id", id: "file_1" },
+        },
+      },
+    });
+    assert.deepEqual(createdRun, { id: "run_new", eval_id: "eval_1" });
+
+    const fetchedRun = await evalMethods.getEvalRun.call(clientContext, {
+      payload: { eval_id: "eval_1", run_id: "run_1" },
+    });
+    assert.deepEqual(fetchedRun, { id: "run_1" });
+
+    const cancelledRun = await evalMethods.cancelEvalRun.call(clientContext, {
+      payload: { eval_id: "eval_1", run_id: "run_1" },
+    });
+    assert.deepEqual(cancelledRun, { id: "run_1", status: "cancelled" });
+
+    const deletedRun = await evalMethods.deleteEvalRun.call(clientContext, {
+      payload: { eval_id: "eval_1", run_id: "run_1" },
+    });
+    assert.deepEqual(deletedRun, { id: "run_1", deleted: true });
+
+    const listedOutputItems = await evalMethods.listEvalRunOutputItems.call(clientContext, {
+      payload: { eval_id: "eval_1", run_id: "run_1", limit: 1 },
+    });
+    assert.deepEqual(listedOutputItems, [{ id: "out_1" }, { id: "out_2" }]);
+
+    const fetchedOutputItem = await evalMethods.getEvalRunOutputItem.call(clientContext, {
+      payload: { eval_id: "eval_1", run_id: "run_1", output_item_id: "out_1" },
+    });
+    assert.deepEqual(fetchedOutputItem, { id: "out_1" });
+
+    delete require.cache[modulePath];
+  });
+
+  const evalCalls = calls.filter((entry) => entry.method !== "ctor");
+  assert.deepEqual(evalCalls, [
+    {
+      method: "evals.list",
+      options: { order: "desc", limit: 2 },
+    },
+    {
+      method: "evals.create",
+      body: {
+        name: "Support quality eval",
+        data_source_config: { type: "custom", schema: { type: "object" } },
+        testing_criteria: [],
+      },
+    },
+    {
+      method: "evals.retrieve",
+      evalId: "eval_1",
+      options: {},
+    },
+    {
+      method: "evals.update",
+      evalId: "eval_1",
+      body: { name: "Updated eval" },
+    },
+    {
+      method: "evals.delete",
+      evalId: "eval_1",
+      options: {},
+    },
+    {
+      method: "evals.runs.list",
+      evalId: "eval_1",
+      options: { limit: 2 },
+    },
+    {
+      method: "evals.runs.create",
+      evalId: "eval_1",
+      body: {
+        data_source: {
+          type: "jsonl",
+          source: { type: "file_id", id: "file_1" },
+        },
+      },
+    },
+    {
+      method: "evals.runs.retrieve",
+      runId: "run_1",
+      options: { eval_id: "eval_1" },
+    },
+    {
+      method: "evals.runs.cancel",
+      runId: "run_1",
+      options: { eval_id: "eval_1" },
+    },
+    {
+      method: "evals.runs.delete",
+      runId: "run_1",
+      options: { eval_id: "eval_1" },
+    },
+    {
+      method: "evals.runs.outputItems.list",
+      runId: "run_1",
+      options: { eval_id: "eval_1", limit: 1 },
+    },
+    {
+      method: "evals.runs.outputItems.retrieve",
+      outputItemId: "out_1",
+      options: { eval_id: "eval_1", run_id: "run_1" },
+    },
+  ]);
+});
+
+test("videos methods map to OpenAI SDK videos endpoints", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.videos = {
+        create: async (body) => {
+          calls.push({ method: "videos.create", body });
+          return { id: "video_new" };
+        },
+        retrieve: async (videoId, options) => {
+          calls.push({ method: "videos.retrieve", videoId, options });
+          return { id: videoId };
+        },
+        list: async (options) => {
+          calls.push({ method: "videos.list", options });
+          return { data: [{ id: "video_1" }, { id: "video_2" }] };
+        },
+        delete: async (videoId, options) => {
+          calls.push({ method: "videos.delete", videoId, options });
+          return { id: videoId, deleted: true };
+        },
+        downloadContent: async (videoId, query) => {
+          calls.push({ method: "videos.downloadContent", videoId, query });
+          return { binary: true };
+        },
+        remix: async (videoId, body) => {
+          calls.push({ method: "videos.remix", videoId, body });
+          return { id: "video_remix" };
+        },
+      };
+    }
+  }
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/videos/methods.js");
+    delete require.cache[modulePath];
+    const videoMethods = require("../src/videos/methods.js");
+
+    const clientContext = { clientParams: { apiKey: "sk-test" } };
+
+    const listedVideos = await videoMethods.listVideos.call(clientContext, {
+      payload: { order: "desc", limit: 1 },
+    });
+    assert.deepEqual(listedVideos, [{ id: "video_1" }, { id: "video_2" }]);
+
+    const createdVideo = await videoMethods.createVideo.call(clientContext, {
+      payload: { prompt: "A sunrise over mountains", model: "sora-2" },
+    });
+    assert.deepEqual(createdVideo, { id: "video_new" });
+
+    const fetchedVideo = await videoMethods.getVideo.call(clientContext, {
+      payload: { video_id: "video_1" },
+    });
+    assert.deepEqual(fetchedVideo, { id: "video_1" });
+
+    const deletedVideo = await videoMethods.deleteVideo.call(clientContext, {
+      payload: { video_id: "video_1" },
+    });
+    assert.deepEqual(deletedVideo, { id: "video_1", deleted: true });
+
+    const downloaded = await videoMethods.downloadVideoContent.call(clientContext, {
+      payload: { video_id: "video_1", variant: "thumbnail" },
+    });
+    assert.deepEqual(downloaded, { binary: true });
+
+    const remixed = await videoMethods.remixVideo.call(clientContext, {
+      payload: { video_id: "video_1", prompt: "Make it cinematic" },
+    });
+    assert.deepEqual(remixed, { id: "video_remix" });
+
+    delete require.cache[modulePath];
+  });
+
+  const videoCalls = calls.filter((entry) => entry.method !== "ctor");
+  assert.deepEqual(videoCalls, [
+    {
+      method: "videos.list",
+      options: { order: "desc", limit: 1 },
+    },
+    {
+      method: "videos.create",
+      body: { prompt: "A sunrise over mountains", model: "sora-2" },
+    },
+    {
+      method: "videos.retrieve",
+      videoId: "video_1",
+      options: {},
+    },
+    {
+      method: "videos.delete",
+      videoId: "video_1",
+      options: {},
+    },
+    {
+      method: "videos.downloadContent",
+      videoId: "video_1",
+      query: { variant: "thumbnail" },
+    },
+    {
+      method: "videos.remix",
+      videoId: "video_1",
+      body: { prompt: "Make it cinematic" },
+    },
+  ]);
+});
+
+test("realtime methods map to OpenAI SDK realtime endpoints", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.realtime = {
+        clientSecrets: {
+          create: async (body) => {
+            calls.push({ method: "realtime.clientSecrets.create", body });
+            return { client_secret: { value: "rt_secret_1", expires_at: 123 } };
+          },
+        },
+        calls: {
+          accept: async (callId, body) => {
+            calls.push({ method: "realtime.calls.accept", callId, body });
+          },
+          hangup: async (callId, options) => {
+            calls.push({ method: "realtime.calls.hangup", callId, options });
+          },
+          refer: async (callId, body) => {
+            calls.push({ method: "realtime.calls.refer", callId, body });
+          },
+          reject: async (callId, body) => {
+            calls.push({ method: "realtime.calls.reject", callId, body });
+          },
+        },
+      };
+    }
+  }
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/realtime/methods.js");
+    delete require.cache[modulePath];
+    const realtimeMethods = require("../src/realtime/methods.js");
+
+    const clientContext = { clientParams: { apiKey: "sk-test" } };
+
+    const secret = await realtimeMethods.createRealtimeClientSecret.call(clientContext, {
+      payload: { model: "gpt-realtime" },
+    });
+    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" },
+    });
+    assert.deepEqual(accepted, { call_id: "call_1", status: "accepted" });
+
+    const hungUp = await realtimeMethods.hangupRealtimeCall.call(clientContext, {
+      payload: { call_id: "call_1" },
+    });
+    assert.deepEqual(hungUp, { call_id: "call_1", status: "hung_up" });
+
+    const referred = await realtimeMethods.referRealtimeCall.call(clientContext, {
+      payload: { call_id: "call_1", target_uri: "tel:+14155550123" },
+    });
+    assert.deepEqual(referred, { call_id: "call_1", status: "referred" });
+
+    const rejected = await realtimeMethods.rejectRealtimeCall.call(clientContext, {
+      payload: { call_id: "call_2", status_code: 486 },
+    });
+    assert.deepEqual(rejected, { call_id: "call_2", status: "rejected" });
+
+    delete require.cache[modulePath];
+  });
+
+  const realtimeCalls = calls.filter((entry) => entry.method !== "ctor");
+  assert.deepEqual(realtimeCalls, [
+    {
+      method: "realtime.clientSecrets.create",
+      body: { model: "gpt-realtime" },
+    },
+    {
+      method: "realtime.calls.accept",
+      callId: "call_1",
+      body: { type: "realtime", model: "gpt-realtime" },
+    },
+    {
+      method: "realtime.calls.hangup",
+      callId: "call_1",
+      options: {},
+    },
+    {
+      method: "realtime.calls.refer",
+      callId: "call_1",
+      body: { target_uri: "tel:+14155550123" },
+    },
+    {
+      method: "realtime.calls.reject",
+      callId: "call_2",
+      body: { status_code: 486 },
+    },
+  ]);
+});
+
+test("webhooks methods map to OpenAI SDK webhooks utilities", async () => {
+  const calls = [];
+
+  class FakeOpenAI {
+    constructor(clientParams) {
+      calls.push({ method: "ctor", clientParams });
+      this.webhooks = {
+        unwrap: async (payload, headers, secret, tolerance) => {
+          calls.push({
+            method: "webhooks.unwrap",
+            payload,
+            headers,
+            secret,
+            tolerance,
+          });
+          return { id: "evt_1", type: "response.completed" };
+        },
+        verifySignature: async (payload, headers, secret, tolerance) => {
+          calls.push({
+            method: "webhooks.verifySignature",
+            payload,
+            headers,
+            secret,
+            tolerance,
+          });
+        },
+      };
+    }
+  }
+
+  await withMockedOpenAI(FakeOpenAI, async () => {
+    const modulePath = require.resolve("../src/webhooks/methods.js");
+    delete require.cache[modulePath];
+    const webhookMethods = require("../src/webhooks/methods.js");
+
+    const clientContext = { clientParams: { apiKey: "sk-test" } };
+
+    const event = await webhookMethods.unwrapWebhookEvent.call(clientContext, {
+      payload: {
+        payload: "{\"id\":\"evt_1\"}",
+        headers: {
+          "webhook-id": "wh_1",
+          "webhook-signature": "v1,abc",
+          "webhook-timestamp": "123",
+        },
+        secret: "whsec_test",
+        tolerance: 30,
+      },
+    });
+    assert.deepEqual(event, { id: "evt_1", type: "response.completed" });
+
+    const verified = await webhookMethods.verifyWebhookSignature.call(clientContext, {
+      payload: {
+        payload: "{\"id\":\"evt_1\"}",
+        headers: {
+          "webhook-id": "wh_1",
+          "webhook-signature": "v1,abc",
+          "webhook-timestamp": "123",
+        },
+        secret: "whsec_test",
+        tolerance: 30,
+      },
+    });
+    assert.deepEqual(verified, { verified: true });
+
+    delete require.cache[modulePath];
+  });
+
+  const webhookCalls = calls.filter((entry) => entry.method !== "ctor");
+  assert.deepEqual(webhookCalls, [
+    {
+      method: "webhooks.unwrap",
+      payload: "{\"id\":\"evt_1\"}",
+      headers: {
+        "webhook-id": "wh_1",
+        "webhook-signature": "v1,abc",
+        "webhook-timestamp": "123",
+      },
+      secret: "whsec_test",
+      tolerance: 30,
+    },
+    {
+      method: "webhooks.verifySignature",
+      payload: "{\"id\":\"evt_1\"}",
+      headers: {
+        "webhook-id": "wh_1",
+        "webhook-signature": "v1,abc",
+        "webhook-timestamp": "123",
+      },
+      secret: "whsec_test",
+      tolerance: 30,
+    },
+  ]);
+});
+
+test("OpenaiApi prototype exposes latest methods", () => {
+  const OpenaiApi = require("../src/lib.js");
+  const client = new OpenaiApi("sk-test", "https://api.openai.com/v1", null);
+
+  assert.equal(typeof client.cancelModelResponse, "function");
+  assert.equal(typeof client.compactModelResponse, "function");
+  assert.equal(typeof client.countInputTokens, "function");
+  assert.equal(typeof client.createConversation, "function");
+  assert.equal(typeof client.listConversationItems, "function");
+  assert.equal(typeof client.createEval, "function");
+  assert.equal(typeof client.listEvalRunOutputItems, "function");
+  assert.equal(typeof client.createRealtimeClientSecret, "function");
+  assert.equal(typeof client.listSkills, "function");
+  assert.equal(typeof client.getSkillVersionContent, "function");
+  assert.equal(typeof client.createVideo, "function");
+  assert.equal(typeof client.verifyWebhookSignature, "function");
+});
+
+test("editor templates and locale expose latest methods", () => {
+  const responsesTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "responses", "template.html"),
+    "utf8"
+  );
+  const conversationsTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "conversations", "template.html"),
+    "utf8"
+  );
+  const skillsTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "skills", "template.html"),
+    "utf8"
+  );
+  const evalsTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "evals", "template.html"),
+    "utf8"
+  );
+  const realtimeTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "realtime", "template.html"),
+    "utf8"
+  );
+  const videosTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "videos", "template.html"),
+    "utf8"
+  );
+  const webhooksTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "webhooks", "template.html"),
+    "utf8"
+  );
+  const nodeTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "src", "node.html"),
+    "utf8"
+  );
+  const responsesHelp = fs.readFileSync(
+    path.join(__dirname, "..", "src", "responses", "help.html"),
+    "utf8"
+  );
+  const skillsHelp = fs.readFileSync(
+    path.join(__dirname, "..", "src", "skills", "help.html"),
+    "utf8"
+  );
+  const evalsHelp = fs.readFileSync(
+    path.join(__dirname, "..", "src", "evals", "help.html"),
+    "utf8"
+  );
+  const realtimeHelp = fs.readFileSync(
+    path.join(__dirname, "..", "src", "realtime", "help.html"),
+    "utf8"
+  );
+  const videosHelp = fs.readFileSync(
+    path.join(__dirname, "..", "src", "videos", "help.html"),
+    "utf8"
+  );
+  const webhooksHelp = fs.readFileSync(
+    path.join(__dirname, "..", "src", "webhooks", "help.html"),
+    "utf8"
+  );
+  const locale = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "..", "locales", "en-US", "node.json"), "utf8")
+  );
+
+  assert.match(responsesTemplate, /value="cancelModelResponse"/);
+  assert.match(responsesTemplate, /value="compactModelResponse"/);
+  assert.match(responsesTemplate, /value="countInputTokens"/);
+  assert.match(conversationsTemplate, /value="createConversation"/);
+  assert.match(conversationsTemplate, /value="listConversationItems"/);
+  assert.match(skillsTemplate, /value="listSkills"/);
+  assert.match(skillsTemplate, /value="getSkillVersionContent"/);
+  assert.match(evalsTemplate, /value="createEval"/);
+  assert.match(evalsTemplate, /value="listEvalRunOutputItems"/);
+  assert.match(realtimeTemplate, /value="createRealtimeClientSecret"/);
+  assert.match(realtimeTemplate, /value="rejectRealtimeCall"/);
+  assert.match(videosTemplate, /value="downloadVideoContent"/);
+  assert.match(webhooksTemplate, /value="verifyWebhookSignature"/);
+  assert.match(nodeTemplate, /@@include\('\.\/conversations\/template\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/conversations\/help\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/evals\/template\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/evals\/help\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/realtime\/template\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/realtime\/help\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/skills\/template\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/skills\/help\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/videos\/template\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/videos\/help\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/webhooks\/template\.html'\)/);
+  assert.match(nodeTemplate, /@@include\('\.\/webhooks\/help\.html'\)/);
+  assert.match(responsesHelp, /⋙ Count Input Tokens/);
+  assert.match(responsesHelp, /Default is <code>desc<\/code>/);
+  assert.match(evalsHelp, /⋙ Create Eval/);
+  assert.match(evalsHelp, /⋙ List Eval Run Output Items/);
+  assert.match(realtimeHelp, /⋙ Create Realtime Client Secret/);
+  assert.match(realtimeHelp, /⋙ Reject Realtime Call/);
+  assert.match(skillsHelp, /⋙ Create Skill/);
+  assert.match(skillsHelp, /⋙ List Skill Versions/);
+  assert.match(videosHelp, /⋙ Download Video Content/);
+  assert.match(webhooksHelp, /⋙ Verify Webhook Signature/);
+
+  assert.equal(
+    locale.OpenaiApi.parameters.cancelModelResponse,
+    "cancel model response"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.countInputTokens,
+    "count input tokens"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.createConversation,
+    "create conversation"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.listSkills,
+    "list skills"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.getSkillVersion,
+    "retrieve skill version"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.createEvalRun,
+    "create eval run"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.acceptRealtimeCall,
+    "accept realtime call"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.downloadVideoContent,
+    "download video content"
+  );
+  assert.equal(
+    locale.OpenaiApi.parameters.verifyWebhookSignature,
+    "verify webhook signature"
+  );
+});