Anthropic兼容-Messages

更新时间:
复制为 MD 格式

通过兼容 Anthropic 格式的 Messages API 调用模型,查看输入输出参数说明及调用示例。

通过修改以下配置,即可将原有的 Anthropic 应用迁移至阿里云百炼:

  • api_key:替换为百炼 API Key

  • base_url:替换为百炼的兼容端点地址(见下方接入信息)。

  • model:替换为百炼支持的模型名称(例如 qwen3.6-plus)。

华北2(北京)

SDK 调用配置的 base_urlhttps://dashscope.aliyuncs.com/apps/anthropic

HTTP 请求地址:POST https://dashscope.aliyuncs.com/apps/anthropic/v1/messages

新加坡

SDK 调用配置的 base_urlhttps://dashscope-intl.aliyuncs.com/apps/anthropic

HTTP 请求地址:POST https://dashscope-intl.aliyuncs.com/apps/anthropic/v1/messages

美国(弗吉尼亚)

SDK 调用配置的 base_urlhttps://dashscope-us.aliyuncs.com/apps/anthropic

HTTP 请求地址:POST https://dashscope-us.aliyuncs.com/apps/anthropic/v1/messages

德国(法兰克福)

SDK 调用配置的 base_urlhttps://{WorkspaceId}.eu-central-1.maas.aliyuncs.com/apps/anthropic

HTTP 请求地址:POST https://{WorkspaceId}.eu-central-1.maas.aliyuncs.com/apps/anthropic/v1/messages

调用时请将 {WorkspaceId} 替换为真实的 Workspace ID。

认证方式:通过 x-api-key 请求头或 Authorization: Bearer 请求头传入百炼 API Key,二者选其一即可。

请求体

基础调用

Python

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/apps/anthropic",
)

message = client.messages.create(
    model="qwen3.6-plus",
    max_tokens=1024,
    system="You are a helpful assistant",
    messages=[
        {
            "role": "user",
            "content": "你是谁?"
        }
    ],
    thinking={"type": "disabled"},
)

print(message.content[0].text)

TypeScript

import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
});

async function main() {
  const message = await anthropic.messages.create({
    model: "qwen3.6-plus",
    max_tokens: 1024,
    system: "You are a helpful assistant",
    messages: [{
      role: "user",
      content: "你是谁?"
    }],
    thinking: { type: "disabled" },
  });

  console.log(message.content[0].text);
}

main().catch(console.error);

curl

curl -X POST "https://dashscope.aliyuncs.com/apps/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DASHSCOPE_API_KEY" \
  -d '{
    "model": "qwen3.6-plus",
    "max_tokens": 1024,
    "system": "You are a helpful assistant",
    "messages": [
        {
            "role": "user",
            "content": "你是谁?"
        }
    ],
    "thinking": {"type": "disabled"}
}'

流式输出

Python

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/apps/anthropic",
)

stream = client.messages.create(
    model="qwen3.6-plus",
    max_tokens=1024,
    stream=True,
    messages=[
        {
            "role": "user",
            "content": "请简单介绍一下人工智能。"
        }
    ],
    thinking={"type": "disabled"},
)

for chunk in stream:
    if chunk.type == "content_block_delta":
        if hasattr(chunk.delta, 'text'):
            print(chunk.delta.text, end="", flush=True)

TypeScript

import Anthropic from "@anthropic-ai/sdk";

async function main() {
  const anthropic = new Anthropic({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
  });

  const stream = await anthropic.messages.create({
    model: "qwen3.6-plus",
    max_tokens: 1024,
    stream: true,
    messages: [{
      role: "user",
      content: "请简单介绍一下人工智能。"
    }],
    thinking: { type: "disabled" },
  });

  for await (const chunk of stream) {
    if (chunk.type === "content_block_delta" && 'text' in chunk.delta) {
      process.stdout.write(chunk.delta.text);
    }
  }
}

main().catch(console.error);

curl

curl -X POST "https://dashscope.aliyuncs.com/apps/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DASHSCOPE_API_KEY" \
  --no-buffer \
  -d '{
    "model": "qwen3.6-plus",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
        {
            "role": "user",
            "content": "请简单介绍一下人工智能。"
        }
    ],
    "thinking": {"type": "disabled"}
}'

深度思考

Python

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/apps/anthropic",
)

stream = client.messages.create(
    model="qwen3.6-plus",
    max_tokens=2048,
    stream=True,
    thinking={
        "type": "enabled",
        "budget_tokens": 1024
    },
    messages=[
        {
            "role": "user",
            "content": "分析一下量子计算的发展前景。"
        }
    ]
)

for chunk in stream:
    if chunk.type == "content_block_delta":
        if hasattr(chunk.delta, 'thinking'):
            print(chunk.delta.thinking, end="", flush=True)
        elif hasattr(chunk.delta, 'text'):
            print(chunk.delta.text, end="", flush=True)

TypeScript

import Anthropic from "@anthropic-ai/sdk";

async function main() {
  const anthropic = new Anthropic({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
  });

  const stream = await anthropic.messages.create({
    model: "qwen3.6-plus",
    max_tokens: 2048,
    stream: true,
    thinking: { type: "enabled", budget_tokens: 1024 },
    messages: [{
      role: "user",
      content: "分析一下量子计算的发展前景。"
    }]
  });

  for await (const chunk of stream) {
    if (chunk.type === "content_block_delta") {
      if ('thinking' in chunk.delta) {
        process.stdout.write(chunk.delta.thinking);
      } else if ('text' in chunk.delta) {
        process.stdout.write(chunk.delta.text);
      }
    }
  }
}

main().catch(console.error);

curl

curl -X POST "https://dashscope.aliyuncs.com/apps/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DASHSCOPE_API_KEY" \
  -d '{
    "model": "qwen3.6-plus",
    "max_tokens": 2048,
    "stream": true,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 1024
    },
    "messages": [
        {
            "role": "user",
            "content": "分析一下量子计算的发展前景。"
        }
    ]
}'

图片理解

Python

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/apps/anthropic",
)

stream = client.messages.create(
    model="qwen3.6-plus",
    max_tokens=1024,
    stream=True,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250414/mqqmiy/animal_01.jpg",
                    },
                },
                {
                    "type": "text",
                    "text": "描述这张图片的内容。"
                },
            ],
        }
    ],
    thinking={"type": "disabled"},
)

for chunk in stream:
    if chunk.type == "content_block_delta":
        if hasattr(chunk.delta, 'text'):
            print(chunk.delta.text, end="", flush=True)

TypeScript

import Anthropic from "@anthropic-ai/sdk";

async function main() {
  const anthropic = new Anthropic({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
  });

  const stream = await anthropic.messages.create({
    model: "qwen3.6-plus",
    max_tokens: 1024,
    stream: true,
    messages: [{
      role: "user",
      content: [
        {
          type: "image",
          source: {
            type: "url",
            url: "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250414/mqqmiy/animal_01.jpg",
          },
        },
        { type: "text", text: "描述这张图片的内容。" },
      ],
    }],
    thinking: { type: "disabled" },
  });

  for await (const chunk of stream) {
    if (chunk.type === "content_block_delta" && 'text' in chunk.delta) {
      process.stdout.write(chunk.delta.text);
    }
  }
}

main().catch(console.error);

curl

curl -X POST "https://dashscope.aliyuncs.com/apps/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DASHSCOPE_API_KEY" \
  -d '{
    "model": "qwen3.6-plus",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250414/mqqmiy/animal_01.jpg"
                    }
                },
                {
                    "type": "text",
                    "text": "描述这张图片的内容。"
                }
            ]
        }
    ],
    "thinking": {"type": "disabled"}
}'

视频理解

Python

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/apps/anthropic",
)

stream = client.messages.create(
    model="qwen3.6-plus",
    max_tokens=1024,
    stream=True,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "video",
                    "source": {
                        "type": "url",
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251208/zpupby/3e81ef38-98f0-4d55-bbb6-259334ca18d0.mp4",
                    },
                },
                {
                    "type": "text",
                    "text": "描述这段视频的内容。"
                },
            ],
        }
    ],
    thinking={"type": "disabled"},
)

for chunk in stream:
    if chunk.type == "content_block_delta":
        if hasattr(chunk.delta, 'text'):
            print(chunk.delta.text, end="", flush=True)

TypeScript

import Anthropic from "@anthropic-ai/sdk";

async function main() {
  const anthropic = new Anthropic({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
  });

  const stream = await anthropic.messages.create({
    model: "qwen3.6-plus",
    max_tokens: 1024,
    stream: true,
    messages: [{
      role: "user",
      content: [
        {
          type: "video",
          source: {
            type: "url",
            url: "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251208/zpupby/3e81ef38-98f0-4d55-bbb6-259334ca18d0.mp4",
          },
        },
        { type: "text", text: "描述这段视频的内容。" },
      ],
    }],
    thinking: { type: "disabled" },
  });

  for await (const chunk of stream) {
    if (chunk.type === "content_block_delta" && 'text' in chunk.delta) {
      process.stdout.write(chunk.delta.text);
    }
  }
}

main().catch(console.error);

curl

curl -X POST "https://dashscope.aliyuncs.com/apps/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DASHSCOPE_API_KEY" \
  -d '{
    "model": "qwen3.6-plus",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "video",
                    "source": {
                        "type": "url",
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251208/zpupby/3e81ef38-98f0-4d55-bbb6-259334ca18d0.mp4"
                    }
                },
                {
                    "type": "text",
                    "text": "描述这段视频的内容。"
                }
            ]
        }
    ],
    "thinking": {"type": "disabled"}
}'

Function Call

Python

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/apps/anthropic",
)

tools = [
    {
        "name": "get_weather",
        "description": "获取指定城市的天气信息",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "城市名称"
                }
            },
            "required": ["city"]
        }
    }
]

message = client.messages.create(
    model="qwen3.6-plus",
    max_tokens=1024,
    tools=tools,
    messages=[
        {
            "role": "user",
            "content": "杭州今天天气怎么样?"
        }
    ]
)

print(message.content)

TypeScript

import Anthropic from "@anthropic-ai/sdk";

async function main() {
  const anthropic = new Anthropic({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
  });

  const message = await anthropic.messages.create({
    model: "qwen3.6-plus",
    max_tokens: 1024,
    tools: [
      {
        name: "get_weather",
        description: "获取指定城市的天气信息",
        input_schema: {
          type: "object",
          properties: {
            city: { type: "string", description: "城市名称" }
          },
          required: ["city"],
        },
      },
    ],
    messages: [{
      role: "user",
      content: "杭州今天天气怎么样?"
    }],
  });

  console.log(JSON.stringify(message.content, null, 2));
}

main().catch(console.error);

curl

curl -X POST "https://dashscope.aliyuncs.com/apps/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DASHSCOPE_API_KEY" \
  -d '{
    "model": "qwen3.6-plus",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "input_schema": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称"
                    }
                },
                "required": ["city"]
            }
        }
    ],
    "messages": [
        {
            "role": "user",
            "content": "杭州今天天气怎么样?"
        }
    ]
}'

显式缓存

Python

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/apps/anthropic",
)

# 模拟代码仓库内容,需达到最小可缓存长度(1024 Token)
long_text_content = "<Your Code Here>" * 400


def get_completion(user_input):
    response = client.messages.create(
        # 选择支持显式缓存的模型
        model="qwen3.6-plus",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": long_text_content,
                # 在 text 块上添加 cache_control 即标记缓存断点;也可放在 messages 数组的 content 块上
                "cache_control": {"type": "ephemeral"},
            }
        ],
        messages=[
            {"role": "user", "content": user_input},
        ],
    )
    return response


# 第一次请求:创建缓存
first = get_completion("这段代码的内容是什么")
print(f"创建缓存 Token:{first.usage.cache_creation_input_tokens}")
print(f"命中缓存 Token:{first.usage.cache_read_input_tokens}")
print("=" * 20)
# 第二次请求:长内容相同,仅修改提问 → 命中缓存
second = get_completion("这段代码可以怎么优化")
print(f"创建缓存 Token:{second.usage.cache_creation_input_tokens}")
print(f"命中缓存 Token:{second.usage.cache_read_input_tokens}")

TypeScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
});

// 模拟代码仓库内容,需达到最小可缓存长度(1024 Token)
const longTextContent = "<Your Code Here>".repeat(400);

async function getCompletion(userInput) {
  return client.messages.create({
    // 选择支持显式缓存的模型
    model: "qwen3.6-plus",
    max_tokens: 1024,
    system: [
      {
        type: "text",
        text: longTextContent,
        // 在 text 块上添加 cache_control 即标记缓存断点;也可放在 messages 数组的 content 块上
        cache_control: { type: "ephemeral" },
      },
    ],
    messages: [{ role: "user", content: userInput }],
  });
}

// 第一次请求:创建缓存
const first = await getCompletion("这段代码的内容是什么");
console.log(`创建缓存 Token:${first.usage.cache_creation_input_tokens}`);
console.log(`命中缓存 Token:${first.usage.cache_read_input_tokens}`);
console.log("=".repeat(20));
// 第二次请求:长内容相同,仅修改提问 → 命中缓存
const second = await getCompletion("这段代码可以怎么优化");
console.log(`创建缓存 Token:${second.usage.cache_creation_input_tokens}`);
console.log(`命中缓存 Token:${second.usage.cache_read_input_tokens}`);

curl

curl -X POST "https://dashscope.aliyuncs.com/apps/anthropic/v1/messages" \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DASHSCOPE_API_KEY" \
  -d '{
    "model": "qwen3.6-plus",
    "max_tokens": 1024,
    "system": [
      {
        "type": "text",
        "text": "<请在此处放置长度 ≥ 1024 Token 的可缓存内容>",
        "cache_control": {"type": "ephemeral"}
      }
    ],
    "messages": [
      {"role": "user", "content": "这段代码的内容是什么"}
    ]
}'

model string (必选)

模型名称,支持范围如下。

支持的模型列表

千问Max:qwen3.7-max、qwen3.7-max-2026-05-20、qwen3.6-max-preview、qwen3-max、qwen3-max-2026-01-23、qwen3-max-preview

千问Plus:qwen3.6-plus、qwen3.6-plus-2026-04-02、qwen3.5-plus、qwen3.5-plus-2026-04-20、qwen3.5-plus-2026-02-15、qwen-plus、qwen-plus-latest、qwen-plus-2025-09-11

千问Flash:qwen3.6-flash、qwen3.6-flash-2026-04-16、qwen3.5-flash、qwen3.5-flash-2026-02-23、qwen-flash、qwen-flash-2025-07-28

千问Turbo:qwen-turbo、qwen-turbo-latest

千问Coder:qwen3-coder-next、qwen3-coder-plus、qwen3-coder-plus-2025-09-23、qwen3-coder-flash

千问VL:qwen3-vl-plus、qwen3-vl-flash、qwen-vl-max、qwen-vl-plus

千问开源模型:qwen3.6-27b、qwen3.5-397b-a17b、qwen3.5-122b-a10b、qwen3.5-27b、qwen3.5-35b-a3b

第三方模型

deepseek-v4-pro、deepseek-v4-flash、deepseek-v3.2、kimi-k2.6、kimi-k2.5、kimi-k2-thinking、glm-5.1、glm-5、glm-4.7、glm-4.6、MiniMax-M2.5、MiniMax-M2.1

max_tokens integer (必选)

生成 Token 的最大数量。

system string 或 array (可选)

系统提示词,用于设定模型的角色或行为。system 通过顶层参数传入,messages 数组中不接受 system 角色。

传入字符串等价于单个 type="text" 的内容块。当需要为系统提示词标记显式缓存断点(参见右侧"显式缓存"示例)时,必须传入数组形式。

属性

type string (必选)

固定为 text

text string (必选)

系统提示词文本。

cache_control object (可选)

在该内容块上标记显式缓存断点(参见右侧"显式缓存"示例),命中后第二次及之后的请求按缓存读取计费。仅包含字段 type,取值固定为 ephemeral

messages array (必选)

消息数组,按 user / assistant 交替轮次排列。

messages 数组元素

role string (必选)

消息角色,可选值:userassistant

content string 或 array (必选)

消息内容。可以是纯文本字符串,也可以是结构化内容数组。content 为字符串时,等价于单个 type="text" 的内容块。

content 数组元素类型

文本信息

属性

type string (必选)

固定为 text

text string (必选)

文本内容。

cache_control object (可选)

在该文本块上标记显式缓存断点(参见右侧"显式缓存"示例)。仅包含字段 type,取值固定为 ephemeral

图片信息(需使用视觉模型)

属性

type string (必选)

固定为 image

source object (必选)

图片数据来源。

属性

type string (必选)

取值:url(公网图片地址)、base64(Base64 编码)。

url string

图片的公网地址。当 typeurl 时必填。

media_type string

图片的 MIME 类型,如 image/jpeg。当 typebase64 时必填。

data string

Base64 编码的图片数据。当 typebase64 时必填。

视频信息(需使用视觉模型)

属性

type string (必选)

固定为 video

source object (必选)

视频数据来源。

属性

type string (必选)

取值:url(公网视频地址)、base64(Base64 编码)。

url string

视频的公网地址。当 typeurl 时必填。

media_type string

视频的 MIME 类型,如 video/mp4。当 typebase64 时必填。

data string

Base64 编码的视频数据。当 typebase64 时必填。

工具调用信息(assistant 角色,模型返回的工具调用指令)

属性

type string (必选)

固定为 tool_use

id string (必选)

工具调用的唯一标识,用于在后续 tool_result 中关联结果。

name string (必选)

被调用的工具名称。

input object (必选)

工具调用的入参,结构由 tools 中对应工具的 input_schema 决定。

cache_control object (可选)

在该块上标记显式缓存断点(参见右侧"显式缓存"示例)。仅包含字段 type,取值固定为 ephemeral。工具调用内容本身会参与缓存前缀。

工具结果信息(user 角色,工具执行结果回传给模型)

属性

type string (必选)

固定为 tool_result

tool_use_id string (必选)

对应 tool_use 信息中的 id

content string (必选)

工具执行返回的内容。

cache_control object (可选)

在该工具结果块上标记显式缓存断点(参见右侧"显式缓存"示例)。仅包含字段 type,取值固定为 ephemeral

stream boolean (可选)

是否启用流式输出,默认为 false

temperature number (可选)

控制生成文本的多样性,取值范围 [0, 2)。值越大,生成结果越随机。

说明

该范围与 Anthropic 官方的 [0.0, 1.0] 不同,从 Anthropic 迁移时请确认该参数取值。

top_p number (可选)

核采样的概率阈值,控制生成文本的多样性。

temperaturetop_p 均可控制生成文本的多样性,建议只设置其中一个值。更多说明请参见概述

top_k integer (可选)

生成过程中采样候选集的大小。

stop_sequences array (可选)

指定停止生成的文本序列。模型生成到该序列前会停止输出,且不包含该序列本身。

说明

命中后,响应的 stop_reason 仍为 end_turn,响应不会回填命中的序列。

thinking object (可选)

深度思考配置。开启后,模型会在生成回复前先进行推理,以提升回答准确度。开启后,响应会包含 thinking 类型的内容块。部分模型不支持思考模式。

属性

type string (必选)

可选值:enabled(开启思考模式)、disabled(关闭思考模式)。

budget_tokens integer (可选)

思考过程可使用的最大 Token 数。预算越大,在复杂问题上的分析越充分。当 typeenabled 时生效。

reasoning_effort string (可选)

控制模型的推理强度。可选值:highmax,默认为 max。支持的模型:deepseek-v4-pro、deepseek-v4-flash。

说明

设为 lowmedium 时会映射为 high,设为 xhigh 时会映射为 max

tools array (可选)

工具定义数组,用于 Function Call 场景。

tools 数组元素

name string (必选)

工具名称。

description string (可选)

工具的功能描述。

input_schema object (必选)

工具输入参数的 JSON Schema 定义。

tool_choice object (可选)

工具选择策略。支持以下值:

  • {"type": "auto"}:模型自行决定是否调用工具(默认)。

  • {"type": "any"}:强制模型调用任意一个工具。

  • {"type": "none"}:禁止模型调用工具。

  • {"type": "tool", "name": "tool_name"}:强制模型调用指定工具。

非流式响应

响应示例

{
  "id": "msg_e2898f19-fc0e-4cb3-bd9b-5b7dc4ea3bc9",
  "type": "message",
  "role": "assistant",
  "model": "qwen3.6-plus",
  "content": [
    {
      "type": "thinking",
      "thinking": "让我分析一下这个问题...",
      "signature": ""
    },
    {
      "type": "text",
      "text": "你好!我是通义千问..."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 22,
    "output_tokens": 223,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

id string

消息的唯一标识。

type string

固定为 message

role string

固定为 assistant

model string

使用的模型名称。

content array

内容数组。

content 数组元素类型

文本信息

属性

type string

固定为 text

text string

模型生成的文本回复。

思考信息(开启深度思考时返回)

属性

type string

固定为 thinking

thinking string

模型在生成最终回复前的思考过程。

signature string

当前固定为空字符串。

工具调用信息(Function Call 场景)

属性

type string

固定为 tool_use

id string

工具调用的唯一标识,用于在后续 tool_result 中关联结果。

name string

被调用的工具名称。

input object

工具调用的入参。

stop_reason string

停止原因。可选值:end_turn(正常结束)、max_tokens(达到 Token 上限)、tool_use(工具调用)。

stop_sequence string

固定为 null

usage object

Token 用量统计。

说明

流式调用中,message_start 事件的 usage 仅包含 input_tokensoutput_tokens;完整 4 个字段在 message_delta 事件中返回。

属性

input_tokens integer

输入 Token 数量。

output_tokens integer

输出 Token 数量。

cache_creation_input_tokens integer

缓存创建消耗的输入 Token 数量。

cache_read_input_tokens integer

缓存读取消耗的输入 Token 数量。

流式响应

流式响应示例

{"type":"message_start","message":{"id":"msg_xxx","type":"message","role":"assistant","model":"qwen3.6-plus","content":[],"usage":{"input_tokens":15,"output_tokens":0}}}
{"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"","signature":""}}
{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"Here's a thinking process:\n\n1. **Analyze User Input:**\n   - **Topic:** 人工智能 (Artificial Intelligence / AI)\n   - **Request:** 请简单介绍一下人工智能。"}}
{"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":""}}
{"type":"content_block_stop","index":0}
{"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}
{"type":"content_block_delta","index":1,"delta":{"type":"text_delta","text":"人工智能(Artificial Intelligence,简称AI)是计算机科学的重要分支..."}}
{"type":"content_block_stop","index":1}
{"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"input_tokens":15,"output_tokens":1078,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}
{"type":"message_stop"}

message_start

流的第一个事件,标记消息开始。

属性

type string

固定为 message_start

message object

初始消息对象,content 为空数组,usage 仅含 input_tokensoutput_tokens

content_block_start

每个内容块开始时发送,标记新内容块的索引和类型。

属性

type string

固定为 content_block_start

index integer

内容块索引,从 0 开始,对应该消息 content 数组中的位置。

content_block object

内容块的初始对象。type 取值为 textthinkingtool_usetool_use 类型在此事件中 input 为空对象,完整入参由后续 content_block_delta 增量拼接。

content_block_delta

内容块的增量更新事件。同一内容块会发送多个该事件。

属性

type string

固定为 content_block_delta

index integer

所属内容块索引。

delta object

增量对象,type 取值:

  • text_delta:文本增量,含 text 字段。

  • thinking_delta:思考增量,含 thinking 字段。

  • signature_delta:签名增量,含 signature 字段(当前固定为空字符串)。

  • input_json_delta:工具调用入参增量,含 partial_json 字段。

content_block_stop

内容块结束事件。

属性

type string

固定为 content_block_stop

index integer

结束的内容块索引。

message_delta

消息级更新事件,在所有内容块结束后发送,包含停止原因和完整的 Token 用量统计。

属性

type string

固定为 message_delta

delta object

包含 stop_reasonstop_sequence,取值参见上方非流式响应表格。

usage object

完整的 Token 用量统计,包含 input_tokensoutput_tokenscache_creation_input_tokenscache_read_input_tokens

message_stop

流的最后一个事件,标记消息结束。

属性

type string

固定为 message_stop

此外,流式响应还会定期发送 ping 事件({"type":"ping"})用于保持连接活跃,客户端可忽略。