Gemini 2.5 Pro (openai)

Streaming Support

When stream: true is set in the request, the API returns responses as server-sent events (SSE) with Content-Type: text/event-stream. This allows for progressive response delivery, where message deltas are sent incrementally as they are generated. Each event contains partial message content, enabling real-time display of responses in your application.

Streaming Response Format:

• Content-Type: text/event-stream
• Each event line starts with data: followed by JSON
• Events contain incremental message deltas
• Final event indicates completion with finish_reason
• The stream ends with a chunk carrying usage and credits_consumed, followed by data: [DONE].

Text, image, video, audio and PDF input Google Search grounding enabled Server-sent events support Multiple message roles supported

Tools Parameter

The tools parameter is an optional array that allows you to define functions the model can call. The array can contain multiple objects. When using function calling, you can define multiple functions in the array.

Use this format to enable Google Search grounding:

{
  "type": "function",
  "function": {
    "name": "googleSearch"
  }
}

This enables real-time information retrieval via Google Search.

Define your own functions with parameters. You can define multiple functions in the `tools` array:

[
  {
    "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"]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "get_stock_price",
      "description": "Get the current stock price for a given symbol",
      "parameters": {
        "type": "object",
        "properties": {
          "symbol": {
            "type": "string",
            "description": "The stock symbol, e.g. AAPL"
          }
        },
        "required": ["symbol"]
      }
    }
  }
]

Function Declaration Requirements

When implementing function calling in your prompt, you need to create a tools array containing one or more function declarations. You can define functions using JSON (specifically, a selected subset of OpenAPI schema format).

A single function declaration can include the following parameters:

• name (string, required): The unique name of the function (e.g., get_weather_forecast, send_email). Use descriptive names without spaces or special characters (use underscores or camelCase).

• description (string, optional but recommended): A clear and detailed description of what the function does and its purpose. This is crucial for the model to understand when to use the function. Be specific and provide examples when necessary (e.g., "Find movie theaters by location, with an option to also find movies currently showing at those theaters.").

• parameters (object, required): Defines the input parameters expected by the function. Contains:

  • type (string): Specifies the overall data type, must be "object".
  • properties (object): Lists individual parameters, each with:
    • type (string): The parameter's data type, such as string, integer, boolean, array.
    • description (string): Description of the parameter's purpose and format. Provide examples and constraints (e.g., "City and state, e.g. 'San Francisco, CA' or a postal code like '95616'.").
    • enum (array, optional): If parameter values come from a fixed set, use enum to list allowed values rather than just describing them in the description. This helps improve accuracy (e.g., "enum": ["daylight", "cool", "warm"]).
  • required (array): An array of strings listing the parameter names required for the function to run.

Response Format Parameter

The response_format parameter is an optional JSON Schema object that defines the structure of the response. When provided, the model will generate responses that conform to this schema.

The `response_format` follows the JSON Schema specification. Supported types include:

• string: For text values
• number: For floating-point numbers
• integer: For whole numbers
• boolean: For true/false values
• object: For structured data with key-value pairs
• array: For lists of items
• null: To allow null values, add "null" to the type array (e.g., {"type": ["string", "null"]})

Type-Specific Properties

For object values:

• properties: Object mapping property names to their schema definitions
• required: Array of required property names
• additionalProperties: Controls whether properties not in properties are allowed

For string values:

• enum: List of specific possible string values for classification
• format: Specifies string syntax (e.g., date-time, date, time)

For number and integer values:

• enum: List of specific possible numeric values
• minimum: Inclusive minimum value
• maximum: Inclusive maximum value

For array values:

• items: Schema definition for all array elements
• prefixItems: List of schemas for the first N items (tuple-like structures)
• minItems: Minimum number of items in the array
• maxItems: Maximum number of items in the array

```json { "response_format": { "type": "json_schema", "json_schema": { "name": "structured_output", "strict": true, "schema": { "type": "object", "properties": { "response": { "type": "string" } }, "required": [ "response" ] } } } } ```

{"type":"json_object"} is also supported.

- **Clear descriptions**: Use the `description` field in the schema to clearly explain what each property means - **Strong typing**: Use specific types (`integer`, `string`, `enum`) whenever possible - **Prompt engineering**: Clearly state in your prompt what you want the model to extract or structure - **Validation**: While structured output ensures JSON is syntactically correct, always validate the semantic correctness of values in your application code

Error Responses

Errors are returned with HTTP 200 and a JSON body {"code": , "msg": ""}. Check code (200 = success) before reading choices/candidates.