# Gemini generateContent API — 内容生成

Source: https://ofox.io/zh/docs/api/gemini/generate-content

通过 Gemini 原生协议调用 Google Gemini 模型。OfoxAI 兼容 Google GenAI SDK。

## 端点

```http
POST https://api.ofox.io/gemini/v1beta/models/{model}:generateContent
POST https://api.ofox.io/gemini/v1beta/models/{model}:streamGenerateContent
```

## 认证

Gemini 协议使用 `x-goog-api-key` Header：

```bash
x-goog-api-key: <你的 OFOXAI_API_KEY>
```

## 请求示例

**cURL**

```bash filename="Terminal"
curl "https://api.ofox.io/gemini/v1beta/models/google/gemini-3.8-flash:generateContent" \
  -H "x-goog-api-key: $OFOX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "parts": [{"text": "用 Python 实现一个简单的 Web 服务器"}]
      }
    ]
  }'
```

**Python**

```python filename="gemini_chat.py" showLineNumbers
from google import genai

client = genai.Client(
    api_key="<你的 OFOXAI_API_KEY>",
    http_options={"api_version": "v1beta", "base_url": "https://api.ofox.io/gemini",}
)

response = client.models.generate_content(
    model="google/gemini-3.8-flash",
    contents="用 Python 实现一个简单的 Web 服务器"
)

print(response.text)
```

**TypeScript**

```typescript filename="gemini_chat.ts" showLineNumbers
import { GoogleGenAI } from '@google/genai'

const ai = new GoogleGenAI({
  apiKey: '<你的 OFOXAI_API_KEY>',
  httpOptions: {
    apiVersion: 'v1beta',
    baseUrl: 'https://api.ofox.io/gemini',
  }
})

const response = await ai.models.generateContent({
  model: 'google/gemini-3.8-flash',
  contents: '用 Python 实现一个简单的 Web 服务器'
})

console.log(response.text)
```

## 流式响应

**Python**

```python filename="gemini_stream.py" showLineNumbers
response = client.models.generate_content_stream(
    model="google/gemini-3.8-flash",
    contents="写一篇关于 AI 的文章"
)

for chunk in response:
    print(chunk.text, end="", flush=True)
```

**TypeScript**

```typescript filename="gemini_stream.ts" showLineNumbers
const response = await ai.models.generateContentStream({
  model: 'google/gemini-3.8-flash',
  contents: '写一篇关于 AI 的文章'
})

for await (const chunk of response) {
  process.stdout.write(chunk.text())
}
```

## 多模态输入

Gemini 原生支持多模态输入，包括图像、音频和视频：

```python
import base64

# 图像分析
with open("photo.jpg", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.models.generate_content(
    model="google/gemini-3.8-flash",
    contents=[
        {"text": "描述这张图片的内容"},
        {"inline_data": {"mime_type": "image/jpeg", "data": image_data}}
    ]
)
```

## 生成与编辑图像

Gemini 原生协议下，`generateContent` 一个端点同时承担生图（text → image）与图像编辑（image + text → image）。推荐模型 `google/gemini-3.1-flash-image`。

```http
POST https://api.ofox.io/gemini/v1beta/models/google/gemini-3.1-flash-image:generateContent
```

也可通过 [OpenAI 兼容端点](https://ofox.io/zh/docs/api/openai/images) 调用同一模型来生图，但**图像编辑能力仅在 Gemini 原生协议下可用**。

### 生图：text → image

**Python**

```python filename="gen.py"
from google import genai

client = genai.Client(
    api_key="YOUR_OFOX_API_KEY",
    http_options={"api_version": "v1beta", "base_url": "https://api.ofox.io/gemini"},
)

resp = client.models.generate_content(
    model="google/gemini-3.1-flash-image",
    contents="A simple red apple on a white table, photorealistic",
)

for part in resp.candidates[0].content.parts:
    if part.inline_data and part.inline_data.data:
        with open("output.png", "wb") as f:
            f.write(part.inline_data.data)
        break
```

**TypeScript**

```typescript filename="gen.ts"
import { GoogleGenAI } from '@google/genai'
import fs from 'node:fs'

const ai = new GoogleGenAI({
  apiKey: 'YOUR_OFOX_API_KEY',
  httpOptions: { apiVersion: 'v1beta', baseUrl: 'https://api.ofox.io/gemini' },
})

const resp = await ai.models.generateContent({
  model: 'google/gemini-3.1-flash-image',
  contents: 'A simple red apple on a white table, photorealistic',
})

for (const part of resp.candidates![0].content!.parts!) {
  if (part.inlineData?.data) {
    fs.writeFileSync('output.png', Buffer.from(part.inlineData.data, 'base64'))
    break
  }
}
```

**cURL**

```bash filename="Terminal"
curl -X POST 'https://api.ofox.io/gemini/v1beta/models/google/gemini-3.1-flash-image:generateContent' \
  -H 'x-goog-api-key: YOUR_OFOX_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [
      { "parts": [{ "text": "A simple red apple on a white table, photorealistic" }] }
    ]
  }'
```

实测输出：

![Gemini 原生协议生成的红苹果](https://ofox.io/screenshots/images-api/example-gemini-flash-image-generated.webp)

### 编辑：image + text → image

把原图以 `inlineData` 与文本指令一起放进 `parts` 即可：

**Python**

```python filename="edit.py"
from google import genai
from google.genai import types

client = genai.Client(
    api_key="YOUR_OFOX_API_KEY",
    http_options={"api_version": "v1beta", "base_url": "https://api.ofox.io/gemini"},
)

with open("apple.png", "rb") as f:
    image_bytes = f.read()

resp = client.models.generate_content(
    model="google/gemini-3.1-flash-image",
    contents=[
        "把苹果改成绿色，其他保持不变",
        types.Part.from_bytes(data=image_bytes, mime_type="image/png"),
    ],
)

for part in resp.candidates[0].content.parts:
    if part.inline_data and part.inline_data.data:
        with open("apple_edited.png", "wb") as out:
            out.write(part.inline_data.data)
        break
```

**TypeScript**

```typescript filename="edit.ts"
import { GoogleGenAI } from '@google/genai'
import fs from 'node:fs'

const ai = new GoogleGenAI({
  apiKey: 'YOUR_OFOX_API_KEY',
  httpOptions: { apiVersion: 'v1beta', baseUrl: 'https://api.ofox.io/gemini' },
})

const imageBase64 = fs.readFileSync('apple.png').toString('base64')

const resp = await ai.models.generateContent({
  model: 'google/gemini-3.1-flash-image',
  contents: [{
    parts: [
      { text: '把苹果改成绿色，其他保持不变' },
      { inlineData: { mimeType: 'image/png', data: imageBase64 } },
    ],
  }],
})

for (const part of resp.candidates![0].content!.parts!) {
  if (part.inlineData?.data) {
    fs.writeFileSync('apple_edited.png', Buffer.from(part.inlineData.data, 'base64'))
    break
  }
}
```

**cURL**

```bash filename="Terminal"
IMG_B64=$(base64 -i apple.png)

curl -X POST 'https://api.ofox.io/gemini/v1beta/models/google/gemini-3.1-flash-image:generateContent' \
  -H 'x-goog-api-key: YOUR_OFOX_API_KEY' \
  -H 'Content-Type: application/json' \
  -d "{
    \"contents\": [{
      \"parts\": [
        { \"text\": \"把苹果改成绿色，其他保持不变\" },
        { \"inlineData\": { \"mimeType\": \"image/png\", \"data\": \"$IMG_B64\" } }
      ]
    }]
  }"
```

实测对比：

| 原图 | 编辑后 |
|------|--------|
| ![原始红苹果](https://ofox.io/screenshots/images-api/example-gemini-flash-image-generated.webp) | ![编辑后的绿苹果](https://ofox.io/screenshots/images-api/example-gemini-flash-image-edited.webp) |

### 响应

```json
{
  "candidates": [{
    "content": {
      "role": "model",
      "parts": [
        { "text": "...", "thought": true },
        { "inlineData": { "mimeType": "image/png", "data": "<图片 Base64>" } }
      ]
    },
    "finishReason": "STOP"
  }],
  "modelVersion": "google/gemini-3.1-flash-image",
  "usageMetadata": {
    "promptTokenCount": 1097,
    "candidatesTokenCount": 1120,
    "thoughtsTokenCount": 1306,
    "totalTokenCount": 3523,
    "candidatesTokensDetails": [
      { "modality": "IMAGE", "tokenCount": 1120 }
    ]
  }
}
```

- 图片在 `candidates[0].content.parts[].inlineData.data`，是 Base64 字符串
- `parts` 中可能混杂若干 `text` + `thought: true` 的思考过程，遍历时只取 `inlineData`
- `usageMetadata.candidatesTokensDetails` 中 `modality: IMAGE` 的 `tokenCount` 是图像输出消耗

## 支持的模型

下表仅列举常用代表，**完整可用模型清单**见：

- 编程接口：[GET /gemini/v1beta/models](https://ofox.io/zh/docs/api/gemini/models) — 实时查询当前账户在网关上可用的模型
- 浏览页面：[模型目录](https://ofox.io/zh/models) — 可视化检索，含定价

| 模型 | 说明 |
|------|------|
| `google/gemini-3.1-pro-preview` | Gemini 3.1 Pro — 最强推理能力 |
| `google/gemini-3.8-flash` | Gemini 3.8 Flash — 速度与能力均衡 |
| `google/gemini-3.5-flash-lite` | Gemini 3.5 Flash Lite — 高速高性价比 |
| `google/gemini-3.1-flash-image` | Gemini 3.1 Flash Image — 图像生成与编辑 |

OfoxAI 的 Gemini 协议支持 Google GenAI SDK 的主要功能，包括 Function Calling、Code Execution、Grounding、图像生成与编辑等。