Add nodes for the main OpenAI models (#141)

* feat(api): add OpenAI SDK dependency and environment configuration

- Add OPENAI_API_KEY to .dev.vars.example following established pattern
- Prepare infrastructure for OpenAI node implementation

* feat(api): implement OpenAI model nodes for GPT-4.1, GPT-5, GPT-5 Mini, and GPT-5 Nano

- Add GPT-4.1 node with compute cost 25
- Add GPT-5 node with compute cost 35
- Add GPT-5 Mini node with compute cost 15
- Add GPT-5 Nano node with compute cost 5
- All nodes follow established patterns with proper error handling
- Uses OpenAI SDK for chat completions API
- Supports system instructions and user input parameters

* feat(api): integrate OpenAI nodes into CloudflareNodeRegistry

- Add imports for GPT-4.1, GPT-5, GPT-5 Mini, and GPT-5 Nano nodes
- Add hasOpenAI environment check for OPENAI_API_KEY
- Register OpenAI nodes conditionally when API key is available
- Follow existing Anthropic node registration patterns
- Add OPENAI_API_KEY env var to runtime context

* test(api): add comprehensive unit tests for OpenAI nodes and fix runtime context

- Add unit tests for GPT-4.1, GPT-5, GPT-5 Mini, and GPT-5 Nano nodes
- Each test suite validates node type definitions, instantiation, and error handling
- Test coverage includes API key validation, input validation, and parameter definitions
- Fix runtime context to pass OPENAI_API_KEY to node execution environment
- All tests pass successfully, completing Phase 4 of OpenAI integration

---------

Co-authored-by: Bertil Chapuis <bchapuis@gmail.com>

Author: rmarquis

apps/api/.dev.vars.example

@@ -28,6 +28,9 @@ RESEND_DEFAULT_FROM=CHANGE_ME
 AWS_ACCESS_KEY_ID=CHANGE_ME
 AWS_SECRET_ACCESS_KEY=CHANGE_ME
 AWS_REGION=CHANGE_ME
+
 SES_DEFAULT_FROM=CHANGE_ME
 
-ANTHROPIC_API_KEY=CHANGE_ME
+OPENAI_API_KEY=CHANGE_ME
+
+ANTHROPIC_API_KEY=CHANGE_ME

apps/api/package.json

@@ -63,6 +63,7 @@
     "jose": "^6.0.10",
     "jsonpath-plus": "^10.3.0",
     "mailparser": "^3.7.2",
+    "openai": "^5.13.1",
     "resend": "^4.5.1",
     "twilio": "^5.5.2",
     "uuid": "^11.1.0",

apps/api/src/context.ts

@@ -37,6 +37,7 @@ export interface Bindings {
   AWS_SECRET_ACCESS_KEY?: string;
   AWS_REGION?: string;
   SES_DEFAULT_FROM?: string;
+  OPENAI_API_KEY?: string;
   ANTHROPIC_API_KEY?: string;
 }
 

apps/api/src/nodes/cloudflare-node-registry.ts

@@ -213,6 +213,10 @@ import { Hermes2ProMistral7BNode } from "./text/hermes-2-pro-mistral-7b-node";
 import { InputTextNode } from "./text/input-text-node";
 import { Llama318BInstructFastNode } from "./text/llama-3-1-8b-instruct-fast-node";
 import { Llama3370BInstructFastNode } from "./text/llama-3-3-70b-instruct-fp8-fast-node";
+import { Gpt41Node } from "./text/gpt-41-node";
+import { Gpt5Node } from "./text/gpt-5-node";
+import { Gpt5MiniNode } from "./text/gpt-5-mini-node";
+import { Gpt5NanoNode } from "./text/gpt-5-nano-node";
 import { GptOss120BNode } from "./text/gpt-oss-120b-node";
 import { GptOss20BNode } from "./text/gpt-oss-20b-node";
 import { Llama4Scout17B16EInstructNode } from "./text/llama-4-scout-17b-16e-instruct-node";
@@ -268,6 +272,7 @@ export class CloudflareNodeRegistry extends BaseNodeRegistry {
       this.env.AWS_REGION &&
       this.env.SES_DEFAULT_FROM
     );
+    const hasOpenAI = !!this.env.OPENAI_API_KEY;
     const hasAnthropic = !!this.env.ANTHROPIC_API_KEY;
 
     // Register all core nodes
@@ -542,6 +547,14 @@ export class CloudflareNodeRegistry extends BaseNodeRegistry {
       this.registerImplementation(WktGeometryNode);
     }
 
+    // OpenAI models
+    if (hasOpenAI) {
+      this.registerImplementation(Gpt41Node);
+      this.registerImplementation(Gpt5Node);
+      this.registerImplementation(Gpt5MiniNode);
+      this.registerImplementation(Gpt5NanoNode);
+    }
+    
     // Anthropic Claude nodes
     if (hasAnthropic) {
       this.registerImplementation(ClaudeOpus41Node);

apps/api/src/nodes/text/gpt-41-node.test.ts

@@ -0,0 +1,85 @@
+import { Node } from "@dafthunk/types";
+import { describe, expect, it } from "vitest";
+
+import { NodeContext } from "../types";
+import { Gpt41Node } from "./gpt-41-node";
+
+describe("Gpt41Node", () => {
+  const mockNode = {
+    id: "test-node",
+    type: "gpt-4.1",
+  } as Node;
+
+  it("should have correct node type definition", () => {
+    expect(Gpt41Node.nodeType).toBeDefined();
+    expect(Gpt41Node.nodeType.id).toBe("gpt-4.1");
+    expect(Gpt41Node.nodeType.name).toBe("GPT-4.1");
+    expect(Gpt41Node.nodeType.type).toBe("gpt-4.1");
+    expect(Gpt41Node.nodeType.description).toBe("Latest GPT-4 iteration with enhanced capabilities");
+    expect(Gpt41Node.nodeType.tags).toEqual(["Text", "AI"]);
+    expect(Gpt41Node.nodeType.computeCost).toBe(25);
+    expect(Gpt41Node.nodeType.inputs).toHaveLength(2);
+    expect(Gpt41Node.nodeType.outputs).toHaveLength(1);
+  });
+
+  it("should instantiate correctly", () => {
+    const node = new Gpt41Node(mockNode);
+    expect(node).toBeDefined();
+  });
+
+  it("should fail without API key", async () => {
+    const node = new Gpt41Node(mockNode);
+    const context = {
+      nodeId: "test-node",
+      workflowId: "test-workflow",
+      organizationId: "test-org",
+      inputs: { input: "Hello" },
+      env: {},
+    } as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("error");
+    expect(result.error).toBe("OPENAI_API_KEY is not configured");
+  });
+
+  it("should fail without input", async () => {
+    const node = new Gpt41Node(mockNode);
+    const context = {
+      nodeId: "test-node",
+      workflowId: "test-workflow", 
+      organizationId: "test-org",
+      inputs: {},
+      env: {
+        OPENAI_API_KEY: "test-key"
+      },
+    } as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("error");
+    expect(result.error).toBe("Input is required");
+  });
+
+  it("should have correct input parameters", () => {
+    const inputs = Gpt41Node.nodeType.inputs;
+    
+    const instructionsInput = inputs.find(input => input.name === "instructions");
+    expect(instructionsInput).toBeDefined();
+    expect(instructionsInput?.type).toBe("string");
+    expect(instructionsInput?.required).toBe(false);
+    expect(instructionsInput?.value).toBe("You are a helpful assistant.");
+
+    const inputParam = inputs.find(input => input.name === "input");
+    expect(inputParam).toBeDefined();
+    expect(inputParam?.type).toBe("string");
+    expect(inputParam?.required).toBe(true);
+  });
+
+  it("should have correct output parameters", () => {
+    const outputs = Gpt41Node.nodeType.outputs;
+    
+    const responseOutput = outputs.find(output => output.name === "response");
+    expect(responseOutput).toBeDefined();
+    expect(responseOutput?.type).toBe("string");
+    expect(responseOutput?.description).toBe("Generated text response from GPT-4.1");
+  });
+});

apps/api/src/nodes/text/gpt-41-node.ts

@@ -0,0 +1,86 @@
+import OpenAI from 'openai';
+import { NodeExecution, NodeType } from "@dafthunk/types";
+
+import { ExecutableNode } from "../types";
+import { NodeContext } from "../types";
+
+/**
+ * GPT-4.1 node implementation using the OpenAI SDK
+ * Latest GPT-4 iteration with enhanced capabilities
+ */
+export class Gpt41Node extends ExecutableNode {
+  public static readonly nodeType: NodeType = {
+    id: "gpt-4.1",
+    name: "GPT-4.1",
+    type: "gpt-4.1",
+    description: "Latest GPT-4 iteration with enhanced capabilities",
+    tags: ["Text", "AI"],
+    icon: "sparkles",
+    computeCost: 25,
+    asTool: true,
+    inputs: [
+      {
+        name: "instructions",
+        type: "string",
+        description: "System instructions for GPT-4.1's behavior",
+        required: false,
+        value: "You are a helpful assistant.",
+      },
+      {
+        name: "input",
+        type: "string",
+        description: "The input text or question for GPT-4.1",
+        required: true,
+      },
+    ],
+    outputs: [
+      {
+        name: "response",
+        type: "string",
+        description: "Generated text response from GPT-4.1",
+      },
+    ],
+  };
+
+  async execute(context: NodeContext): Promise<NodeExecution> {
+    try {
+      const { instructions, input } = context.inputs;
+
+      if (!context.env.OPENAI_API_KEY) {
+        return this.createErrorResult("OPENAI_API_KEY is not configured");
+      }
+
+      if (!input) {
+        return this.createErrorResult("Input is required");
+      }
+
+      const client = new OpenAI({
+        apiKey: context.env.OPENAI_API_KEY,
+        timeout: 60000
+      });
+
+      const completion = await client.chat.completions.create({
+        model: "gpt-4.1",
+        max_tokens: 1024,
+        messages: [
+          ...(instructions ? [{ role: "system" as const, content: instructions }] : []),
+          { role: "user" as const, content: input }
+        ]
+      });
+
+      const responseText = completion.choices[0]?.message?.content || "";
+
+      return this.createSuccessResult({
+        response: responseText,
+      });
+    } catch (error) {
+      console.error(error);
+      if (error instanceof OpenAI.APIError) {
+        return this.createErrorResult(`OpenAI API error: ${error.message}`);
+      }
+      return this.createErrorResult(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+}

apps/api/src/nodes/text/gpt-5-mini-node.test.ts

@@ -0,0 +1,85 @@
+import { Node } from "@dafthunk/types";
+import { describe, expect, it } from "vitest";
+
+import { NodeContext } from "../types";
+import { Gpt5MiniNode } from "./gpt-5-mini-node";
+
+describe("Gpt5MiniNode", () => {
+  const mockNode = {
+    id: "test-node",
+    type: "gpt-5-mini",
+  } as Node;
+
+  it("should have correct node type definition", () => {
+    expect(Gpt5MiniNode.nodeType).toBeDefined();
+    expect(Gpt5MiniNode.nodeType.id).toBe("gpt-5-mini");
+    expect(Gpt5MiniNode.nodeType.name).toBe("GPT-5 Mini");
+    expect(Gpt5MiniNode.nodeType.type).toBe("gpt-5-mini");
+    expect(Gpt5MiniNode.nodeType.description).toBe("Faster, cost-effective version of GPT-5");
+    expect(Gpt5MiniNode.nodeType.tags).toEqual(["Text", "AI"]);
+    expect(Gpt5MiniNode.nodeType.computeCost).toBe(15);
+    expect(Gpt5MiniNode.nodeType.inputs).toHaveLength(2);
+    expect(Gpt5MiniNode.nodeType.outputs).toHaveLength(1);
+  });
+
+  it("should instantiate correctly", () => {
+    const node = new Gpt5MiniNode(mockNode);
+    expect(node).toBeDefined();
+  });
+
+  it("should fail without API key", async () => {
+    const node = new Gpt5MiniNode(mockNode);
+    const context = {
+      nodeId: "test-node",
+      workflowId: "test-workflow",
+      organizationId: "test-org",
+      inputs: { input: "Hello" },
+      env: {},
+    } as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("error");
+    expect(result.error).toBe("OPENAI_API_KEY is not configured");
+  });
+
+  it("should fail without input", async () => {
+    const node = new Gpt5MiniNode(mockNode);
+    const context = {
+      nodeId: "test-node",
+      workflowId: "test-workflow", 
+      organizationId: "test-org",
+      inputs: {},
+      env: {
+        OPENAI_API_KEY: "test-key"
+      },
+    } as NodeContext;
+
+    const result = await node.execute(context);
+    expect(result.status).toBe("error");
+    expect(result.error).toBe("Input is required");
+  });
+
+  it("should have correct input parameters", () => {
+    const inputs = Gpt5MiniNode.nodeType.inputs;
+    
+    const instructionsInput = inputs.find(input => input.name === "instructions");
+    expect(instructionsInput).toBeDefined();
+    expect(instructionsInput?.type).toBe("string");
+    expect(instructionsInput?.required).toBe(false);
+    expect(instructionsInput?.value).toBe("You are a helpful assistant.");
+
+    const inputParam = inputs.find(input => input.name === "input");
+    expect(inputParam).toBeDefined();
+    expect(inputParam?.type).toBe("string");
+    expect(inputParam?.required).toBe(true);
+  });
+
+  it("should have correct output parameters", () => {
+    const outputs = Gpt5MiniNode.nodeType.outputs;
+    
+    const responseOutput = outputs.find(output => output.name === "response");
+    expect(responseOutput).toBeDefined();
+    expect(responseOutput?.type).toBe("string");
+    expect(responseOutput?.description).toBe("Generated text response from GPT-5 Mini");
+  });
+});