# Gemini 4 Argon (`google/gemini-4-argon`): API

> google/gemini-4-argon is a language model from Google you can call on the OceanToken API, with a 1.05M-token context window and up to 66K output tokens; it supports reasoning, tool calling, image input, video input, audio input, file input.

Endpoint: `POST https://api.oceantoken.ai/v1/chat/completions` (also `/v1/responses` and `/v1/messages`). Auth: `Authorization: Bearer $OCEANTOKEN_API_KEY`. OpenAI-compatible; the OpenAI SDKs work with base URL https://api.oceantoken.ai/v1.

## Request parameters

- `model` (string; required): This model's ID.
- `messages` (array; required): The conversation so far: objects with a `role` (`system`, `user`, `assistant` or `tool`) and a `content`, a string or a list of content parts: text, and images, video, audio or files on models that take them.
- `stream` (boolean; default false): Send the answer as server-sent events as it is written.
- `stream_options` (object): With `stream`: `{"include_usage": true}` adds a last event with the token counts.
- `max_tokens` (integer; 1 to 65536): The most tokens to write, reasoning included. `max_completion_tokens` is accepted as the same thing.
- `temperature` (number; 0 to 2): Randomness: lower is more focused, higher more varied.
- `top_p` (number; 0 to 1): Nucleus sampling: only the most likely tokens whose probabilities add up to this are considered.
- `stop` (string or array): Up to 4 strings; the answer ends before any of them.
- `response_format` (object; json_object, json_schema): `{"type": "json_object"}` for JSON output, or `{"type": "json_schema", "json_schema": {"name": ..., "schema": {...}}}` for output that matches your schema.
- `tools` (array): Functions the model may call: `{"type": "function", "function": {"name", "description", "parameters"}}`.
- `tool_choice` (string or object): `auto` (default), `none`, `required`, or `{"type": "function", "function": {"name": ...}}`.
- `user` (string): Your own ID for the end user, for your records.

## Gemini options

- `media_resolution` (string; MEDIA_RESOLUTION_LOW, MEDIA_RESOLUTION_MEDIUM, MEDIA_RESOLUTION_HIGH): Detail for every image and video frame in the request. A video frame is about 70 tokens at low and medium and 280 at high.

## Message content parts

Besides plain text, `messages[].content` can be a list of parts:

### `image_url`

An image, as a public https:// URL or a data URL.

- `image_url.url` (string; required): https:// URL or `data:image/...;base64,...`.

```json
{"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}
```

### `file`

A document such as a PDF, by URL or as base64.

- `file.file_data` (string; required): A data URL or an https:// URL.

```json
{"type":"file","file":{"file_data":"data:application/pdf;base64,...","filename":"report.pdf"}}
```

### `input_audio`

Audio, base64-encoded.

- `input_audio.data` (string; required): The audio, base64-encoded.
- `input_audio.format` (string; required; mp3, wav): The audio format.

```json
{"type":"input_audio","input_audio":{"data":"<base64>","format":"mp3"}}
```

### `video_url`

A video, as a public https:// URL (a YouTube link works on models that take one) or a data URL.

- `video_url.url` (string; required): https:// URL or `data:video/mp4;base64,...`.
- `video_url.processing` (string; static, agentic; default "static"): `agentic` lets the model look at the parts of a long video it needs, again and in more detail. It loads extra frames as input tokens, so it costs more on short clips; meant for videos of 5 to 10 minutes or longer.

```json
{"type":"video_url","video_url":{"url":"https://example.com/clip.mp4"}}
```

## Example: Video input

```bash
curl https://api.oceantoken.ai/v1/chat/completions \
  -H "Authorization: Bearer $OCEANTOKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "google/gemini-4-argon",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "What happens in this video?"
        },
        {
          "type": "video_url",
          "video_url": {
            "url": "https://example.com/clip.mp4"
          }
        }
      ]
    }
  ],
  "media_resolution": "MEDIA_RESOLUTION_LOW"
}'
```

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://api.oceantoken.ai/v1", api_key=os.environ["OCEANTOKEN_API_KEY"])
response = client.chat.completions.create(
    model="google/gemini-4-argon",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What happens in this video?"},
                {
                    "type": "video_url",
                    "video_url": {"url": "https://example.com/clip.mp4"},
                },
            ],
        },
    ],
    extra_body={"media_resolution": "MEDIA_RESOLUTION_LOW"},
)
print(response.choices[0].message.content)
```

## Response

- `id` (string): The request's ID.
- `choices[].message.content` (string): The answer.
- `choices[].message.reasoning_content` (string): The model's reasoning, on models that return it.
- `choices[].message.tool_calls` (array): The tools the model wants called, with JSON arguments.
- `choices[].finish_reason` (string): `stop`, `length` (hit max_tokens), `tool_calls` or `content_filter`.
- `usage.prompt_tokens` (integer): Input tokens, media included.
- `usage.completion_tokens` (integer): Output tokens, reasoning included.
- `usage.prompt_tokens_details.cached_tokens` (integer): Input tokens read from the prompt cache.
- `usage.completion_tokens_details.reasoning_tokens` (integer): Output tokens spent reasoning.

With `stream: true`, `chat.completion.chunk` events carry `choices[].delta`; the stream ends with `data: [DONE]`.

```json
{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1792000000,
  "model": "google/gemini-4-argon",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "...",
        "reasoning_content": null,
        "tool_calls": null
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 20,
    "total_tokens": 32,
    "prompt_tokens_details": {
      "cached_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0
    }
  }
}
```

## More

- Model page: https://docs.oceantoken.ai/models/google/gemini-4-argon
- This spec as JSON (with a JSON Schema of the request): https://docs.oceantoken.ai/models/google/gemini-4-argon/spec.json
- Guide: https://docs.oceantoken.ai/guides/text
- All models: https://docs.oceantoken.ai/llms.txt