{
  "openapi": "3.0.3",
  "info": {
    "title": "AnyAPI API",
    "description":"Universal API Integration Platform - Connect any API to any API with intelligent data transformation and workflow orchestration.",
    "version": "1.0.0",
    "contact": {
      "name": "AnyAPI Support",
      "email": "support@anyapi.ai",
      "url": "https://anyapi.ai/support"
    },
    "license": {
      "name": "MIT",
      "url": "https://opensource.org/licenses/MIT"
    }
  },
  "servers": [
    {
      "url": "https://api.anyapi.ai/v1",
      "description": "Production server"
    }
  ],
  "security": [
    {
      "bearerAuth": []
    }
  ],
  "paths": {
    "/chat/completions": {
      "post": {
        "summary": "Create chat completion",
        "description": "Creates a model response for the given chat conversation",
        "operationId": "createChatCompletion",
        "tags": ["Text"],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateChatCompletionRequest"
              },
              "examples": {
                "Base request": {
                  "summary": "Base request",
                  "description": "Minimal request with mandatory parameters. Used for simple questions without additional settings.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Sample text goes here"
                      }
                    ]
                  }
                },
                "With a system prompt": {
                  "summary": "With a system prompt",
                  "description": "Adds a system message that sets the behavior and context for the assistant throughout the dialogue.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "system",
                        "content": "You are a helpful assistant."
                      },
                      {
                        "role": "user",
                        "content": "What is the capital of France?"
                      }
                    ]
                  }
                },
                "Multi-message conversation": {
                  "summary": "A multi-message conversation",
                  "description": "Presents a history of dialogue with multiple messages from the user and assistant for contextual communication.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "system",
                        "content": "You are a helpful assistant."
                      },
                      {
                        "role": "user",
                        "content": "What is the capital of France?"
                      },
                      {
                        "role": "assistant",
                        "content": "The capital of France is Paris."
                      },
                      {
                        "role": "user",
                        "content": "What is its population?"
                      }
                    ]
                  }
                },
                "With temperature and token settings": {
                  "summary": "With temperature and token settings",
                  "description": "Adjusting the creativity of the response (temperature), maximum length (max_tokens), and other sampling parameters to control the quality of the generation.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Write a creative story about a robot."
                      }
                    ],
                    "temperature": 0.7,
                    "max_tokens": 500,
                    "top_p": 1,
                    "frequency_penalty": 0,
                    "presence_penalty": 0
                  }
                },
                "Streaming response": {
                  "summary": "Streaming response",
                  "description": "Includes streaming response transmission (as in ChatGPT), where tokens arrive gradually rather than all at once.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Tell me a story."
                      }
                    ],
                    "stream": true
                  }
                },
                "Vision - URL": {
                  "summary": "Vision - URL",
                  "description": "Sending an image via URL for analysis using the multimodal GPT-4 Vision model.",
                  "value": {
                    "model": "google/gemini-2.5-pro",
                    "messages": [
                      {
                        "role": "user",
                        "content": [
                          {
                            "type": "text",
                            "text": "What's in this image?"
                          },
                          {
                            "type": "image_url",
                            "image_url": {
                              "url": "https://example.com/image.jpg"
                            }
                          }
                        ]
                      }
                    ],
                    "max_tokens": 300
                  }
                },
                "Vision base64": {
                  "summary": "Vision base64",
                  "description": "Sending an image in base64 format for analysis. Used when the image is not available via URL or is stored locally.",
                  "value": {
                    "model": "mistralai/pixtral-12b",
                    "messages": [
                      {
                        "role": "user",
                        "content": [
                          {
                            "type": "text",
                            "text": "Describe this image"
                          },
                          {
                            "type": "image_url",
                            "image_url": {
                              "url": "data:image/jpeg;base64,/9j/4AAQSkZJRg...",
                              "detail": "high"
                            }
                          }
                        ]
                      }
                    ]
                  }
                },
                "Function calling": {
                  "summary": "Function Calling - function definition",
                  "description": "Defining the tools (functions) that the model can call to obtain external data (e.g., weather, database).",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "What's the weather in Boston?"
                      }
                    ],
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_current_weather",
                          "description": "Get the current weather in a given location",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {
                                "type": "string",
                                "description": "The city and state, e.g. San Francisco, CA"
                              },
                              "unit": {
                                "type": "string",
                                "enum": ["celsius", "fahrenheit"]
                              }
                            },
                            "required": ["location"]
                          }
                        }
                      }
                    ],
                    "tool_choice": "auto"
                  }
                },
                "Function call response": {
                  "summary": "With a response to Function Call",
                  "description": "Continuation of the dialogue after the model has called the function - transfer of the function execution result back to the model.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "What's the weather in Boston?"
                      },
                      {
                        "role": "assistant",
                        "content": null,
                        "tool_calls": [
                          {
                            "id": "call_abc123",
                            "type": "function",
                            "function": {
                              "name": "get_current_weather",
                              "arguments": "{\"location\": \"Boston, MA\"}"
                            }
                          }
                        ]
                      },
                      {
                        "role": "tool",
                        "tool_call_id": "call_abc123",
                        "content": "{\"temperature\": 22, \"unit\": \"celsius\", \"description\": \"Sunny\"}"
                      }
                    ],
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_current_weather",
                          "description": "Get the current weather",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {"type": "string"}
                            }
                          }
                        }
                      }
                    ]
                  }
                },
                "JSON mode": {
                  "summary": "JSON Mode",
                  "description": "Forces the model to return only valid JSON. Useful for parsing structured data.",
                  "value": {
                    "model": "openai/gpt-4-turbo",
                    "messages": [
                      {
                        "role": "system",
                        "content": "You are a helpful assistant designed to output JSON."
                      },
                      {
                        "role": "user",
                        "content": "Extract the name and age from this text: 'John is 25 years old.'"
                      }
                    ],
                    "response_format": {
                      "type": "json_object"
                    }
                  }
                },
                "Structured outputs": {
                  "summary": "Structured Outputs (JSON Schema)",
                  "description": "Ensures that the response conforms to the exact JSON schema. A stricter version of JSON Mode with structure validation.",
                  "value": {
                    "model": "openai/gpt-4o-2024-08-06",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Extract user information from: 'John Doe, 30 years old, john@example.com'"
                      }
                    ],
                    "response_format": {
                      "type": "json_schema",
                      "json_schema": {
                        "name": "user_info",
                        "strict": true,
                        "schema": {
                          "type": "object",
                          "properties": {
                            "name": {"type": "string"},
                            "age": {"type": "number"},
                            "email": {"type": "string"}
                          },
                          "required": ["name", "age", "email"],
                          "additionalProperties": false
                        }
                      }
                    }
                  }
                },
                "Logprobs": {
                  "summary": "With Probability Logging (logprobs)",
                  "description": "Returns probabilities for each generated token. Useful for analyzing model confidence.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Say hello"
                      }
                    ],
                    "logprobs": true,
                    "top_logprobs": 2
                  }
                },
                "Multiple options": {
                  "summary": "With multiple options (n > 1)",
                  "description": "Generates several alternative answers to a single query. Useful for selecting the best option.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Write a tagline for an ice cream shop."
                      }
                    ],
                    "n": 3,
                    "temperature": 0.9
                  }
                },
                "Stop sequences": {
                  "summary": "Stop sequences",
                  "description": "Specifies character sequences at which generation should stop. Useful for formatting.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "List three colors:"
                      }
                    ],
                    "stop": ["\n", "4."],
                    "max_tokens": 100
                  }
                },
                "Seed reproducibility": {
                  "summary": "With seed for reproducibility",
                  "description": "Sets the seed for deterministic generation. With identical parameters, it will produce the same result.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Generate a random story."
                      }
                    ],
                    "seed": 12345,
                    "temperature": 1
                  }
                },
                "UserId": {
                  "summary": "With user ID",
                  "description": "Transmits the user ID for monitoring and preventing abuse. Helps OpenAI track violations.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Sample text goes here"
                      }
                    ],
                    "user": "user-123456"
                  }
                },
                "Parallel function calling": {
                  "summary": "Parallel Function Calling",
                  "description": "Allows the model to call multiple functions simultaneously in a single response for efficiency.",
                  "value": {
                    "model": "openai/gpt-4-turbo",
                    "messages": [
                      {
                        "role": "user",
                        "content": "What's the weather in Boston and New York?"
                      }
                    ],
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_current_weather",
                          "description": "Get weather",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {"type": "string"}
                            },
                            "required": ["location"]
                          }
                        }
                      }
                    ],
                    "parallel_tool_calls": true
                  }
                },
                "o1 models": {
                  "summary": "O1 models (reasoning)",
                  "description": "Using O1 models with advanced reasoning capabilities for complex tasks (mathematics, logic).",
                  "value": {
                    "model": "openai/o1",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Solve this complex math problem: Find the integral of x^2 * e^x dx"
                      }
                    ],
                    "max_completion_tokens": 5000
                  }
                },
                "Audio input (base)": {
                  "summary": "Audio input (base)",
                  "description": "Sending audio to a model for transcription or voice analysis. Audio is encoded in base64.",
                  "value": {
                    "model": "google/gemini-2.5-pro",
                    "modalities": ["text", "audio"],
                    "audio": {
                      "voice": "alloy",
                      "format": "wav"
                    },
                    "messages": [
                      {
                        "role": "user",
                        "content": [
                          {
                            "type": "input_audio",
                            "input_audio": {
                              "data": "base64_encoded_audio_data_here...",
                              "format": "wav"
                            }
                          }
                        ]
                      }
                    ]
                  }
                },
                "Audio input + text": {
                  "summary": "Audio input + text",
                  "description": "A combination of text and audio in a single message for multimodal interaction.",
                  "value": {
                    "model": "google/gemini-2.5-pro",
                    "modalities": ["text", "audio"],
                    "audio": {
                      "voice": "echo",
                      "format": "mp3"
                    },
                    "messages": [
                      {
                        "role": "user",
                        "content": [
                          {
                            "type": "text",
                            "text": "Please transcribe and summarize this audio:"
                          },
                          {
                            "type": "input_audio",
                            "input_audio": {
                              "data": "base64_encoded_audio...",
                              "format": "mp3"
                            }
                          }
                        ]
                      }
                    ]
                  }
                },
                "Stream option": {
                  "summary": "Stream Options",
                  "description": "Additional options for streaming mode, such as enabling token usage information.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Hello"
                      }
                    ],
                    "stream": true,
                    "stream_options": {
                      "include_usage": true
                    }
                  }
                },
                "Logit bias": {
                  "summary": "Logit Bias",
                  "description": "Changes the probability of certain tokens appearing. Positive values increase it, negative values decrease it.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Write a sentence"
                      }
                    ],
                    "logit_bias": {
                      "50256": -100,
                      "13": 10
                    }
                  }
                },
                "Multiple images": {
                  "summary": "Multiple images in one post",
                  "description": "Sending multiple images simultaneously for comparison or comprehensive analysis.",
                  "value": {
                    "model": "google/gemini-2.5-pro",
                    "messages": [
                      {
                        "role": "user",
                        "content": [
                          {
                            "type": "text",
                            "text": "Compare these images:"
                          },
                          {
                            "type": "image_url",
                            "image_url": {"url": "https://example.com/image1.jpg"}
                          },
                          {
                            "type": "image_url",
                            "image_url": {"url": "https://example.com/image2.jpg"}
                          },
                          {
                            "type": "image_url",
                            "image_url": {"url": "https://example.com/image3.jpg"}
                          }
                        ]
                      }
                    ],
                    "max_tokens": 500
                  }
                },
                "Image detail level": {
                  "summary": "Image detail level",
                  "description": "Control the level of detail in image analysis. 'high' - detailed analysis, 'low' - quick overview.",
                  "value": {
                    "model": "google/gemini-2.5-pro",
                    "messages": [
                      {
                        "role": "user",
                        "content": [
                          {
                            "type": "text",
                            "text": "Analyze in detail"
                          },
                          {
                            "type": "image_url",
                            "image_url": {
                              "url": "https://example.com/image.jpg",
                              "detail": "high"
                            }
                          }
                        ]
                      }
                    ]
                  }
                },
                "Tool choice (specific)": {
                  "summary": "Tool Choice - Specific Function",
                  "description": "Forced invocation of a specific function instead of automatic selection by the model.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "What's the weather?"
                      }
                    ],
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_weather",
                          "description": "Get weather",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {"type": "string"}
                            }
                          }
                        }
                      }
                    ],
                    "tool_choice": {
                      "type": "function",
                      "function": {
                        "name": "get_weather"
                      }
                    }
                  }
                },
                "Tool choice": {
                  "summary": "Tool Choice - none",
                  "description": "Prohibition of using tools. The model must respond only with text, even if functions are defined.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "What's the weather in Paris?"
                      }
                    ],
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_weather",
                          "description": "Get weather",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {"type": "string"}
                            }
                          }
                        }
                      }
                    ],
                    "tool_choice": "none"
                  }
                },
                "Tool choice (required)": {
                  "summary": "Tool Choice - required",
                  "description": "Requires the mandatory use of at least one tool. The model cannot respond with text alone.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "What's the weather in Paris?"
                      }
                    ],
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_weather",
                          "description": "Get weather",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {"type": "string"}
                            }
                          }
                        }
                      }
                    ],
                    "tool_choice": "required"
                  }
                },
                "Multi-user chats": {
                  "summary": "Name in messages (multi-user chats)",
                  "description": "Specifying the sender's name for group chats or dialogues with multiple users.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "system",
                        "content": "You are in a group chat"
                      },
                      {
                        "role": "user",
                        "name": "Alice",
                        "content": "Hello everyone!"
                      },
                      {
                        "role": "user",
                        "name": "Bob",
                        "content": "Hi Alice!"
                      }
                    ]
                  }
                },
                "Metadata": {
                  "summary": "Metadata",
                  "description": "Arbitrary metadata for tracking and analytics. Does not affect generation, used for organization.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Sample text goes here"
                      }
                    ],
                    "metadata": {
                      "user_id": "user_123",
                      "conversation_id": "conv_456",
                      "custom_field": "value"
                    }
                  }
                },
                "Store": {
                  "summary": "Store (saving conversations)",
                  "description": "Saving conversations for subsequent use in model training (with user consent).",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Sample text goes here"
                      }
                    ],
                    "store": true
                  }
                },
                "Reasoning effort": {
                  "summary": "Reasoning Effort (O1 models)",
                  "description": "Control of 'thinking' time for O1 models. More effort = deeper analysis, but slower.",
                  "value": {
                    "model": "openai/o1",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Solve this complex problem: optimize the traveling salesman for 20 cities"
                      }
                    ],
                    "reasoning_effort": "high"
                  }
                },
                "Developer messages": {
                  "summary": "Developer Messages (O1)",
                  "description": "Use the 'developer' role for system instructions in O1 models (instead of 'system').",
                  "value": {
                    "model": "openai/o1",
                    "messages": [
                      {
                        "role": "developer",
                        "content": "You are a helpful assistant."
                      },
                      {
                        "role": "user",
                        "content": "Hello"
                      }
                    ]
                  }
                },
                "Service tier": {
                  "summary": "Service Tier",
                  "description": "Select the service level for prioritizing requests (default or auto).",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Sample text goes here"
                      }
                    ],
                    "service_tier": "default"
                  }
                },
                "Prediction (prompt caching)": {
                  "summary": "Prediction (Prompt Caching)",
                  "description": "Optimization for prompt caching. Continuation prediction to speed up generation.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Continue this story: Once upon a time in a magical forest..."
                      }
                    ],
                    "prediction": {
                      "type": "content",
                      "content": "There lived a wise old owl who knew all the secrets of the woods."
                    }
                  }
                },
                "Parallel tool calls - disabled": {
                  "summary": "Parallel Tool Calls - disabled",
                  "description": "Disable parallel function calls. The model will call functions sequentially.",
                  "value": {
                    "model": "openai/gpt-4-turbo",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Get weather in Boston and New York"
                      }
                    ],
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_weather",
                          "description": "Get weather",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {"type": "string"}
                            }
                          }
                        }
                      }
                    ],
                    "parallel_tool_calls": false
                  }
                },
                "Refusal": {
                  "summary": "Refusal in assistant messages",
                  "description": "A clear indication of the model's refusal in the previous response to continue the dialogue.",
                  "value": {
                    "model": "openai/gpt-4",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Tell me how to hack"
                      },
                      {
                        "role": "assistant",
                        "refusal": "I cannot help with that request."
                      },
                      {
                        "role": "user",
                        "content": "Okay, how about legal cybersecurity?"
                      }
                    ]
                  }
                },
                "All parameters": {
                  "summary": "Complex request - all parameters",
                  "description": "Demonstration of the maximum number of parameters in a single request for complete control over generation.",
                  "value": {
                    "model": "openai/gpt-4-turbo",
                    "messages": [
                      {
                        "role": "system",
                        "content": "You are a helpful assistant."
                      },
                      {
                        "role": "user",
                        "name": "Alice",
                        "content": "Help me with weather and calculations"
                      }
                    ],
                    "temperature": 0.7,
                    "top_p": 0.9,
                    "max_tokens": 1000,
                    "n": 1,
                    "stream": false,
                    "stop": null,
                    "presence_penalty": 0.1,
                    "frequency_penalty": 0.1,
                    "logit_bias": {},
                    "user": "user-12345",
                    "seed": 42,
                    "tools": [
                      {
                        "type": "function",
                        "function": {
                          "name": "get_weather",
                          "description": "Get weather",
                          "parameters": {
                            "type": "object",
                            "properties": {
                              "location": {"type": "string"}
                            }
                          }
                        }
                      }
                    ],
                    "tool_choice": "auto",
                    "parallel_tool_calls": true,
                    "response_format": {"type": "text"},
                    "metadata": {
                      "conversation_id": "conv_789"
                    },
                    "store": false
                  }
                },
                "Structured outputs with description": {
                  "summary": "Structured Outputs with Description",
                  "description": "JSON Schema with detailed description for precise control of response structure with validation.",
                  "value": {
                    "model": "openai/gpt-4o-2024-08-06",
                    "messages": [
                      {
                        "role": "user",
                        "content": "Calculate 15 * 27 step by step"
                      }
                    ],
                    "response_format": {
                      "type": "json_schema",
                      "json_schema": {
                        "name": "math_response",
                        "description": "A mathematical calculation response",
                        "strict": true,
                        "schema": {
                          "type": "object",
                          "properties": {
                            "result": {
                              "type": "number",
                              "description": "The final answer"
                            },
                            "steps": {
                              "type": "array",
                              "description": "Step by step calculations",
                              "items": {"type": "string"}
                            }
                          },
                          "required": ["result", "steps"],
                          "additionalProperties": false
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CreateChatCompletionResponse"
                }
              },
              "text/event-stream": {
                "schema": {
                  "$ref": "#/components/schemas/CreateChatCompletionStreamResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/completions": {
      "post": {
        "summary": "[LEGACY] Create completion",
        "description": "Create text completion from a single prompt\n.",
        "operationId": "createCompletion",
        "tags": ["Text"],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateCompletionRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CreateCompletionResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/images/generations": {
      "post": {
        "summary": "Create image",
        "description": "Creates an image given a text prompt. Supports streaming responses for real-time generation updates.",
        "operationId": "createImageGeneration",
        "tags": ["Images"],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ImageGenerationRequest"
              },
              "examples": {
                "Generation": {
                  "summary": "Basic image generation",
                  "value": {
                    "model": "MODEL_EXAMPLE",
                    "prompt": "A cute baby sea otter",
                    "n": 1,
                    "size": "1024x1024"
                  }
                },
                "Streaming": {
                  "summary": "Streaming image generation",
                  "value": {
                    "model": "MODEL_EXAMPLE",
                    "prompt": "A cute baby sea otter",
                    "n": 1,
                    "size": "1024x1024",
                    "stream": true
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ImageGenerationResponse"
                }
              },
              "text/event-stream": {
                "schema": {
                  "$ref": "#/components/schemas/ImageGenerationStreamResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "429": {
            "description": "Rate limit exceeded",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "500": {
            "description": "Internal server error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/embeddings": {
      "post": {
        "summary": "Create embeddings",
        "description": "Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.",
        "operationId": "createEmbedding",
        "tags": ["Embeddings"],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/EmbeddingRequest"
              },
              "examples": {
                "basic_embedding": {
                  "summary": "Basic text embedding",
                  "value": {
                    "input": "The food was delicious and the waiter...",
                    "model": "text-embedding-ada-002",
                    "encoding_format": "float"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EmbeddingResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad request - Invalid input parameters"
          },
          "401": {
            "description": "Unauthorized - Invalid or missing API key"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "500": {
            "description": "Internal server error"
          }
        }
      }
    },
    "/models": {
      "get": {
        "summary": "List models",
        "description": "Lists the currently available models, and provides basic information about each one such as the owner and availability.",
        "operationId": "listModels",
        "tags": ["Models"],
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ListModelsResponse"
                }
              }
            }
          },
          "401": {
            "description": "Invalid request parameters",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "429": {
            "description": "Invalid request parameters",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/responses": {
      "post": {
        "summary": "Create response",
        "description": "Creates a comprehensive AI response with support for conversations, tools, files, and streaming",
        "operationId": "createResponse",
        "tags": ["Responses"],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateResponseRequest"
              },
              "examples": {
                "Basic": {
                  "summary": "Basic request",
                  "description": "Simple request with model and input text",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Tell me about AI"
                  }
                },
                "With temperature": {
                  "summary": "With temperature",
                  "description": "Adjusts creativity level using temperature parameter",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Write a creative story about a robot",
                    "temperature": 0.9
                  }
                },
                "With max_tokens": {
                  "summary": "With max_tokens",
                  "description": "Limits the length of the response using max_tokens",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Explain quantum computing",
                    "max_tokens": 500
                  }
                },
                "Conversation": {
                  "summary": "Conversation with message history",
                  "description": "Sends full conversation history with multiple messages",
                  "value": {
                    "model": "openai/gpt-4o",
                    "conversation": {
                      "messages": [
                        {
                          "role": "user",
                          "content": "Hello! How are you?"
                        },
                        {
                          "role": "assistant",
                          "content": "I'm doing well, thank you! How can I help you today?"
                        },
                        {
                          "role": "user",
                          "content": "Tell me about the weather"
                        }
                      ]
                    }
                  }
                },
                "Conversation ID": {
                  "summary": "Using conversation ID",
                  "description": "References existing conversation by ID for context continuity",
                  "value": {
                    "model": "openai/gpt-4o",
                    "conversation": "conv_abc123xyz",
                    "input": "Can you elaborate on that?"
                  }
                },
                "New dialog with system message": {
                  "summary": "System message for context",
                  "description": "Starts conversation with system message to set assistant behavior",
                  "value": {
                    "model": "openai/gpt-4o",
                    "conversation": {
                      "messages": [
                        {
                          "role": "system",
                          "content": "You are a helpful math tutor. Explain concepts clearly."
                        },
                        {
                          "role": "user",
                          "content": "What is calculus?"
                        }
                      ]
                    }
                  }
                },
                "Web Search": {
                  "summary": "Web search tool",
                  "description": "Enables web search capability to find current information",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "What are the latest news about AI today?",
                    "tools": [
                      {
                        "type": "web_search"
                      }
                    ]
                  }
                },
                "File Search": {
                  "summary": "File search tool",
                  "description": "Searches through uploaded documents for relevant information",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Find information about quarterly sales in the uploaded documents",
                    "tools": [
                      {
                        "type": "file_search"
                      }
                    ]
                  }
                },
                "Code Interpreter": {
                  "summary": "Code interpreter tool",
                  "description": "Executes Python code for calculations and data analysis",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Calculate the first 10 Fibonacci numbers",
                    "tools": [
                      {
                        "type": "code_interpreter"
                      }
                    ]
                  }
                },
                "Multiple tools": {
                  "summary": "Multiple tools combined",
                  "description": "Uses multiple tools together for complex tasks",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Research the latest Python libraries and create a comparison chart",
                    "tools": [
                      {
                        "type": "web_search"
                      },
                      {
                        "type": "code_interpreter"
                      }
                    ]
                  }
                },
                "All tools": {
                  "summary": "All available tools",
                  "description": "Enables all three tools for maximum capability",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Find recent research papers on machine learning, summarize them, and create visualizations",
                    "tools": [
                      {
                        "type": "web_search"
                      },
                      {
                        "type": "file_search"
                      },
                      {
                        "type": "code_interpreter"
                      }
                    ]
                  }
                },
                "Include web_search sources": {
                  "summary": "Include web search sources",
                  "description": "Returns web search sources in the response",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "What happened in tech news yesterday?",
                    "tools": [
                      {
                        "type": "web_search"
                      }
                    ],
                    "include": ["web_search"]
                  }
                },
                "Include code_interpreter outputs": {
                  "summary": "Include code outputs",
                  "description": "Returns code execution outputs and generated files",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Plot a sine wave from 0 to 2π",
                    "tools": [
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "include": ["code_interpreter.outputs"]
                  }
                },
                "Include multiple": {
                  "summary": "Include multiple tool outputs",
                  "description": "Returns outputs from multiple tools in the response",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Research AI trends and create a visualization",
                    "tools": [
                      {
                        "type": "web_search"
                      },
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "include": ["web_search", "code_interpreter.outputs"]
                  }
                },
                "Single image URL": {
                  "summary": "Image from URL",
                  "description": "Analyzes image provided via URL",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": [
                      {
                        "type": "text",
                        "text": "What's in this image?"
                      },
                      {
                        "type": "image_url",
                        "image_url": {
                          "url": "https://example.com/image.jpg"
                        }
                      }
                    ]
                  }
                },
                "Image base64": {
                  "summary": "Image in base64 format",
                  "description": "Analyzes image provided as base64-encoded data",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": [
                      {
                        "type": "text",
                        "text": "Describe this image"
                      },
                      {
                        "type": "image_url",
                        "image_url": {
                          "url": "data:image/jpeg;base64,/9j/4AAQSkZJRg...",
                          "detail": "high"
                        }
                      }
                    ]
                  }
                },
                "Multiple images": {
                  "summary": "Multiple images",
                  "description": "Analyzes and compares multiple images",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": [
                      {
                        "type": "text",
                        "text": "Compare these two images"
                      },
                      {
                        "type": "image_url",
                        "image_url": {
                          "url": "https://example.com/image1.jpg"
                        }
                      },
                      {
                        "type": "image_url",
                        "image_url": {
                          "url": "https://example.com/image2.jpg"
                        }
                      }
                    ]
                  }
                },
                "File input (base64)": {
                  "summary": "File input (base64)",
                  "description": "Provides a document directly in the input as a base64-encoded data URL",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": [
                      {
                        "type": "text",
                        "text": "Summarize this document"
                      },
                      {
                        "type": "file",
                        "file": {
                          "file_data": "data:application/pdf;base64,JVBERi0xLjQKJ..."
                        }
                      }
                    ]
                  }
                },
                "File input (URL)": {
                  "summary": "File input (public URL)",
                  "description": "Provides a document via a publicly accessible URL",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": [
                      {
                        "type": "text",
                        "text": "Summarize this document"
                      },
                      {
                        "type": "file",
                        "file": {
                          "file_id": "https://example.com/report.pdf"
                        }
                      }
                    ]
                  }
                },
                "Background processing": {
                  "summary": "Background processing",
                  "description": "Processes request in background for long-running tasks",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Generate a comprehensive market analysis report",
                    "tools": [
                      {
                        "type": "web_search"
                      },
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "background": true
                  }
                },
                "Background with callback": {
                  "summary": "Background with webhook",
                  "description": "Background processing with webhook callback when complete",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Process this large dataset and create visualizations",
                    "tools": [
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "background": true,
                    "webhook_url": "https://your-app.com/webhook"
                  }
                },
                "With metadata": {
                  "summary": "Request with metadata",
                  "description": "Includes custom metadata for tracking and organization",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Analyze customer feedback",
                    "metadata": {
                      "user_id": "user_12345",
                      "session_id": "session_abc",
                      "request_type": "analysis"
                    }
                  }
                },
                "Web research with conversation": {
                  "summary": "Web research in conversation",
                  "description": "Combines conversation context with web search capabilities",
                  "value": {
                    "model": "openai/gpt-4o",
                    "conversation": {
                      "messages": [
                        {
                          "role": "user",
                          "content": "I'm researching renewable energy"
                        }
                      ]
                    },
                    "input": "What are the latest developments in solar panel technology?",
                    "tools": [
                      {
                        "type": "web_search"
                      }
                    ],
                    "include": ["web_search"],
                    "temperature": 0.7
                  }
                },
                "Image analysis with code interpreter": {
                  "summary": "Image + code analysis",
                  "description": "Analyzes images and generates code or visualizations",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": [
                      {
                        "type": "text",
                        "text": "Analyze the data in this chart and recreate it with updated styling"
                      },
                      {
                        "type": "image_url",
                        "image_url": {
                          "url": "https://example.com/chart.png"
                        }
                      }
                    ],
                    "tools": [
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "include": ["code_interpreter.outputs"]
                  }
                },
                "Document analysis with web search": {
                  "summary": "Document + web search",
                  "description": "Compares document content with current online information",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Compare the information in this document with current online sources",
                    "tools": [
                      {
                        "type": "file_search"
                      },
                      {
                        "type": "web_search"
                      }
                    ],
                    "include": ["web_search"]
                  }
                },
                "Multi-step research task": {
                  "summary": "Complex multi-step research",
                  "description": "Comprehensive research task with system instructions and multiple tools",
                  "value": {
                    "model": "openai/gpt-4o",
                    "conversation": {
                      "messages": [
                        {
                          "role": "system",
                          "content": "You are a research assistant. Provide detailed, well-sourced analysis."
                        },
                        {
                          "role": "user",
                          "content": "I need to understand market trends"
                        }
                      ]
                    },
                    "input": "Research competitors in the EV market, analyze their strategies, and create comparison charts",
                    "tools": [
                      {
                        "type": "web_search"
                      },
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "include": ["web_search", "code_interpreter.outputs"],
                    "max_tokens": 2000,
                    "temperature": 0.5
                  }
                },
                "Code analysis with file": {
                  "summary": "Code file analysis",
                  "description": "Reviews code files for bugs and improvements",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Review this code file for bugs and suggest improvements",
                    "tools": [
                      {
                        "type": "code_interpreter"
                      },
                      {
                        "type": "file_search"
                      }
                    ],
                    "include": ["code_interpreter.outputs"]
                  }
                },
                "Data visualization task": {
                  "summary": "Data visualization",
                  "description": "Creates visualizations and dashboards from data files",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Create a dashboard with sales trends from the uploaded CSV",
                    "tools": [
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "include": ["code_interpreter.outputs"],
                    "temperature": 0.3
                  }
                },
                "Stream mode": {
                  "summary": "Streaming response",
                  "description": "Streams the response in real-time as it's generated",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Write a long article about artificial intelligence",
                    "stream": true
                  }
                },
                "Stream with tools": {
                  "summary": "Streaming with tools",
                  "description": "Streams response while using tools",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Research and write about quantum computing advances",
                    "tools": [
                      {
                        "type": "web_search"
                      }
                    ],
                    "include": ["web_search"],
                    "stream": true
                  }
                },
                "Multi-modal analysis": {
                  "summary": "Multi-modal comprehensive analysis",
                  "description": "Combines images, conversation context, and multiple tools",
                  "value": {
                    "model": "openai/gpt-4o",
                    "conversation": {
                      "messages": [
                        {
                          "role": "system",
                          "content": "You are a data analyst expert"
                        }
                      ]
                    },
                    "input": [
                      {
                        "type": "text",
                        "text": "Analyze this chart, search for related market data, and provide insights"
                      },
                      {
                        "type": "image_url",
                        "image_url": {
                          "url": "https://example.com/market-chart.png",
                          "detail": "high"
                        }
                      }
                    ],
                    "tools": [
                      {
                        "type": "web_search"
                      },
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "include": ["web_search", "code_interpreter.outputs"],
                    "max_tokens": 3000
                  }
                },
                "Research paper analysis": {
                  "summary": "Research paper analysis",
                  "description": "Analyzes research papers and compares with latest findings",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Summarize key findings and compare with latest research",
                    "tools": [
                      {
                        "type": "file_search"
                      },
                      {
                        "type": "web_search"
                      }
                    ],
                    "include": ["web_search"],
                    "metadata": {
                      "project": "literature-review",
                      "topic": "machine-learning"
                    }
                  }
                },
                "Automated report generation": {
                  "summary": "Automated reporting",
                  "description": "Generates comprehensive reports with charts in background",
                  "value": {
                    "model": "openai/gpt-4o",
                    "input": "Generate a comprehensive weekly report with charts and data analysis",
                    "tools": [
                      {
                        "type": "code_interpreter"
                      },
                      {
                        "type": "web_search"
                      }
                    ],
                    "include": ["code_interpreter.outputs", "web_search"],
                    "background": true,
                    "webhook_url": "https://your-app.com/reports/webhook",
                    "metadata": {
                      "report_type": "weekly",
                      "department": "sales"
                    }
                  }
                },
                "Maximum parameters": {
                  "summary": "All available parameters",
                  "description": "Demonstrates maximum capability with all parameters combined",
                  "value": {
                    "model": "openai/gpt-4o",
                    "conversation": {
                      "messages": [
                        {
                          "role": "system",
                          "content": "You are an expert research analyst"
                        },
                        {
                          "role": "user",
                          "content": "I need comprehensive market analysis"
                        }
                      ]
                    },
                    "input": [
                      {
                        "type": "text",
                        "text": "Analyze this market data, search for competitor information, and create visualizations"
                      },
                      {
                        "type": "image_url",
                        "image_url": {
                          "url": "https://example.com/data-chart.png",
                          "detail": "high"
                        }
                      }
                    ],
                    "tools": [
                      {
                        "type": "web_search"
                      },
                      {
                        "type": "file_search"
                      },
                      {
                        "type": "code_interpreter"
                      }
                    ],
                    "include": ["web_search", "code_interpreter.outputs"],
                    "max_tokens": 4000,
                    "temperature": 0.7,
                    "stream": false,
                    "background": false,
                    "metadata": {
                      "user_id": "user_xyz",
                      "project": "market-analysis",
                      "priority": "high"
                    }
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/CreateResponseResponse"
                }
              },
              "text/event-stream": {
                "schema": {
                  "$ref": "#/components/schemas/CreateResponseStreamResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    },
    "/moderations": {
      "post": {
        "summary": "Check content moderation",
        "description": "The moderations endpoint is a tool you can use to check whether content complies with an LLM Providers policies",
        "operationId": "checkModeration",
        "tags": ["Moderation"],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "required": [
                  "input",
                  "model"
                ],
                "properties": {
                  "input": {
                    "type": "string",
                    "description": "The text to check for moderation",
                    "example": "Sample text goes here"
                  },
                  "model": {
                    "type": "string",
                    "description": "The moderation model to use",
                    "example": "text-moderation-stable"
                  }
                }
              },
              "example": {
                "input": "Sample text goes here",
                "model": "text-moderation-stable"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "id": {
                      "type": "string",
                      "description": "Response identifier"
                    },
                    "model": {
                      "type": "string",
                      "description": "Model used for moderation"
                    },
                    "results": {
                      "type": "array",
                      "items": {
                        "type": "object",
                        "properties": {
                          "flagged": {
                            "type": "boolean",
                            "description": "Whether the content was flagged"
                          },
                          "categories": {
                            "type": "object",
                            "description": "Categories that were checked",
                            "additionalProperties": {
                              "type": "boolean"
                            }
                          },
                          "category_scores": {
                            "type": "object",
                            "description": "Scores for each category",
                            "additionalProperties": {
                              "type": "number"
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Bad request - invalid input"
          },
          "401": {
            "description": "Unauthorized - invalid API key"
          }
        }
      }
    }
  },
  "components": {
    "securitySchemes": {
      "bearerAuth": {
        "type": "http",
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "description": "Bearer token authentication. Get your API key from the dashboard."
      }
    },
    "parameters":{
      "AcceptHeader":{
        "name":"accept",
        "in":"header",
        "required":true,
        "schema":{
          "type":"string",
          "enum":[
            "application/json"
          ]
        }
      },
      "ContentTypeHeader":{
        "name":"content",
        "in":"header",
        "required":true,
        "schema":{
          "type":"string",
          "enum":[
            "application/json"
          ]
        }
      }
    },
    "schemas": {
      "TextContentPart": {
        "type": "object",
        "required": ["type", "text"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["text"]
          },
          "text": {
            "type": "string",
            "description": "The text content"
          }
        }
      },
      "ImageUrlContentPart": {
        "type": "object",
        "required": ["type", "image_url"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["image_url"]
          },
          "image_url": {
            "$ref": "#/components/schemas/ImageUrl"
          }
        }
      },
      "ImageUrl": {
        "type": "object",
        "required": ["url"],
        "properties": {
          "url": {
            "type": "string",
            "format": "uri",
            "description": "Either a URL of the image or the base64 encoded image data"
          },
          "detail": {
            "type": "string",
            "enum": ["auto", "low", "high"],
            "description": "Specifies the detail level of the image",
            "default": "auto"
          }
        }
      },
      "Tool": {
        "type": "object",
        "required": ["type", "function"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["function"]
          },
          "function": {
            "$ref": "#/components/schemas/Function"
          }
        }
      },
      "Function": {
        "type": "object",
        "required": ["name"],
        "properties": {
          "name": {
            "type": "string",
            "description": "The name of the function to be called"
          },
          "description": {
            "type": "string",
            "description": "A description of what the function does"
          },
          "parameters": {
            "type": "object",
            "description": "The parameters the functions accepts, described as a JSON Schema object"
          }
        }
      },
      "ToolChoice": {
        "type": "object",
        "required": ["type", "function"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["function"]
          },
          "function": {
            "type": "object",
            "required": ["name"],
            "properties": {
              "name": {
                "type": "string",
                "description": "The name of the function to call"
              }
            }
          }
        }
      },
      "Usage": {
        "type": "object",
        "required": ["prompt_tokens", "completion_tokens", "total_tokens"],
        "properties": {
          "prompt_tokens": {
            "type": "integer",
            "description": "Number of tokens in the prompt"
          },
          "completion_tokens": {
            "type": "integer",
            "description": "Number of tokens in the generated completion"
          },
          "total_tokens": {
            "type": "integer",
            "description": "Total number of tokens used in the request"
          }
        }
      },
      "ChatCompletionStreamResponse": {
        "type": "object",
        "description": "Represents a streamed chunk of a chat completion response",
        "required": ["id", "object", "created", "model", "choices"],
        "properties": {
          "id": {
            "type": "string",
            "description": "A unique identifier for the chat completion"
          },
          "object": {
            "type": "string",
            "enum": ["chat.completion.chunk"],
            "description": "The object type, which is always 'chat.completion.chunk'"
          },
          "created": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) of when the chat completion was created"
          },
          "model": {
            "type": "string",
            "description": "The model used for the chat completion"
          },
          "choices": {
            "type": "array",
            "description": "A list of chat completion choices",
            "items": {
              "$ref": "#/components/schemas/StreamChoice"
            }
          }
        }
      },
      "StreamChoice": {
        "type": "object",
        "required": ["index", "delta"],
        "properties": {
          "index": {
            "type": "integer",
            "description": "The index of the choice in the list of choices"
          },
          "delta": {
            "$ref": "#/components/schemas/ChatMessageDelta"
          },
          "finish_reason": {
            "type": "string",
            "enum": ["stop", "length", "function_call", "content_filter", "tool_calls"],
            "description": "The reason the model stopped generating tokens",
            "nullable": true
          }
        }
      },
      "ChatMessageDelta": {
        "type": "object",
        "description": "A chat completion delta generated by streamed model responses",
        "properties": {
          "role": {
            "type": "string",
            "enum": ["assistant"],
            "description": "The role of the author of this message"
          },
          "content": {
            "type": "string",
            "description": "The contents of the chunk message",
            "nullable": true
          }
        }
      },
      "TranslationRequest": {
        "type": "object",
        "required": ["file", "model"],
        "properties": {
          "file": {
            "type": "string",
            "format": "binary",
            "description": "The audio file object (not file name) to translate, in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm."
          },
          "model": {
            "type": "string",
            "description": "ID of the model to use",
            "example": "whisper-1"
          },
          "prompt": {
            "type": "string",
            "description": "An optional text to guide the model's style or continue a previous audio segment. The prompt should be in English."
          },
          "response_format": {
            "type": "string",
            "description": "The format of the transcript output",
            "enum": ["json", "text", "srt", "verbose_json", "vtt"],
            "default": "json"
          },
          "temperature": {
            "type": "number",
            "description": "The sampling temperature, between 0 and 1",
            "minimum": 0,
            "maximum": 1,
            "default": 0
          }
        }
      },
      "TranslationResponse": {
        "type": "object",
        "required": ["text"],
        "properties": {
          "text": {
            "type": "string",
            "description": "The translated text in English"
          },
          "language": {
            "type": "string",
            "description": "The language of the input audio"
          },
          "duration": {
            "type": "number",
            "description": "The duration of the input audio in seconds"
          }
        }
      },
      "ImageEditRequest": {
        "type": "object",
        "required": ["model", "image"],
        "properties": {
          "model": {
            "type": "string",
            "description": "The model to use for image editing",
            "example": "gpt-image-1"
          },
          "image": {
            "oneOf": [
              {
                "type": "string",
                "format": "binary",
                "description": "The image to edit. Must be a valid PNG file, less than 4MB, and square."
              },
              {
                "type": "array",
                "items": {
                  "type": "string",
                  "format": "binary"
                },
                "description": "Multiple images to use in the edit. Each must be a valid PNG file, less than 4MB, and square."
              }
            ]
          },
          "mask": {
            "type": "string",
            "format": "binary",
            "description": "An additional image whose fully transparent areas (e.g. where alpha is zero) indicate where image should be edited. Must be a valid PNG file, less than 4MB, and have the same dimensions as image."
          },
          "prompt": {
            "type": "string",
            "description": "A text description of the desired image(s). The maximum length is 1000 characters.",
            "maxLength": 1000
          },
          "n": {
            "type": "integer",
            "description": "The number of images to generate",
            "minimum": 1,
            "maximum": 10,
            "default": 1
          },
          "size": {
            "type": "string",
            "description": "The size of the generated images",
            "enum": ["256x256", "512x512", "1024x1024"],
            "default": "1024x1024"
          },
          "response_format": {
            "type": "string",
            "description": "The format in which the generated images are returned",
            "enum": ["url", "b64_json"],
            "default": "url"
          },
          "user": {
            "type": "string",
            "description": "A unique identifier representing your end-user"
          }
        }
      },
      "ImageGenerationRequest": {
        "type": "object",
        "required": ["model", "prompt"],
        "properties": {
          "model": {
            "type": "string",
            "description": "The model to use for image generation",
            "example": "gpt-image-1"
          },
          "prompt": {
            "type": "string",
            "description": "A text description of the desired image(s)",
            "example": "A cute baby sea otter",
            "maxLength": 1000
          },
          "n": {
            "type": "integer",
            "description": "The number of images to generate",
            "minimum": 1,
            "maximum": 10,
            "default": 1
          },
          "size": {
            "type": "string",
            "description": "The size of the generated images",
            "enum": ["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"],
            "default": "1024x1024"
          },
          "stream": {
            "type": "boolean",
            "description": "If set, generation progress updates will be sent as server-sent events",
            "default": false
          },
          "response_format": {
            "type": "string",
            "description": "The format in which the generated images are returned",
            "enum": ["url", "b64_json"],
            "default": "url"
          }
        }
      },
      "ImageGenerationResponse": {
        "type": "object",
        "required": ["created", "data"],
        "properties": {
          "created": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) of when the images were generated"
          },
          "data": {
            "type": "array",
            "description": "Array of generated image objects",
            "items": {
              "$ref": "#/components/schemas/ImageObject"
            }
          }
        }
      },
      "ImageObject": {
        "type": "object",
        "properties": {
          "url": {
            "type": "string",
            "format": "uri",
            "description": "The URL of the generated image, if response_format is url (default)"
          },
          "b64_json": {
            "type": "string",
            "description": "The base64-encoded JSON of the generated image, if response_format is b64_json"
          },
          "revised_prompt": {
            "type": "string",
            "description": "The prompt that was used to generate the image, if there was any revision to the prompt"
          }
        }
      },
      "ImageGenerationStreamResponse": {
        "type": "object",
        "description": "Represents a streamed chunk of an image generation response",
        "required": ["id", "object", "created"],
        "properties": {
          "id": {
            "type": "string",
            "description": "A unique identifier for the image generation"
          },
          "object": {
            "type": "string",
            "enum": ["image.generation.chunk"],
            "description": "The object type, which is always 'image.generation.chunk'"
          },
          "created": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) of when the image generation was created"
          },
          "progress": {
            "type": "number",
            "description": "The progress of the image generation as a percentage (0-100)",
            "minimum": 0,
            "maximum": 100
          },
          "status": {
            "type": "string",
            "enum": ["pending", "generating", "completed", "failed"],
            "description": "The current status of the image generation"
          },
          "data": {
            "type": "array",
            "description": "Array of generated image objects (only present when completed)",
            "items": {
              "$ref": "#/components/schemas/ImageObject"
            }
          }
        }
      },
      "ImageVariationRequest": {
        "type": "object",
        "required": ["image"],
        "properties": {
          "image": {
            "type": "string",
            "format": "binary",
            "description": "The image to use as the basis for the variation(s). Must be a valid PNG file, less than 4MB, and square."
          },
          "model": {
            "type": "string",
            "description": "The model to use for image variation generation",
            "example": "dall-e-2"
          },
          "n": {
            "type": "integer",
            "description": "The number of images to generate",
            "minimum": 1,
            "maximum": 10,
            "default": 1
          },
          "response_format": {
            "type": "string",
            "description": "The format in which the generated images are returned",
            "enum": ["url", "b64_json"],
            "default": "url"
          },
          "size": {
            "type": "string",
            "description": "The size of the generated images",
            "enum": ["256x256", "512x512", "1024x1024"],
            "default": "1024x1024"
          },
          "user": {
            "type": "string",
            "description": "A unique identifier representing your end-user"
          }
        }
      },
      "SpeechRequest": {
        "type": "object",
        "required": ["model", "input", "voice"],
        "properties": {
          "model": {
            "type": "string",
            "description": "One of the available TTS models",
            "example": "gpt-4o-mini-tts"
          },
          "input": {
            "type": "string",
            "description": "The text to generate audio for. The maximum length is 4096 characters",
            "maxLength": 4096
          },
          "voice": {
            "type": "string",
            "description": "The voice to use when generating the audio",
            "enum": ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]
          },
          "response_format": {
            "type": "string",
            "description": "The format to audio in",
            "enum": ["mp3", "opus", "aac", "flac", "wav", "pcm"],
            "default": "mp3"
          },
          "speed": {
            "type": "number",
            "description": "The speed of the generated audio",
            "minimum": 0.25,
            "maximum": 4.0,
            "default": 1.0
          }
        }
      },
      "TranscriptionRequest": {
        "type": "object",
        "required": ["file", "model"],
        "properties": {
          "file": {
            "type": "string",
            "format": "binary",
            "description": "The audio file object (not file name) to transcribe, in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm."
          },
          "model": {
            "type": "string",
            "description": "ID of the model to use",
            "example": "gpt-4o-transcribe"
          },
          "language": {
            "type": "string",
            "description": "The language of the input audio. Supplying the input language in ISO-639-1 format will improve accuracy and latency"
          },
          "prompt": {
            "type": "string",
            "description": "An optional text to guide the model's style or continue a previous audio segment"
          },
          "response_format": {
            "type": "string",
            "description": "The format of the transcript output",
            "enum": ["json", "text", "srt", "verbose_json", "vtt"],
            "default": "json"
          },
          "temperature": {
            "type": "number",
            "description": "The sampling temperature, between 0 and 1",
            "minimum": 0,
            "maximum": 1,
            "default": 0
          },
          "timestamp_granularities": {
            "type": "array",
            "description": "The timestamp granularities to populate for this transcription",
            "items": {
              "type": "string",
              "enum": ["word", "segment"]
            }
          },
          "stream": {
            "type": "boolean",
            "description": "If set, partial transcription results will be sent as server-sent events",
            "default": false
          },
          "include": {
            "type": "array",
            "description": "Additional data to include in the response",
            "items": {
              "type": "string",
              "enum": ["logprobs"]
            }
          }
        }
      },
      "TranscriptionResponse": {
        "type": "object",
        "required": ["text"],
        "properties": {
          "text": {
            "type": "string",
            "description": "The transcribed text"
          },
          "language": {
            "type": "string",
            "description": "The language of the input audio"
          },
          "duration": {
            "type": "number",
            "description": "The duration of the input audio in seconds"
          },
          "words": {
            "type": "array",
            "description": "Extracted words and their corresponding timestamps (when timestamp_granularities includes 'word')",
            "items": {
              "$ref": "#/components/schemas/TranscriptionWord"
            }
          },
          "segments": {
            "type": "array",
            "description": "Segments of the transcribed text and their corresponding details (when timestamp_granularities includes 'segment')",
            "items": {
              "$ref": "#/components/schemas/TranscriptionSegment"
            }
          }
        }
      },
      "TranscriptionWord": {
        "type": "object",
        "required": ["word", "start", "end"],
        "properties": {
          "word": {
            "type": "string",
            "description": "The text content of the word"
          },
          "start": {
            "type": "number",
            "description": "Start time of the word in seconds"
          },
          "end": {
            "type": "number",
            "description": "End time of the word in seconds"
          }
        }
      },
      "TranscriptionSegment": {
        "type": "object",
        "required": ["id", "seek", "start", "end", "text", "tokens"],
        "properties": {
          "id": {
            "type": "integer",
            "description": "Unique identifier of the segment"
          },
          "seek": {
            "type": "integer",
            "description": "Seek offset of the segment"
          },
          "start": {
            "type": "number",
            "description": "Start time of the segment in seconds"
          },
          "end": {
            "type": "number",
            "description": "End time of the segment in seconds"
          },
          "text": {
            "type": "string",
            "description": "Text content of the segment"
          },
          "tokens": {
            "type": "array",
            "description": "Array of token IDs for the text content",
            "items": {
              "type": "integer"
            }
          },
          "temperature": {
            "type": "number",
            "description": "Temperature parameter used for the segment"
          },
          "avg_logprob": {
            "type": "number",
            "description": "Average log probability of the segment"
          },
          "compression_ratio": {
            "type": "number",
            "description": "Compression ratio of the segment"
          },
          "no_speech_prob": {
            "type": "number",
            "description": "Probability of no speech"
          }
        }
      },
      "TranscriptionStreamResponse": {
        "type": "object",
        "description": "Represents a streamed chunk of a transcription response",
        "required": ["id", "object", "created"],
        "properties": {
          "id": {
            "type": "string",
            "description": "A unique identifier for the transcription"
          },
          "object": {
            "type": "string",
            "enum": ["transcription.chunk"],
            "description": "The object type, which is always 'transcription.chunk'"
          },
          "created": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) of when the transcription was created"
          },
          "model": {
            "type": "string",
            "description": "The model used for transcription"
          },
          "delta": {
            "$ref": "#/components/schemas/TranscriptionDelta"
          }
        }
      },
      "TranscriptionDelta": {
        "type": "object",
        "description": "A transcription delta generated by streamed model responses",
        "properties": {
          "text": {
            "type": "string",
            "description": "The partial transcribed text",
            "nullable": true
          }
        }
      },
      "EmbeddingRequest": {
        "type": "object",
        "required": ["input", "model"],
        "properties": {
          "input": {
            "oneOf": [
              {
                "type": "string",
                "description": "Input text to embed"
              },
              {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Array of input texts to embed"
              }
            ]
          },
          "model": {
            "type": "string",
            "description": "ID of the model to use",
            "example": "text-embedding-ada-002"
          },
          "encoding_format": {
            "type": "string",
            "description": "The format to return the embeddings in",
            "enum": ["float", "base64"],
            "default": "float"
          },
          "dimensions": {
            "type": "integer",
            "description": "The number of dimensions the resulting embeddings should have",
            "minimum": 1
          },
          "user": {
            "type": "string",
            "description": "A unique identifier representing your end-user"
          }
        }
      },
      "EmbeddingResponse": {
        "type": "object",
        "required": ["object", "data", "model", "usage"],
        "properties": {
          "object": {
            "type": "string",
            "enum": ["list"],
            "description": "The object type, which is always 'list'"
          },
          "data": {
            "type": "array",
            "description": "Array of embedding objects",
            "items": {
              "$ref": "#/components/schemas/Embedding"
            }
          },
          "model": {
            "type": "string",
            "description": "The name of the model used to generate the embedding"
          },
          "usage": {
            "$ref": "#/components/schemas/Usage"
          }
        }
      },
      "Embedding": {
        "type": "object",
        "required": ["object", "embedding", "index"],
        "properties": {
          "object": {
            "type": "string",
            "enum": ["embedding"],
            "description": "The object type, which is always 'embedding'"
          },
          "embedding": {
            "type": "array",
            "description": "The embedding vector",
            "items": {
              "type": "number"
            }
          },
          "index": {
            "type": "integer",
            "description": "The index of the embedding in the list of embeddings"
          }
        }
      },
      "BatchRequest": {
        "type": "object",
        "required": ["input_file_id", "endpoint", "completion_window"],
        "properties": {
          "input_file_id": {
            "type": "string",
            "description": "The ID of an uploaded file that contains requests for the new batch"
          },
          "endpoint": {
            "type": "string",
            "description": "The endpoint to be used for all requests in the batch",
            "enum": ["/v1/chat/completions", "/v1/embeddings", "/v1/completions"]
          },
          "completion_window": {
            "type": "string",
            "description": "The time frame within which the batch should be processed",
            "enum": ["24h"]
          },
          "metadata": {
            "type": "object",
            "description": "Optional custom metadata for the batch",
            "additionalProperties": {
              "type": "string"
            }
          }
        }
      },
      "BatchObject": {
        "type": "object",
        "required": ["id", "object", "endpoint", "input_file_id", "completion_window", "status", "created_at"],
        "properties": {
          "id": {
            "type": "string",
            "description": "The batch identifier"
          },
          "object": {
            "type": "string",
            "enum": ["batch"],
            "description": "The object type, which is always 'batch'"
          },
          "endpoint": {
            "type": "string",
            "description": "The endpoint used for the batch"
          },
          "input_file_id": {
            "type": "string",
            "description": "The ID of the input file for the batch"
          },
          "completion_window": {
            "type": "string",
            "description": "The time frame within which the batch should be processed"
          },
          "status": {
            "type": "string",
            "description": "The current status of the batch",
            "enum": ["validating", "failed", "in_progress", "finalizing", "completed", "expired", "cancelling", "cancelled"]
          },
          "output_file_id": {
            "type": "string",
            "description": "The ID of the file containing the outputs of successfully executed requests",
            "nullable": true
          },
          "error_file_id": {
            "type": "string",
            "description": "The ID of the file containing the outputs of requests with errors",
            "nullable": true
          },
          "created_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch was created"
          },
          "in_progress_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch started processing",
            "nullable": true
          },
          "expires_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch will expire",
            "nullable": true
          },
          "finalizing_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch started finalizing",
            "nullable": true
          },
          "completed_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch was completed",
            "nullable": true
          },
          "failed_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch failed",
            "nullable": true
          },
          "expired_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch expired",
            "nullable": true
          },
          "cancelling_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch started cancelling",
            "nullable": true
          },
          "cancelled_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the batch was cancelled",
            "nullable": true
          },
          "request_counts": {
            "$ref": "#/components/schemas/BatchRequestCounts"
          },
          "metadata": {
            "type": "object",
            "description": "Set of key-value pairs attached to the object",
            "additionalProperties": {
              "type": "string"
            },
            "nullable": true
          }
        }
      },
      "BatchRequestCounts": {
        "type": "object",
        "required": ["total", "completed", "failed"],
        "properties": {
          "total": {
            "type": "integer",
            "description": "Total number of requests in the batch"
          },
          "completed": {
            "type": "integer",
            "description": "Number of requests that have been completed successfully"
          },
          "failed": {
            "type": "integer",
            "description": "Number of requests that have failed"
          }
        }
      },
      "BatchList": {
        "type": "object",
        "required": ["object", "data"],
        "properties": {
          "object": {
            "type": "string",
            "enum": ["list"],
            "description": "The object type, which is always 'list'"
          },
          "data": {
            "type": "array",
            "description": "Array of batch objects",
            "items": {
              "$ref": "#/components/schemas/BatchObject"
            }
          },
          "first_id": {
            "type": "string",
            "description": "First ID in the retrieved list"
          },
          "last_id": {
            "type": "string",
            "description": "Last ID in the retrieved list"
          },
          "has_more": {
            "type": "boolean",
            "description": "Whether there are more batches available"
          }
        }},
      "FineTuningJobRequest": {
        "type": "object",
        "required": ["model", "training_file"],
        "properties": {
          "model": {
            "type": "string",
            "description": "The name of the model to fine-tune",
            "example": "openai/gpt-4o-mini"
          },
          "training_file": {
            "type": "string",
            "description": "The ID of an uploaded file that contains training data"
          },
          "hyperparameters": {
            "$ref": "#/components/schemas/FineTuningHyperparameters"
          },
          "suffix": {
            "type": "string",
            "description": "A string of up to 18 characters that will be added to your fine-tuned model name",
            "maxLength": 18
          },
          "validation_file": {
            "type": "string",
            "description": "The ID of an uploaded file that contains validation data"
          },
          "integrations": {
            "type": "array",
            "description": "A list of integrations to enable for your fine-tuning job",
            "items": {
              "$ref": "#/components/schemas/FineTuningIntegration"
            }
          },
          "seed": {
            "type": "integer",
            "description": "The seed controls the reproducibility of the job",
            "minimum": 0,
            "maximum": 2147483647
          },
          "method": {
            "$ref": "#/components/schemas/FineTuningMethod"
          }
        }
      },
      "FineTuningMethod": {
        "type": "object",
        "required": ["type"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["supervised", "dpo", "reinforcement"],
            "description": "The fine-tuning method to use"
          },
          "supervised": {
            "$ref": "#/components/schemas/SupervisedFineTuning"
          },
          "dpo": {
            "$ref": "#/components/schemas/DPOFineTuning"
          },
          "reinforcement": {
            "$ref": "#/components/schemas/ReinforcementFineTuning"
          }
        }
      },
      "SupervisedFineTuning": {
        "type": "object",
        "properties": {
          "hyperparameters": {
            "type": "object",
            "properties": {
              "n_epochs": {
                "type": "integer",
                "description": "The number of epochs to train the model for",
                "minimum": 1,
                "maximum": 50,
                "default": 3
              },
              "learning_rate_multiplier": {
                "type": "number",
                "description": "Scaling factor for the learning rate",
                "minimum": 0.02,
                "maximum": 2,
                "default": 1
              },
              "batch_size": {
                "type": "integer",
                "description": "Number of examples in each batch",
                "minimum": 1,
                "maximum": 256,
                "default": 8
              }
            }
          }
        }
      },
      "DPOFineTuning": {
        "type": "object",
        "properties": {
          "hyperparameters": {
            "type": "object",
            "properties": {
              "beta": {
                "type": "number",
                "description": "The beta parameter for DPO loss",
                "minimum": 0,
                "maximum": 5,
                "default": 0.1
              },
              "learning_rate_multiplier": {
                "type": "number",
                "description": "Scaling factor for the learning rate",
                "minimum": 0.02,
                "maximum": 2,
                "default": 1
              },
              "n_epochs": {
                "type": "integer",
                "description": "The number of epochs to train the model for",
                "minimum": 1,
                "maximum": 50,
                "default": 3
              }
            }
          }
        }
      },
      "ReinforcementFineTuning": {
        "type": "object",
        "required": ["grader"],
        "properties": {
          "grader": {
            "$ref": "#/components/schemas/FineTuningGrader"
          },
          "hyperparameters": {
            "type": "object",
            "properties": {
              "reasoning_effort": {
                "type": "string",
                "enum": ["low", "medium", "high"],
                "description": "The reasoning effort level for the model",
                "default": "medium"
              }
            }
          }
        }
      },
      "FineTuningGrader": {
        "type": "object",
        "required": ["type", "name", "input", "reference", "operation"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["string_check"],
            "description": "The type of grader"
          },
          "name": {
            "type": "string",
            "description": "The name of the grader"
          },
          "input": {
            "type": "string",
            "description": "The input template for the grader"
          },
          "reference": {
            "type": "string",
            "description": "The reference template for comparison"
          },
          "operation": {
            "type": "string",
            "enum": ["eq", "ne", "contains"],
            "description": "The comparison operation"
          }
        }
      },
      "FineTuningHyperparameters": {
        "type": "object",
        "properties": {
          "batch_size": {
            "oneOf": [
              {
                "type": "string",
                "enum": ["auto"]
              },
              {
                "type": "integer",
                "minimum": 1,
                "maximum": 256
              }
            ],
            "description": "Number of examples in each batch",
            "default": "auto"
          },
          "learning_rate_multiplier": {
            "oneOf": [
              {
                "type": "string",
                "enum": ["auto"]
              },
              {
                "type": "number",
                "minimum": 0.02,
                "maximum": 2
              }
            ],
            "description": "Scaling factor for the learning rate",
            "default": "auto"
          },
          "n_epochs": {
            "oneOf": [
              {
                "type": "string",
                "enum": ["auto"]
              },
              {
                "type": "integer",
                "minimum": 1,
                "maximum": 50
              }
            ],
            "description": "The number of epochs to train the model for",
            "default": "auto"
          }
        }
      },
      "FineTuningIntegration": {
        "type": "object",
        "required": ["type"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["wandb"],
            "description": "The type of integration"
          },
          "wandb": {
            "$ref": "#/components/schemas/WandbIntegration"
          }
        }
      },
      "WandbIntegration": {
        "type": "object",
        "required": ["project"],
        "properties": {
          "project": {
            "type": "string",
            "description": "The name of the project that the new run will be created under"
          },
          "name": {
            "type": "string",
            "description": "A display name to set for the run"
          },
          "entity": {
            "type": "string",
            "description": "The entity to use for the run"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "A list of tags to be attached to the newly created run"
          }
        }
      },
      "FineTuningJob": {
        "type": "object",
        "required": ["id", "object", "created_at", "finished_at", "fine_tuned_model", "hyperparameters", "model", "organization_id", "result_files", "status", "trained_tokens", "training_file", "validation_file"],
        "properties": {
          "id": {
            "type": "string",
            "description": "The object identifier"
          },
          "object": {
            "type": "string",
            "enum": ["fine_tuning.job"],
            "description": "The object type, which is always 'fine_tuning.job'"
          },
          "created_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the fine-tuning job was created"
          },
          "error": {
            "$ref": "#/components/schemas/FineTuningJobError"
          },
          "fine_tuned_model": {
            "type": "string",
            "description": "The name of the fine-tuned model that is being created",
            "nullable": true
          },
          "finished_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the fine-tuning job was finished",
            "nullable": true
          },
          "hyperparameters": {
            "$ref": "#/components/schemas/FineTuningHyperparameters"
          },
          "model": {
            "type": "string",
            "description": "The base model that is being fine-tuned"
          },
          "organization_id": {
            "type": "string",
            "description": "The organization that owns the fine-tuning job"
          },
          "result_files": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "The compiled results file ID(s) for the fine-tuning job"
          },
          "status": {
            "type": "string",
            "enum": ["validating_files", "queued", "running", "succeeded", "failed", "cancelled"],
            "description": "The current status of the fine-tuning job"
          },
          "trained_tokens": {
            "type": "integer",
            "description": "The total number of billable tokens processed by this fine-tuning job",
            "nullable": true
          },
          "training_file": {
            "type": "string",
            "description": "The file ID used for training"
          },
          "validation_file": {
            "type": "string",
            "description": "The file ID used for validation",
            "nullable": true
          },
          "integrations": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/FineTuningIntegration"
            },
            "description": "A list of integrations enabled for this fine-tuning job"
          },
          "seed": {
            "type": "integer",
            "description": "The seed used for the fine-tuning job"
          },
          "estimated_finish": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the fine-tuning job is estimated to finish",
            "nullable": true
          }
        }
      },
      "FineTuningJobError": {
        "type": "object",
        "required": ["code", "message", "param"],
        "properties": {
          "code": {
            "type": "string",
            "description": "A machine-readable error code"
          },
          "message": {
            "type": "string",
            "description": "A human-readable error message"
          },
          "param": {
            "type": "string",
            "description": "The parameter that was invalid",
            "nullable": true
          }
        }
      },
      "FineTuningJobList": {
        "type": "object",
        "required": ["object", "data"],
        "properties": {
          "object": {
            "type": "string",
            "enum": ["list"],
            "description": "The object type, which is always 'list'"
          },
          "data": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/FineTuningJob"
            },
            "description": "Array of fine-tuning job objects"
          },
          "has_more": {
            "type": "boolean",
            "description": "Whether there are more fine-tuning jobs available"
          }
        }
      },
      "FineTuningJobEvent": {
        "type": "object",
        "required": ["id", "object", "created_at", "level", "message"],
        "properties": {
          "id": {
            "type": "string",
            "description": "The object identifier"
          },
          "object": {
            "type": "string",
            "enum": ["fine_tuning.job.event"],
            "description": "The object type, which is always 'fine_tuning.job.event'"
          },
          "created_at": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) for when the fine-tuning job event was created"
          },
          "level": {
            "type": "string",
            "enum": ["info", "warn", "error"],
            "description": "The log level of the event"
          },
          "message": {
            "type": "string",
            "description": "The event message"
          },
          "data": {
            "type": "object",
            "description": "Additional event data",
            "nullable": true
          },
          "type": {
            "type": "string",
            "enum": ["message", "metrics"],
            "description": "The type of event"
          }
        }
      },
      "FineTuningJobEventList": {
        "type": "object",
        "required": ["object", "data"],
        "properties": {
          "object": {
            "type": "string",
            "enum": ["list"],
            "description": "The object type, which is always 'list'"
          },
          "data": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/FineTuningJobEvent"
            },
            "description": "Array of fine-tuning job event objects"
          },
          "has_more": {
            "type": "boolean",
            "description": "Whether there are more events available"
          }
        }
      },
      "ChatCompletionMessageFunctionCall": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "arguments": {
            "type": "string"
          }
        },
        "required": ["name", "arguments"]
      },
      "CreateChatCompletionResponse": {
        "type": "object",
        "required": ["id", "object", "created", "model", "choices"],
        "properties": {
          "id": {
            "type": "string",
            "description": "A unique identifier for the chat completion"
          },
          "object": {
            "type": "string",
            "enum": ["chat.completion"]
          },
          "created": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) of when the chat completion was created"
          },
          "model": {
            "type": "string",
            "description": "The model used for the chat completion"
          },
          "choices": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionChoice"
            }
          },
          "usage": {
            "$ref": "#/components/schemas/CompletionUsage"
          },
          "system_fingerprint": {
            "type": "string",
            "description": "This fingerprint represents the backend configuration that the model runs with"
          }
        }
      },
      "CreateChatCompletionStreamResponse": {
        "type": "object",
        "required": ["id", "object", "created", "model", "choices"],
        "properties": {
          "id": {
            "type": "string",
            "description": "A unique identifier for the chat completion"
          },
          "object": {
            "type": "string",
            "enum": ["chat.completion.chunk"]
          },
          "created": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) of when the chat completion was created"
          },
          "model": {
            "type": "string",
            "description": "The model used for the chat completion"
          },
          "choices": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionStreamChoice"
            }
          },
          "system_fingerprint": {
            "type": "string",
            "description": "This fingerprint represents the backend configuration that the model runs with"
          }
        }
      },
      "CreateResponseRequest": {
        "type": "object",
        "required": ["model"],
        "properties": {
          "model": {
            "type": "string",
            "description": "ID of the model to use",
            "example": "openai/gpt-4o"
          },
          "input": {
            "oneOf": [
              {
                "type": "string",
                "description": "Text input for the model"
              },
              {
                "type": "array",
                "description": "Array of content parts (text, images, and/or files)",
                "items": {
                  "oneOf": [
                    {
                      "$ref": "#/components/schemas/ChatCompletionMessageContentPartText"
                    },
                    {
                      "$ref": "#/components/schemas/ChatCompletionMessageContentPartImage"
                    },
                    {
                      "$ref": "#/components/schemas/ChatCompletionMessageContentPartFile"
                    }
                  ]
                }
              }
            ]
          },
          "conversation": {
            "oneOf": [
              {
                "type": "string",
                "description": "Conversation ID to continue an existing conversation"
              },
              {
                "type": "object",
                "description": "Conversation object with message history",
                "properties": {
                  "messages": {
                    "type": "array",
                    "items": {
                      "$ref": "#/components/schemas/ChatCompletionMessage"
                    }
                  }
                }
              }
            ]
          },
          "tools": {
            "type": "array",
            "description": "List of tools available to the model",
            "items": {
              "type": "object",
              "required": ["type"],
              "properties": {
                "type": {
                  "type": "string",
                  "enum": ["web_search", "file_search", "code_interpreter"],
                  "description": "Type of tool to enable"
                }
              }
            }
          },
          "files": {
            "type": "array",
            "description": "List of files to attach to the request",
            "items": {
              "type": "object",
              "required": ["file_id"],
              "properties": {
                "file_id": {
                  "type": "string",
                  "description": "The ID of the file to use"
                }
              }
            }
          },
          "include": {
            "type": "array",
            "description": "List of additional data to include in the response",
            "items": {
              "type": "string",
              "enum": ["web_search", "file_search", "code_interpreter.outputs"]
            }
          },
          "max_tokens": {
            "type": "integer",
            "description": "Maximum number of tokens to generate",
            "minimum": 1
          },
          "temperature": {
            "type": "number",
            "description": "Sampling temperature between 0 and 2",
            "minimum": 0,
            "maximum": 2,
            "default": 1
          },
          "stream": {
            "type": "boolean",
            "description": "Whether to stream the response",
            "default": false
          },
          "background": {
            "type": "boolean",
            "description": "Process request in background and notify via webhook",
            "default": false
          },
          "webhook_url": {
            "type": "string",
            "format": "uri",
            "description": "Webhook URL for background processing notifications"
          },
          "metadata": {
            "type": "object",
            "description": "Arbitrary metadata to attach to the request",
            "additionalProperties": true
          }
        }
      },
      "CreateResponseResponse": {
        "type": "object",
        "required": ["id", "object", "created", "model", "content"],
        "properties": {
          "id": {
            "type": "string",
            "description": "Unique identifier for the response"
          },
          "object": {
            "type": "string",
            "enum": ["response"],
            "description": "Object type, always 'response'"
          },
          "created": {
            "type": "integer",
            "description": "Unix timestamp of when the response was created"
          },
          "model": {
            "type": "string",
            "description": "The model used for generating the response"
          },
          "content": {
            "type": "string",
            "description": "The generated response content"
          },
          "conversation_id": {
            "type": "string",
            "description": "ID of the conversation if part of a conversation"
          },
          "tools_used": {
            "type": "array",
            "description": "List of tools that were used in generating the response",
            "items": {
              "type": "object",
              "properties": {
                "type": {
                  "type": "string",
                  "enum": ["web_search", "file_search", "code_interpreter"]
                },
                "result": {
                  "type": "object",
                  "description": "Tool execution result"
                }
              }
            }
          },
          "usage": {
            "$ref": "#/components/schemas/CompletionUsage"
          },
          "metadata": {
            "type": "object",
            "description": "Metadata attached to the request",
            "additionalProperties": true
          }
        }
      },
      "CreateResponseStreamResponse": {
        "type": "object",
        "required": ["id", "object", "created", "model", "delta"],
        "properties": {
          "id": {
            "type": "string",
            "description": "Unique identifier for the response"
          },
          "object": {
            "type": "string",
            "enum": ["response.chunk"],
            "description": "Object type, always 'response.chunk'"
          },
          "created": {
            "type": "integer",
            "description": "Unix timestamp of when the response was created"
          },
          "model": {
            "type": "string",
            "description": "The model used for generating the response"
          },
          "delta": {
            "type": "object",
            "description": "Incremental content update",
            "properties": {
              "content": {
                "type": "string",
                "description": "Content chunk",
                "nullable": true
              }
            }
          },
          "finish_reason": {
            "type": "string",
            "enum": ["stop", "length", "tool_calls", "content_filter"],
            "description": "Reason why the stream ended",
            "nullable": true
          }
        }
      },
      "CreateChatCompletionRequest": {
        "type": "object",
        "required": ["model", "messages"],
        "properties": {
          "model": {
            "type": "string",
            "description": "ID of the model to use",
            "example": ["openai/gpt-4.1", "openai/gpt-5"]
          },
          "messages": {
            "type": "array",
            "description": "A list of messages comprising the conversation so far",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionMessage"
            },
            "minItems": 1
          },
          "max_tokens": {
            "type": "integer",
            "description": "The maximum number of tokens to generate in the chat completion",
            "minimum": 1,
            "example": 300
          },
          "stream": {
            "type": "boolean",
            "description": "If set, partial message deltas will be sent as data-only server-sent events",
            "default": false
          },
          "tools": {
            "type": "array",
            "description": "A list of tools the model may call",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionTool"
            }
          },
          "tool_choice": {
            "oneOf": [
              {
                "type": "string",
                "enum": ["none", "auto"],
                "description": "Controls which (if any) tool is called by the model"
              },
              {
                "$ref": "#/components/schemas/ChatCompletionToolChoice"
              }
            ],
            "default": "auto"
          },
          "logprobs": {
            "type": "boolean",
            "description": "Whether to return log probabilities of the output tokens",
            "default": false
          },
          "top_logprobs": {
            "type": "integer",
            "description": "An integer between 0 and 20 specifying the number of most likely tokens to return at each token position",
            "minimum": 0,
            "maximum": 20
          },
          "modalities": {
            "type": "array",
            "description": "Output types the model should generate for this request",
            "items": {
              "type": "string",
              "enum": ["text", "audio"]
            }
          },
          "audio": {
            "type": "object",
            "description": "Parameters for audio output. Required when modalities includes audio",
            "properties": {
              "voice": {
                "type": "string",
                "description": "The voice to use for audio output"
              },
              "format": {
                "type": "string",
                "enum": ["wav", "mp3"],
                "description": "The output audio format"
              }
            }
          }
        }
      },
      "ChatCompletionTool": {
        "type": "object",
        "required": ["type", "function"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["function"]
          },
          "function": {
            "$ref": "#/components/schemas/FunctionDefinition"
          }
        }
      },
      "ChatCompletionMessage": {
        "type": "object",
        "required": ["role", "content"],
        "properties": {
          "role": {
            "type": "string",
            "enum": ["user", "assistant", "developer", "tool"],
            "description": "The role of the messages author"
          },
          "content": {
            "oneOf": [
              {
                "type": "string",
                "description": "The contents of the message"
              },
              {
                "type": "array",
                "description": "An array of content parts with a defined type",
                "items": {
                  "$ref": "#/components/schemas/ChatCompletionMessageContentPart"
                }
              }
            ]
          },
          "name": {
            "type": "string",
            "description": "An optional name for the participant"
          },
          "tool_calls": {
            "type": "array",
            "description": "The tool calls generated by the model",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionMessageToolCall"
            }
          },
          "tool_call_id": {
            "type": "string",
            "description": "Tool call that this message is responding to"
          }
        }
      },
      "ChatCompletionMessageContentPart": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/ChatCompletionMessageContentPartText"
          },
          {
            "$ref": "#/components/schemas/ChatCompletionMessageContentPartImage"
          },
          {
            "$ref": "#/components/schemas/ChatCompletionMessageContentPartFile"
          },
          {
            "$ref": "#/components/schemas/ChatCompletionMessageContentPartInputAudio"
          }
        ],
        "discriminator": {
          "propertyName": "type",
          "mapping": {
            "text": "#/components/schemas/ChatCompletionMessageContentPartText",
            "image_url": "#/components/schemas/ChatCompletionMessageContentPartImage",
            "file": "#/components/schemas/ChatCompletionMessageContentPartFile",
            "input_audio": "#/components/schemas/ChatCompletionMessageContentPartInputAudio"
          }
        }
      },
      "ChatCompletionMessageContentPartText": {
        "type": "object",
        "required": ["type", "text"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["text"]
          },
          "text": {
            "type": "string",
            "description": "The text content"
          }
        }
      },
      "ChatCompletionMessageContentPartImage": {
        "type": "object",
        "required": ["type", "image_url"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["image_url"]
          },
          "image_url": {
            "type": "object",
            "required": ["url"],
            "properties": {
              "url": {
                "type": "string",
                "format": "uri",
                "description": "Either a URL of the image or the base64 encoded image data"
              },
              "detail": {
                "type": "string",
                "enum": ["auto", "low", "high"],
                "description": "Specifies the detail level of the image",
                "default": "auto"
              }
            }
          }
        }
      },
      "ChatCompletionMessageContentPartFile": {
        "type": "object",
        "required": ["type", "file"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["file"]
          },
          "file": {
            "type": "object",
            "properties": {
              "file_data": {
                "type": "string",
                "description": "A base64-encoded data URL of the file (e.g. data:application/pdf;base64,...)"
              },
              "file_id": {
                "type": "string",
                "description": "A public URL to the file"
              }
            },
            "description": "Provide either file_data (base64 data URL) or file_id (public URL). Supported formats vary by model, e.g. PDF is broadly supported, while TXT/CSV/DOCX/XLSX support depends on the model."
          }
        }
      },
      "ChatCompletionMessageContentPartInputAudio": {
        "type": "object",
        "required": ["type", "input_audio"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["input_audio"]
          },
          "input_audio": {
            "type": "object",
            "required": ["data", "format"],
            "properties": {
              "data": {
                "type": "string",
                "description": "Base64-encoded audio data"
              },
              "format": {
                "type": "string",
                "enum": ["wav", "mp3"],
                "description": "The format of the encoded audio data"
              }
            }
          }
        }
      },
      "FunctionDefinition": {
        "type": "object",
        "required": ["name"],
        "properties": {
          "name": {
            "type": "string",
            "description": "The name of the function to be called"
          },
          "description": {
            "type": "string",
            "description": "A description of what the function does"
          },
          "parameters": {
            "type": "object",
            "description": "The parameters the functions accepts, described as a JSON Schema object"
          }
        }
      },
      "ChatCompletionToolChoice": {
        "type": "object",
        "required": ["type", "function"],
        "properties": {
          "type": {
            "type": "string",
            "enum": ["function"]
          },
          "function": {
            "type": "object",
            "required": ["name"],
            "properties": {
              "name": {
                "type": "string",
                "description": "The name of the function to call"
              }
            }
          }
        }
      },
      "ChatCompletionStreamChoice": {
        "type": "object",
        "required": ["index", "delta"],
        "properties": {
          "index": {
            "type": "integer",
            "description": "The index of the choice in the list of choices"
          },
          "delta": {
            "$ref": "#/components/schemas/ChatCompletionStreamChoiceDelta"
          },
          "finish_reason": {
            "type": "string",
            "enum": ["stop", "length", "tool_calls", "content_filter", "function_call"],
            "description": "The reason the model stopped generating tokens"
          },
          "logprobs": {
            "$ref": "#/components/schemas/ChatCompletionLogprobs"
          }
        }
      },
      "ChatCompletionLogprobs": {
        "type": "object",
        "properties": {
          "content": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionTokenLogprob"
            }
          }
        }
      },
      "ChatCompletionTokenLogprob": {
        "type": "object",
        "required": ["token", "logprob", "bytes", "top_logprobs"],
        "properties": {
          "token": {
            "type": "string",
            "description": "The token"
          },
          "logprob": {
            "type": "number",
            "description": "The log probability of this token"
          },
          "bytes": {
            "type": "array",
            "items": {
              "type": "integer"
            },
            "description": "A list of integers representing the UTF-8 bytes representation of the token"
          },
          "top_logprobs": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionTopLogprob"
            },
            "description": "List of the most likely tokens and their log probabilities"
          }
        }
      },
      "ChatCompletionTopLogprob": {
        "type": "object",
        "required": ["token", "logprob", "bytes"],
        "properties": {
          "token": {
            "type": "string",
            "description": "The token"
          },
          "logprob": {
            "type": "number",
            "description": "The log probability of this token"
          },
          "bytes": {
            "type": "array",
            "items": {
              "type": "integer"
            },
            "description": "A list of integers representing the UTF-8 bytes representation of the token"
          }
        }
      },
      "ChatCompletionStreamChoiceDelta": {
        "type": "object",
        "properties": {
          "role": {
            "type": "string",
            "enum": ["system", "user", "assistant", "tool"],
            "description": "The role of the author of this message"
          },
          "content": {
            "type": "string",
            "description": "The contents of the chunk message"
          },
          "tool_calls": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ChatCompletionMessageToolCallChunk"
            }
          }
        }
      },
      "ChatCompletionMessageToolCallChunk": {
        "type": "object",
        "required": ["index"],
        "properties": {
          "index": {
            "type": "integer",
            "description": "The index of the tool call in the tool calls array"
          },
          "id": {
            "type": "string",
            "description": "The ID of the tool call"
          },
          "type": {
            "type": "string",
            "enum": ["function"]
          },
          "function": {
            "type": "object",
            "properties": {
              "name": {
                "type": "string",
                "description": "The name of the function to call"
              },
              "arguments": {
                "type": "string",
                "description": "The arguments to call the function with, as generated by the model in JSON format"
              }
            }
          }
        }
      },
      "ChatCompletionMessageToolCall": {
        "type": "object",
        "required": ["id", "type", "function"],
        "properties": {
          "id": {
            "type": "string",
            "description": "The ID of the tool call"
          },
          "type": {
            "type": "string",
            "enum": ["function"]
          },
          "function": {
            "type": "object",
            "required": ["name", "arguments"],
            "properties": {
              "name": {
                "type": "string",
                "description": "The name of the function to call"
              },
              "arguments": {
                "type": "string",
                "description": "The arguments to call the function with, as generated by the model in JSON format"
              }
            }
          }
        }
      },
      "ChatCompletionChoice": {
        "type": "object",
        "properties": {
          "index": {
            "type": "integer"
          },
          "message": {
            "$ref": "#/components/schemas/ChatCompletionResponseMessage"
          },
          "finish_reason": {
            "type": "string",
            "enum": ["stop", "length", "function_call", "content_filter"]
          }
        },
        "required": ["index", "message", "finish_reason"]
      },
      "ChatCompletionResponseMessage": {
        "type": "object",
        "properties": {
          "role": {
            "type": "string",
            "enum": ["assistant"]
          },
          "content": {
            "type": "string"
          },
          "function_call": {
            "$ref": "#/components/schemas/ChatCompletionMessageFunctionCall"
          }
        },
        "required": ["role"]
      },
      "CreateCompletionRequest": {
        "type": "object",
        "properties": {
          "model": {
            "type": "string",
            "description": "ID of the model to use"
          },
          "prompt": {
            "description": "The prompt(s) to generate completions for"
          }
        },
        "required": ["model", "prompt"]
      },
      "CreateCompletionResponse": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "object": {
            "type": "string",
            "enum": ["text_completion"]
          },
          "created": {
            "type": "integer"
          },
          "model": {
            "type": "string"
          },
          "choices": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/CompletionChoice"
            }
          },
          "usage": {
            "$ref": "#/components/schemas/CompletionUsage"
          }
        },
        "required": ["id", "object", "created", "model", "choices"]
      },
      "CompletionChoice": {
        "type": "object",
        "properties": {
          "text": {
            "type": "string"
          },
          "index": {
            "type": "integer"
          },
          "logprobs": {
            "type": "object",
            "properties": {
              "tokens": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "token_logprobs": {
                "type": "array",
                "items": {
                  "type": "number"
                }
              },
              "top_logprobs": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": {
                    "type": "number"
                  }
                }
              },
              "text_offset": {
                "type": "array",
                "items": {
                  "type": "integer"
                }
              }
            }
          },
          "finish_reason": {
            "type": "string",
            "enum": ["stop", "length", "content_filter"]
          }
        },
        "required": ["text", "index", "finish_reason"]
      },
      "CreateTranscriptionRequest": {
        "type": "object",
        "properties": {
          "file": {
            "type": "string",
            "format": "binary",
            "description": "The audio file object to transcribe"
          },
          "model": {
            "type": "string",
            "description": "ID of the model to use",
            "enum": ["whisper-1"]
          },
          "language": {
            "type": "string",
            "description": "The language of the input audio"
          },
          "prompt": {
            "type": "string",
            "description": "An optional text to guide the model's style or continue a previous audio segment"
          },
          "response_format": {
            "type": "string",
            "enum": ["json", "text", "srt", "verbose_json", "vtt"],
            "default": "json",
            "description": "The format of the transcript output"
          },
          "temperature": {
            "type": "number",
            "minimum": 0,
            "maximum": 1,
            "default": 0,
            "description": "The sampling temperature, between 0 and 1"
          }
        },
        "required": ["file", "model"]
      },
      "CreateTranscriptionResponse": {
        "type": "object",
        "properties": {
          "text": {
            "type": "string",
            "description": "The transcribed text"
          }
        },
        "required": ["text"]
      },
      "ListModelsResponse": {
        "type": "object",
        "properties": {
          "object": {
            "type": "string",
            "enum": ["list"]
          },
          "data": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Model"
            }
          }
        },
        "required": ["object", "data"]
      },
      "Model": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "The model identifier"
          },
          "object": {
            "type": "string",
            "enum": ["model"],
            "description": "The object type"
          },
          "created": {
            "type": "integer",
            "description": "The Unix timestamp (in seconds) when the model was created"
          },
          "owned_by": {
            "type": "string",
            "description": "The organization that owns the model"
          }
        },
        "required": ["id", "object", "created", "owned_by"]
      },
      "CompletionUsage": {
        "type": "object",
        "properties": {
          "completion_tokens": {
            "type": "integer",
            "description": "Number of tokens in the generated completion"
          },
          "prompt_tokens": {
            "type": "integer",
            "description": "Number of tokens in the prompt"
          },
          "total_tokens": {
            "type": "integer",
            "description": "Total number of tokens used in the request"
          }
        },
        "required": ["completion_tokens", "prompt_tokens", "total_tokens"]
      },
      "Error": {
        "type": "object",
        "properties": {
          "error": {
            "type": "object",
            "properties": {
              "code": {
                "type": "string"
              },
              "message": {
                "type": "string"
              },
              "param": {
                "type": "string"
              },
              "type": {
                "type": "string"
              }
            },
            "required": ["message", "type"]
          }
        },
        "required": ["error"]
      },
      "ErrorResponse": {
        "type": "object",
        "required": ["error"],
        "properties": {
          "error": {
            "type": "object",
            "required": ["message", "type"],
            "properties": {
              "message": {
                "type": "string",
                "description": "A human-readable error message"
              },
              "type": {
                "type": "string",
                "description": "The type of error"
              },
              "code": {
                "type": "string",
                "description": "An error code identifying the error type"
              }
            }
          }
        }
      }
    }
  },
  "tags": [
    {
      "name": "Text",
      "description": "Generate text completions"
    },
    {
      "name": "Images",
      "description": "Generate and manipulate images"
    },
    {
      "name": "Audio",
      "description": "Generate speech and transcribe audio"
    },
    {
      "name": "Music",
      "description": "List and retrieve model information"
    },
    {
      "name": "Video",
      "description": "Create vector embeddings for text"
    },
    {
      "name": "Vision",
      "description": "Create vector embeddings for text"
    },
    {
      "name": "3D Models",
      "description": "Create vector embeddings for text"
    },
    {
      "name": "Embeddings",
      "description": "Create vector embeddings for text"
    },
    {
      "name": "Batches",
      "description": "Batches"
    },
    {
      "name": "Moderation",
      "description": "Moderation"
    },
    {
      "name": "Other",
      "description": "Other models"
    }
  ]
}



