# Gemini 3.7 Flash

> Reasoning-first flagship text model for coding and agentic work, with tunable thinking levels, tool calling and streaming over an OpenAI-compatible endpoint.

## Overview

- **Endpoint**: `https://queue.modelrunner.run/google/gemini-3.7-flash`
- **Model ID**: `google/gemini-3.7-flash`
- **Category**: text-to-text
- **Kind**: inference
- **Tags**: gemini, gemini-3.7, flash, llm, text-to-text, chat, chat-completions, openai-compatible, reasoning, thinking, agentic, coding, streaming, tool-calling, json-mode

## Pricing

- **Input tokens**: $2.1 per 1M
- **Cached input tokens**: $0.21 per 1M
- **Output tokens**: $10.5 per 1M

## Request Lifecycle

This model runs on the ModelRunner **asynchronous queue API** — a single POST does not return the output. Every call requires an `Authorization: Key $MODEL_RUNNER_KEY` header. Run three steps:

1. **Submit** — `POST https://queue.modelrunner.run/google/gemini-3.7-flash` with a JSON body holding the input fields at the top level. The body may also include a reserved top-level `metadata` object — a flat string map (max 16 keys, key ≤64 / value ≤512 chars) stored on the request for your own tagging. It is never sent to the model; filter your request history with `GET https://queue.modelrunner.run/requests?metadata=<url-encoded JSON>` (exact key=value matches, AND-ed). The response carries request handles only (no output yet):

```json
{
  "status": "IN_QUEUE",
  "request_id": "<21-char id>",
  "status_url": "https://queue.modelrunner.run/google/gemini-3.7-flash/requests/<request_id>/status",
  "response_url": "https://queue.modelrunner.run/google/gemini-3.7-flash/requests/<request_id>",
  "cancel_url": "https://queue.modelrunner.run/google/gemini-3.7-flash/requests/<request_id>/cancel"
}
```

2. **Poll status** — `GET <status_url>` until `status` is `COMPLETED`. Possible values are `IN_QUEUE`, `IN_PROGRESS`, `COMPLETED`, `FAILED`, `CANCELLED`. A `FAILED` request responds with HTTP 400 and an `error` field.

3. **Read result** — `GET <response_url>`. Returns the finished request, including the generated `output`:

```json
{ "id": "<request_id>", "status": "COMPLETED", "output": ..., "input": ... }
```

The JavaScript and Python SDKs below perform steps 2–3 for you. In any language without an SDK (Swift, Go, Kotlin, etc.) you must implement the polling loop and the final result fetch yourself — see the cURL example for the full flow.

### Input Schema

- **`seed`** (`integer`, _optional_):
  Best-effort determinism hint.

- **`stop`** (`unknown`, _optional_):
  Up to 4 stop sequences.

- **`tools`** (`array<object>`, _optional_):
  OpenAI-format tool definitions the model may call.

- **`stream`** (`boolean`, _optional_):
  Return the reply as a Server-Sent Events stream of deltas terminated by \`data: \[DONE\]\`.
  - Default: `false`

- **`messages`** (`array<object>`, _required_):
  OpenAI-style conversation history. Each item is an object with a \`role\` (\`system\`, \`user\`, \`assistant\` or \`tool\`) and \`content\`.

- **`max_tokens`** (`integer`, _optional_):
  Upper bound on generated tokens. Thinking consumes this budget, so allow generous headroom.
  - Range: `1` to `"+inf"`

- **`tool_choice`** (`unknown`, _optional_):
  \`auto\`, \`none\`, \`required\`, or a specific tool.

- **`response_format`** (`object`, _optional_):
  Set \`{"type":"json_object"}\` for JSON mode.

- **`reasoning_effort`** (`string`, _optional_):
  How much the model thinks before answering. Thinking tokens bill as output tokens.
  - Default: `"medium"`
  - Options: `"low"`, `"medium"`, `"high"`

### Output Schema

- **`id`** (`string`, _optional_):

- **`model`** (`string`, _optional_):

- **`usage`** (`object`, _optional_):

- **`object`** (`string`, _optional_):

- **`choices`** (`array<object>`, _optional_):

- **`created`** (`integer`, _optional_):

## Default Example

**Input**

```json
{
  "messages": [
    {
      "role": "user",
      "content": "A function is supposed to return the k-th largest element of an unsorted list. This implementation is subtly wrong: def kth(nums, k): return sorted(nums)[k]. Find every bug, explain why each is wrong, and give a corrected version with its time complexity."
    }
  ],
  "max_tokens": 8000,
  "reasoning_effort": "high"
}
```

**Output**

```json
{
  "id": "chatcmpl-09TWMsiJF9xVoSoeRqdWw",
  "model": "google/gemini-3.7-flash",
  "usage": {
    "total_tokens": 2081,
    "prompt_tokens": 58,
    "completion_tokens": 663,
    "completion_tokens_details": {
      "reasoning_tokens": 1360
    }
  },
  "object": "chat.completion",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Here is the breakdown of the bugs in the implementation, why they occur, and the corrected solutions.\n\n---\n\n### **Bugs Identified**\n\n1. **Sort Direction (Ascending instead of Descending):**\n   * **Why it's wrong:** `sorted(nums)` sorts the list in **ascending** order (smallest to largest). Accessing an index from the beginning gives the smallest elements, not the largest.\n\n2. **1-based vs. 0-based Indexing (Off-by-One Error):**\n   * **Why it's wrong:** Natural language definitions of \"$k$-th largest\" use 1-based indexing (e.g., $k=1$ is the 1st largest / maximum). \n   * In Python, lists are 0-indexed. Passing $k=1$ to `sorted(nums)[1]` returns the *2nd smallest* element rather than the *1st largest*.\n\n3. **Index Out of Bounds on Boundary Value ($k = \\text{len}(nums)$):**\n   * **Why it's wrong:** If a caller asks for the $N$-th largest element of a list with length $N$ (i.e., the absolute smallest element), accessing index `[N]` will raise an `IndexError` because valid indices are `0` through `N - 1`.\n\n---\n\n### **Corrected Implementations**\n\n#### **1. Direct Fix (Sorting Approach)**\nUsing negative indexing (`-k`), which directly accesses the $k$-th element from the end of an ascending list:\n\n```python\ndef kth_largest(nums: list[int], k: int) -> int:\n    if not 1 <= k <= len(nums):\n        raise IndexError(\"k must be between 1 and len(nums)\")\n    return sorted(nums)[-k]\n```\n*(Alternatively: `return sorted(nums, reverse=True)[k - 1]`)*\n\n* **Time Complexity:** $\\mathcal{O}(N \\log N)$, where $N$ is the number of elements in `nums` (due to Timsort).\n* **Space Complexity:** $\\mathcal{O}(N)$ to store the sorted array.\n\n---\n\n#### **2. Optimal Standard Library Fix (Min-Heap / `heapq`)**\nIf efficiency is important, finding the $k$-th largest element does not require sorting the entire list:\n\n```python\nimport heapq\n\n\ndef kth_largest(nums: list[int], k: int) -> int:\n    if not 1 <= k <= len(nums):\n        raise IndexError(\"k must be between 1 and len(nums)\")\n    return heapq.nlargest(k, nums)[-1]\n```\n\n* **Time Complexity:** $\\mathcal{O}(N \\log k)$, which is much faster than sorting when $k \\ll N$.\n* **Space Complexity:** $\\mathcal{O}(k)$ to maintain the heap.\n\n*(Note: For $\\mathcal{O}(N)$ average time complexity, the **Quickselect** algorithm can also be used).*",
        "extra_content": {
          "upstream": {
            "thought_signature": "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"
          }
        }
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "created": 1786739870
}
```
## Usage Examples

### cURL

The queue API is asynchronous: submit the request, poll `status_url` until it is `COMPLETED`, then read the result from `response_url`. Requires `jq`.

```bash
# 1. Submit the request (returns request handles, not the output)
SUBMIT=$(curl --silent --request POST \
  --url https://queue.modelrunner.run/google/gemini-3.7-flash \
  --header "Authorization: Key $MODEL_RUNNER_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "messages": [
    {
      "role": "user",
      "content": "A function is supposed to return the k-th largest element of an unsorted list. This implementation is subtly wrong: def kth(nums, k): return sorted(nums)[k]. Find every bug, explain why each is wrong, and give a corrected version with its time complexity."
    }
  ],
  "max_tokens": 8000,
  "reasoning_effort": "high"
}')

STATUS_URL=$(echo "$SUBMIT" | jq -r '.status_url')
RESPONSE_URL=$(echo "$SUBMIT" | jq -r '.response_url')

# 2. Poll until the request leaves the queue / in-progress state
while true; do
  STATUS=$(curl --silent --url "$STATUS_URL" \
    --header "Authorization: Key $MODEL_RUNNER_KEY" | jq -r '.status')
  echo "Status: $STATUS"
  case "$STATUS" in
    COMPLETED) break ;;
    FAILED|CANCELLED) echo "Request $STATUS"; exit 1 ;;
  esac
  sleep 1
done

# 3. Read the finished request, including the generated output
curl --silent --url "$RESPONSE_URL" \
  --header "Authorization: Key $MODEL_RUNNER_KEY"
```

### JavaScript

```javascript
import { modelrunner } from "@modelrunner/client";

const result = await modelrunner.subscribe("google/gemini-3.7-flash", {
  input: {
  "messages": [
    {
      "role": "user",
      "content": "A function is supposed to return the k-th largest element of an unsorted list. This implementation is subtly wrong: def kth(nums, k): return sorted(nums)[k]. Find every bug, explain why each is wrong, and give a corrected version with its time complexity."
    }
  ],
  "max_tokens": 8000,
  "reasoning_effort": "high"
}
});

console.log(result.data);
```

### Python

```python
import asyncio
import modelrunner_ai

async def main():
    response = await modelrunner_ai.submit_async(
        "google/gemini-3.7-flash",
        arguments={
  "messages": [
    {
      "role": "user",
      "content": "A function is supposed to return the k-th largest element of an unsorted list. This implementation is subtly wrong: def kth(nums, k): return sorted(nums)[k]. Find every bug, explain why each is wrong, and give a corrected version with its time complexity."
    }
  ],
  "max_tokens": 8000,
  "reasoning_effort": "high"
}
    )
    result = await response.get()
    print(result["output"])

asyncio.run(main())
```

## Additional Resources

- [Playground](https://modelrunner.ai/models/google/gemini-3.7-flash)
- [OpenAPI Schema](https://modelrunner.ai/models/google/gemini-3.7-flash/openapi.json)
- [LLM Instructions](https://modelrunner.ai/models/google/gemini-3.7-flash/llms.txt)