Provides basic status information about the router service. Useful for health checks. No authentication required.

Retrieves a list of currently available models accessible through this router, including their IDs, descriptions, and ownership information. Useful for discovering capabilities and selecting appropriate models for requests. Includes aliases like viable-1, viable-2, and viable-3 as well as direct model access (e.g., gpt-4.1, gpt-4o, gemini-2.0-flash).

A more detailed and visually organized list is also available at the Model Catalog.

Generates a standard response from an LLM based on a provided conversation history. This endpoint is designed to be compatible with the OpenAI /v1/chat/completions API format.

Quick Start (Migrating from OpenAI API): Migrating your existing OpenAI API calls to use our service is straightforward:

1. Change the API Endpoint URL: Update the request URL from https://api.openai.com/v1/chat/completions to https://api.viablelab.org/v1/chat/completions.
2. Remove Client-Side Auth: Crucially, remove the Authorization: Bearer YOUR_OPENAI_KEY header from your client-side request. Our API handles authentication securely on the server-side. This improves security by preventing your API key from being exposed in frontend code or network requests.
3. Check Model: Ensure the model ID specified in your request body (e.g., {"model": "gpt-4o-mini", ...}) is available in our service. Check the current model list for supported IDs and aliases (like viable-1, viable-2, viable-3).
4. Keep Request Body: Your existing OpenAI-compatible JSON request body (with messages, model, etc.) remains the same.

That's it! Enjoy easy migration and potentially enhanced security practices.

Authentication: (Reminder: Bearer Token authentication is planned but not currently enforced. Access currently relies on temporary Origin/Referer checks via CORS middleware for browser requests.)

Model Selection:

• Use the model field to specify a model ID or alias (e.g., viable-3, gpt-4o-mini). See the /v1/models endpoint or the Model Catalog for available options.
• If model is omitted, the default model (currently gpt-4.1-nano) is used.
• Requesting an unsupported model will result in a 400 Bad Request error.

Image Input (Multimodal): For models that support image input (e.g., viable-1, gpt-4o-mini), you can provide images via URLs within the messages array. Structure the content field of a message as an array containing objects with type: 'text' and type: 'image_url' as shown in the example below. Only image_url is currently supported (not base64 data).

Streaming: Streaming (stream: true) is currently not supported. Requests with stream: true may result in an error or unexpected behavior.

Generates an LLM response based on conversation history, similar to /v1/chat/completions, but includes a simplified internal vetting layer to ensure responses adhere to basic guidelines.

Purpose: Provides an easy way to get generally safer or guided responses without needing the full configuration of the /v1/vetting/full endpoint. Ideal for quickly adding basic content filtering or adherence to simple pedagogical rules.

Interface: Designed for easy adoption, acting as a near drop-in replacement for standard chat completion requests.

Quick Start:

• Already using https://api.viablelab.org/v1/chat/completions?
  • Simply change the request URL to https://api.viablelab.org/v1/chat/vetting.
  • Your existing request body (messages, model, etc.) will work.
  • The response format is identical to /v1/chat/completions, but includes an additional vetting_info object at the top level, showing the internal attemptCount and stopReason. The main choices[0].message.content is the vetted, ready-to-use response.
• Migrating from OpenAI API?
  • Change the API endpoint URL to https://api.viablelab.org/v1/chat/vetting.
  • Ensure the model field in your request body specifies a model ID supported by our service (see available models).
  • That's it! You get the benefits of basic vetting with minimal changes.

Basic Vetting (Default): If you make no changes other than the URL, a default safety/guidance prompt is applied internally (e.g., "Ensure the response is helpful, harmless... guide the user, don't give direct answers to homework...").

Vetting Customization (Optional):

• To tailor the filtering, include an optional vettingConfig object in your request body:
  • vettingConfig.systemPrompt: Provide a concise guideline string (e.g., "Do not provide code directly, only explain the concepts.", "Adapt response for a 5th-grade reading level.", "Focus answers on the subject of biology.").
  • vettingConfig.maxAttempts: Optionally adjust the internal retry limit (default is 3).
• If vettingConfig.systemPrompt is omitted, the default guideline is used.

Image Input (Multimodal): Similar to /v1/chat/completions, you can provide image URLs in the messages.content array for models that support it. The vetting layer currently operates primarily on the text content.

Output: Returns a standard OpenAI Chat Completion response object, plus a top-level vetting_info object containing:

• attemptCount: The number of internal vetting attempts made.
• stopReason: Why the internal vetting loop stopped (e.g., VERIFICATION_PASSED, MAX_ATTEMPTS_REACHED).

Model Selection: Uses the model field like /v1/chat/completions. A default verification model (gpt-4o-mini) is used internally for the vetting step.

Streaming: Not supported.

Generates audio from the input text using a Text-to-Speech (TTS) model (also known as Text to speech).

This endpoint is based on OpenAI's TTS API and currently routes requests to their service.

Use Cases:

• Narrate a written blog post
• Produce spoken audio in multiple languages
• Give realtime audio output using streaming (Note: Streaming via this endpoint might depend on client handling, the API itself returns the full audio currently)

Important: OpenAI usage policies require you to provide a clear disclosure to end users that the TTS voice they are hearing is AI-generated and not a human voice.

Models: gpt-4o-mini-tts, tts-1, tts-1-hd Voices: alloy, ash, ballad, coral, echo, fable, onyx, nova, sage, shimmer, verse

Quickstart Examples:

Curl:

curl https://api.viablelab.org/v1/audio/speech \
  -H "Authorization: Bearer YOUR_VIABLE_LAB_KEY_OR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ \n    "model": "gpt-4o-mini-tts", \n    "input": "The VIABLE Lab at the University of Florida advances educational research by developing AI-powered technologies that enhance learning through data-driven insights and interdisciplinary collaboration.", \n    "voice": "alloy" \n  }' \
  --output speech.mp3

Python:

# Assuming you have a client library or use requests
import requests
import shutil

api_url = "https://api.viablelab.org/v1/audio/speech"
headers = {
    # "Authorization": "Bearer YOUR_VIABLE_LAB_KEY_OR_TOKEN", # Add if auth is implemented
    "Content-Type": "application/json",
}
data = {
    "model": "gpt-4o-mini-tts",
    "input": "The VIABLE Lab at the University of Florida advances educational research by developing AI-powered technologies that enhance learning through data-driven insights and interdisciplinary collaboration.",
    "voice": "alloy"
}

speech_file_path = "speech.mp3"

response = requests.post(api_url, headers=headers, json=data, stream=True)

if response.status_code == 200:
    with open(speech_file_path, 'wb') as f:
        response.raw.decode_content = True
        shutil.copyfileobj(response.raw, f)
    print(f"Audio saved to {speech_file_path}")
else:
    print(f"Error: {response.status_code}")
    print(response.text)

JavaScript (Node.js):

import fs from 'fs';
import path from 'path';
import fetch from 'node-fetch'; // Or your preferred fetch implementation

const api_url = 'https://api.viablelab.org/v1/audio/speech';
const headers = {
    // 'Authorization': 'Bearer YOUR_VIABLE_LAB_KEY_OR_TOKEN', // Add if auth is implemented
    'Content-Type': 'application/json',
};
const body = JSON.stringify({
    model: 'gpt-4o-mini-tts',
    input: 'Today is a wonderful day to build something people love!',
    voice: 'alloy',
});

const speechFile = path.resolve('./speech.mp3');

async function main() {
  try {
    const response = await fetch(api_url, { method: 'POST', headers: headers, body: body });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const buffer = await response.arrayBuffer();
    await fs.promises.writeFile(speechFile, Buffer.from(buffer));
    console.log(`Audio saved to ${speechFile}`);
  } catch (error) {
    console.error('Error fetching or saving speech:', error);
  }
}
main();

Supported Output Formats: mp3 (default), opus, aac, flac, wav, pcm.

Transcribes audio into the input language (Speech-to-Text).

(Planned / Not Yet Implemented)

This endpoint will accept audio file uploads and return the transcribed text.

Generates an LLM response with a comprehensive verification layer designed for educational contexts, checking against specific questions and answer keys.

Use Case: Intended for scenarios requiring detailed checks, like ensuring an AI tutor doesn't reveal specific answers or key concepts defined in context.items. Provides detailed feedback on verification attempts.

Modes:

• vetting: Enables the full verification layer. Requires config.verificationModel and context.items (containing question and answerKey objects).
• chat: Standard chat completion using this endpoint's structure but without performing verification (verification config/context ignored).

Context: Requires context.items with question and answerKey when mode='vetting'.

Output: Returns a detailed response including the final message, verification status (passed, stopReason), and details of each attempt.

Streaming: Not supported.