OpenAI TS/JS SDK

Use the official OpenAI TypeScript/JavaScript SDK with Eden AI for seamless multi-provider access.

Overview

The OpenAI TypeScript SDK works perfectly with Eden AI’s V3 API. Configure the base URL and start using 500+ models from multiple providers.

Installation

Install the OpenAI SDK for Node.js:

npm install openai

Quick Start

Configure the client to use Eden AI:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'YOUR_EDEN_AI_API_KEY',
  baseURL: 'https://api.edenai.run/v3',
});

async function main() {
  const stream = await client.chat.completions.create({
    model: 'openai/gpt-4',
    messages: [{ role: 'user', content: 'Hello! How are you?' }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }
}

main();

Available Models

Access models from multiple providers:

OpenAI

openai/gpt-4
openai/gpt-4-turbo
openai/gpt-4o
openai/gpt-3.5-turbo

Anthropic

anthropic/claude-sonnet-4-5
anthropic/claude-opus-4-5
anthropic/claude-sonnet-4-5

Google

google/gemini-2.5-pro
google/gemini-2.5-flash

Cohere & Meta

cohere/command-r-plus
meta/llama-3-70b

Multi-Turn Conversations

Build stateful chat applications:

import OpenAI from 'openai';
import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions';

const client = new OpenAI({
  apiKey: process.env.EDEN_AI_API_KEY!,
  baseURL: 'https://api.edenai.run/v3',
});

async function chat() {
  const messages: ChatCompletionMessageParam[] = [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is the capital of France?' },
  ];

  // First interaction
  const stream1 = await client.chat.completions.create({
    model: 'anthropic/claude-sonnet-4-5',
    messages,
    stream: true,
  });

  let assistantResponse = '';
  for await (const chunk of stream1) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
      assistantResponse += content;
    }
  }

  // Add to conversation history
  messages.push({ role: 'assistant', content: assistantResponse });
  messages.push({ role: 'user', content: "What's the population?" });

  // Continue conversation
  const stream2 = await client.chat.completions.create({
    model: 'anthropic/claude-sonnet-4-5',
    messages,
    stream: true,
  });

  for await (const chunk of stream2) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }
}

chat();

Advanced Parameters

Control model behavior:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.EDEN_AI_API_KEY!,
  baseURL: 'https://api.edenai.run/v3',
});

const stream = await client.chat.completions.create({
  model: 'openai/gpt-4',
  messages: [
    { role: 'user', content: 'Write a creative story about AI.' },
  ],
  temperature: 0.9,        // Higher = more creative (0-2)
  max_tokens: 500,         // Limit response length
  top_p: 1.0,              // Nucleus sampling
  frequency_penalty: 0.0,  // Penalize repetition
  presence_penalty: 0.0,   // Penalize topic repetition
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) {
    process.stdout.write(content);
  }
}

Vision Capabilities

Send images to vision models:

import OpenAI from 'openai';
import FormData from 'form-data';
import fs from 'fs';
import fetch from 'node-fetch';

const client = new OpenAI({
  apiKey: process.env.EDEN_AI_API_KEY!,
  baseURL: 'https://api.edenai.run/v3',
});

async function analyzeImage() {
  // First, upload the image
  const formData = new FormData();
  formData.append('file', fs.createReadStream('image.jpg'));

  const uploadResponse = await fetch(
    'https://api.edenai.run/v3/upload',
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${process.env.EDEN_AI_API_KEY}`,
      },
      body: formData,
    }
  );

  const { file_id } = await uploadResponse.json();

  // Use file_id in chat
  const stream = await client.chat.completions.create({
    model: 'openai/gpt-4o',
    messages: [
      {
        role: 'user',
        content: [
          { type: 'text', text: "What's in this image?" },
          { type: 'file', file: { file_id } },
        ],
      },
    ],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }
}

analyzeImage();

Error Handling

Handle API errors properly:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.EDEN_AI_API_KEY!,
  baseURL: 'https://api.edenai.run/v3',
});

async function safeChat() {
  try {
    const stream = await client.chat.completions.create({
      model: 'openai/gpt-4',
      messages: [{ role: 'user', content: 'Hello!' }],
      stream: true,
    });

    for await (const chunk of stream) {
      const content = chunk.choices[0]?.delta?.content;
      if (content) {
        process.stdout.write(content);
      }
    }
  } catch (error) {
    if (error instanceof OpenAI.APIError) {
      console.error(`API Error (${error.status}):`, error.message);

      if (error.status === 401) {
        console.error('Authentication failed. Check your API key.');
      } else if (error.status === 429) {
        console.error('Rate limit exceeded. Please wait and retry.');
      } else if (error.status === 402) {
        console.error('Insufficient credits. Please add credits to your account.');
      }
    } else {
      console.error('Unexpected error:', error);
    }
  }
}

safeChat();

Express.js Integration

Build a chat API with Express:

import express from 'express';
import OpenAI from 'openai';

const app = express();
app.use(express.json());

const client = new OpenAI({
  apiKey: process.env.EDEN_AI_API_KEY!,
  baseURL: 'https://api.edenai.run/v3',
});

app.post('/api/chat', async (req, res) => {
  try {
    const { messages, model = 'openai/gpt-4' } = req.body;

    res.setHeader('Content-Type', 'text/event-stream');
    res.setHeader('Cache-Control', 'no-cache');
    res.setHeader('Connection', 'keep-alive');

    const stream = await client.chat.completions.create({
      model,
      messages,
      stream: true,
    });

    for await (const chunk of stream) {
      const content = chunk.choices[0]?.delta?.content;
      if (content) {
        res.write(`data: ${JSON.stringify({ content })}\n\n`);
      }
    }

    res.write('data: [DONE]\n\n');
    res.end();
  } catch (error) {
    console.error('Error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

React Integration

Stream responses in a React application:

import { useState } from 'react';

export function ChatComponent() {
  const [messages, setMessages] = useState<Array<{role: string, content: string}>>([]);
  const [input, setInput] = useState('');
  const [streaming, setStreaming] = useState(false);

  const sendMessage = async () => {
    if (!input.trim()) return;

    const userMessage = { role: 'user', content: input };
    const updatedMessages = [...messages, userMessage];
    setMessages(updatedMessages);
    setInput('');
    setStreaming(true);

    try {
      const response = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          messages: updatedMessages,
          model: 'anthropic/claude-sonnet-4-5',
        }),
      });

      const reader = response.body?.getReader();
      const decoder = new TextDecoder();
      let assistantMessage = '';

      if (reader) {
        while (true) {
          const { done, value } = await reader.read();
          if (done) break;

          const chunk = decoder.decode(value);
          const lines = chunk.split('\n');

          for (const line of lines) {
            if (line.startsWith('data: ')) {
              const data = line.slice(6);
              if (data === '[DONE]') continue;

              try {
                const parsed = JSON.parse(data);
                assistantMessage += parsed.content;
                setMessages([
                  ...updatedMessages,
                  { role: 'assistant', content: assistantMessage },
                ]);
              } catch (e) {
                // Ignore parse errors
              }
            }
          }
        }
      }
    } catch (error) {
      console.error('Error:', error);
    } finally {
      setStreaming(false);
    }
  };

  return (
    <div>
      <div className="messages">
        {messages.map((msg, i) => (
          <div key={i} className={msg.role}>
            <strong>{msg.role}:</strong> {msg.content}
          </div>
        ))}
      </div>
      <input
        value={input}
        onChange={(e) => setInput(e.target.value)}
        onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
        disabled={streaming}
      />
      <button onClick={sendMessage} disabled={streaming}>
        {streaming ? 'Sending...' : 'Send'}
      </button>
    </div>
  );
}

Environment Variables

Use .env files for configuration:

EDEN_AI_API_KEY=your_api_key_here

Complete Chat CLI Example

Build a command-line chat interface:

import OpenAI from 'openai';
import readline from 'readline';
import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions';

const client = new OpenAI({
  apiKey: process.env.EDEN_AI_API_KEY!,
  baseURL: 'https://api.edenai.run/v3',
});

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

async function main() {
  const messages: ChatCompletionMessageParam[] = [
    { role: 'system', content: 'You are a helpful assistant.' },
  ];

  console.log('Chat with AI (type "quit" to exit)');
  console.log('-'.repeat(50));

  const askQuestion = () => {
    rl.question('\nYou: ', async (input) => {
      const userInput = input.trim();

      if (userInput.toLowerCase() === 'quit') {
        rl.close();
        return;
      }

      if (!userInput) {
        askQuestion();
        return;
      }

      messages.push({ role: 'user', content: userInput });

      process.stdout.write('\nAssistant: ');

      try {
        const stream = await client.chat.completions.create({
          model: 'anthropic/claude-sonnet-4-5',
          messages,
          temperature: 0.7,
          stream: true,
        });

        let assistantResponse = '';

        for await (const chunk of stream) {
          const content = chunk.choices[0]?.delta?.content;
          if (content) {
            process.stdout.write(content);
            assistantResponse += content;
          }
        }

        console.log(); // New line
        messages.push({ role: 'assistant', content: assistantResponse });
      } catch (error) {
        console.error('\nError:', error);
      }

      askQuestion();
    });
  };

  askQuestion();
}

main();

List Available Models

Programmatically discover models:

import fetch from 'node-fetch';

async function listModels() {
  const response = await fetch('https://api.edenai.run/v3/models', {
    headers: {
      Authorization: `Bearer ${process.env.EDEN_AI_API_KEY}`,
    },
  });

  const data = await response.json();

  // Group by provider
  const providers: Record<string, string[]> = {};

  for (const model of data.data) {
    const provider = model.owned_by;
    if (!providers[provider]) {
      providers[provider] = [];
    }
    providers[provider].push(model.id);
  }

  console.log('Available Models:\n');
  for (const [provider, models] of Object.entries(providers)) {
    console.log(`${provider}:`);
    models.forEach(m => console.log(`  - ${m}`));
    console.log();
  }
}

listModels();

Next Steps

File Attachments - Working with images and documents
Streaming Responses - Handle Server-Sent Events

V3 Documentation

Quick Start

Overview

LLMs

Expert Models

General

Data Governance

Integrations

Overview

Installation

Quick Start

Available Models

OpenAI

Anthropic

Google

Cohere & Meta

Multi-Turn Conversations

Advanced Parameters

Vision Capabilities

Error Handling

Express.js Integration

React Integration

Environment Variables

Complete Chat CLI Example

List Available Models

Next Steps

V3 Documentation

Quick Start

Overview

LLMs

Expert Models

General

Data Governance

Integrations

Documentation Index

​Overview

​Installation

​Quick Start

​Available Models

​OpenAI

​Anthropic

​Google

​Cohere & Meta

​Multi-Turn Conversations

​Advanced Parameters

​Vision Capabilities

​Error Handling

​Express.js Integration

​React Integration

​Environment Variables

​Complete Chat CLI Example

​List Available Models

​Next Steps

Overview

Installation

Quick Start

Available Models

OpenAI

Anthropic

Google

Cohere & Meta

Multi-Turn Conversations

Advanced Parameters

Vision Capabilities

Error Handling

Express.js Integration

React Integration

Environment Variables

Complete Chat CLI Example

List Available Models

Next Steps