大模型Responses API

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-5",
    messages=[
        {
            "role": "user",
            "content": "Write a one-sentence bedtime story about a unicorn."
        }
    ]
)

print(completion.choices[0].message.content)

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Write a one-sentence bedtime story about a unicorn."
)

print(response.output_text)

{
  "id": "chatcmpl-C9EDpkjH60VPPIB86j2zIhiR8kWiC",
  "object": "chat.completion",
  "created": 1756315657,
  "model": "gpt-5-2025-08-07",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Under a blanket of starlight, a sleepy unicorn tiptoed through moonlit meadows, gathering dreams like dew to tuck beneath its silver mane until morning.",
        "refusal": null,
        "annotations": []
      },
      "finish_reason": "stop"
    }
  ],
  ...
}

{
  "id": "resp_68af4030592c81938ec0a5fbab4a3e9f05438e46b5f69a3b",
  "object": "response",
  "created_at": 1756315696,
  "model": "gpt-5-2025-08-07",
  "output": [
    {
      "id": "rs_68af4030baa48193b0b43b4c2a176a1a05438e46b5f69a3b",
      "type": "reasoning",
      "content": [],
      "summary": []
    },
    {
      "id": "msg_68af40337e58819392e935fb404414d005438e46b5f69a3b",
      "type": "message",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "annotations": [],
          "logprobs": [],
          "text": "Under a quilt of moonlight, a drowsy unicorn wandered through quiet meadows, brushing blossoms with her glowing horn so they sighed soft lullabies that carried every dreamer gently to sleep."
        }
      ],
      "role": "assistant"
    }
  ],
  ...
}

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the capital of France?"}
]
res1 = client.chat.completions.create(model="gpt-5", messages=messages)

messages += [res1.choices[0].message]
messages += [{"role": "user", "content": "And its population?"}]

res2 = client.chat.completions.create(model="gpt-5", messages=messages)

context = [
    { "role": "role", "content": "What is the capital of France?" }
]
res1 = client.responses.create(
    model="gpt-5",
    input=context,
)

// Append the first response’s output to context
context += res1.output

// Add the next user message
context += [
    { "role": "role", "content": "And it's population?" }
]

res2 = client.responses.create(
    model="gpt-5",
    input=context,
)

res1 = client.responses.create(
    model="gpt-5",
    input="What is the capital of France?",
    store=True
)

res2 = client.responses.create(
    model="gpt-5",
    input="And its population?",
    previous_response_id=res1.id,
    store=True
)

from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
  model="gpt-5",
  messages=[
    {
      "role": "user",
      "content": "Jane, 54 years old",
    }
  ],
  response_format={
    "type": "json_schema",
    "json_schema": {
      "name": "person",
      "strict": True,
      "schema": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "minLength": 1
          },
          "age": {
            "type": "number",
            "minimum": 0,
            "maximum": 130
          }
        },
        "required": [
          "name",
          "age"
        ],
        "additionalProperties": False
      }
    }
  },
  verbosity="medium",
  reasoning_effort="medium"
)

response = client.responses.create(
  model="gpt-5",
  input="Jane, 54 years old", 
  text={
    "format": {
      "type": "json_schema",
      "name": "person",
      "strict": True,
      "schema": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "minLength": 1
          },
          "age": {
            "type": "number",
            "minimum": 0,
            "maximum": 130
          }
        },
        "required": [
          "name",
          "age"
        ],
        "additionalProperties": False
      }
    }
  }
)

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Determine weather in my location",
    "strict": true,
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
        },
      },
      "additionalProperties": false,
      "required": [
        "location",
        "unit"
      ]
    }
  }
}

{
  "type": "function",
  "name": "get_weather",
  "description": "Determine weather in my location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
      },
    },
    "additionalProperties": false,
    "required": [
      "location",
      "unit"
    ]
  }
}

import requests

def web_search(query):
    r = requests.get(f"https://api.example.com/search?q={query}")
    return r.json().get("results", [])

completion = client.chat.completions.create(
    model="gpt-5",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Who is the current president of France?"}
    ],
    functions=[
        {
            "name": "web_search",
            "description": "Search the web for information",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string"}},
                "required": ["query"]
            }
        }
    ]
)

answer = client.responses.create(
    model="gpt-5",
    input="Who is the current president of France?",
    tools=[{"type": "web_search"}]
)

print(answer.output_text)

输入

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url="https://ark.cn-beijing.volces.com/api/v3",
    api_key=os.getenv('ARK_API_KEY'),
)

completion = client.chat.completions.create(
    model = "doubao-seed-1-6-251015",
    messages=[
        {"role": "user", "content": "Hello."},
    ],
)
print(completion)

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
)

response = client.responses.create(
    model="doubao-seed-1-6-251015",
    input="Hello.",
)

print(response)

输出

{
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null,
            "message": {
                "content": "Hello! How can I assist you today? Whether you have a question you'd like answered, want to chat about something that's on your mind, or need help with a specific task, feel free to share—I'm here to help. 😊",
                "reasoning_content": "\nGot it, let's see. The user just said \"Hello.\" I need to respond in a friendly way. Since the system prompt mentions I'm an AI assistant who can answer questions, chat, and provide information, I should keep it open-ended to encourage them to share what they need help with. Maybe something like \"Hello! How can I assist you today? Whether you have a question, want to chat about something, or need help with a task, feel free to let me know.\" That sounds natural and covers the points from the system prompt.",
                "role": "assistant"
            }
        }
    ],
    "created": 1765193367,
    "id": "0217651933631536335e3dfd75940b9979797202ce7ea2a894823",
    "model": "doubao-seed-1-6-251015",
    "service_tier": "default",
    "object": "chat.completion",
    "usage": {
        "completion_tokens": 164,
        "prompt_tokens": 35,
        "total_tokens": 199,
        "prompt_tokens_details": {
            "cached_tokens": 0
        },
        "completion_tokens_details": {
            "reasoning_tokens": 114
        }
    }

{
    "created_at": 1765193461,
    "id": "resp_0217651934613099e1bacc68b98f823c2af95ea68bff0aec36f83",
    "max_output_tokens": 32768,
    "model": "doubao-seed-1-6-251015",
    "object": "response",
    "output": [
        {
            "id": "rs_02176519346192100000000000000000000ffffac15322033925d",
            "type": "reasoning",
            "summary": [
                {
                    "type": "summary_text",
                    "text": "\nGot it, let's see. The user said \"hello.\" First, I need to respond in a friendly way. Since the system prompt mentions being a helpful assistant, I should greet back and maybe invite them to ask whatever they need help with. Let me make it natural. Like, \"Hello! How can I assist you today?\" That's simple and open-ended. Yeah, that works."
                }
            ],
            "status": "completed"
        },
        {
            "type": "message",
            "role": "assistant",
            "content": [
                {
                    "type": "output_text",
                    "text": "Hello! How can I assist you today? Whether you have a question, need help with a task, or just want to chat, feel free to let me know. 😊"
                }
            ],
            "status": "completed",
            "id": "msg_02176519346378200000000000000000000ffffac153220cfab51"
        }
    ],
    "service_tier": "default",
    "status": "completed",
    "usage": {
        "input_tokens": 35,
        "output_tokens": 118,
        "total_tokens": 153,
        "input_tokens_details": {
            "cached_tokens": 0
        },
        "output_tokens_details": {
            "reasoning_tokens": 82
        }
    },
    "caching": {
        "type": "disabled"
    },
    "store": true,
    "expire_at": 1765452661
}

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url="https://ark.cn-beijing.volces.com/api/v3",
    api_key=os.getenv('ARK_API_KEY'),
)

completion = client.chat.completions.create(
    # Replace with Model ID
    model = "doubao-seed-1-6-251015",
    messages=[
        {"role": "user","content": "Hi，帮我讲个笑话。"},
        {"role": "assistant","content":"我把洗面奶当牙膏挤，刷完牙才发现味道不对。"},
        {"role": "user","content": "这个笑话的笑点在哪？"}
    ]
)
print(completion.choices[0].message.content)

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
)

# Create the first-round conversation request
response = client.responses.create(
    model="doubao-seed-1-6-251015",
    input=[{"role": "user", "content": "Hi，帮我讲个笑话。"}],
)
print(response)

# Create the second-round conversation request
second_response = client.responses.create(
    model="doubao-seed-1-6-251015",
    previous_response_id=response.id,
    input=[{"role": "user", "content": "这个笑话的笑点在哪？"}],
)
print(second_response)

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url="https://ark.cn-beijing.volces.com/api/v3",
    api_key=os.getenv('ARK_API_KEY'),
)

completion = client.chat.completions.create(
    model = "doubao-seed-1-6-251015",
    messages=[
        {"role": "user", "content": "常见的十字花科植物有哪些？json输出"},
    ],
    response_format={"type":"json_object"},
    thinking={"type": "disabled"},# 不使用深度思考能力
)
print(completion.choices[0].message.content)

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
)

response = client.responses.create(
    model="doubao-seed-1-6-251015",
    input=[
        {"role": "user", "content": "常见的十字花科植物有哪些？json输出"},
    ],
    text={"format":{"type": "json_object"}},
    thinking={"type": "disabled"},# 不使用深度思考能力
)
print(response)

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url="https://ark.cn-beijing.volces.com/api/v3",
    api_key=os.getenv('ARK_API_KEY'),
)

completion = client.chat.completions.create(
    model = "doubao-seed-1-6-251015",
    messages=[
        {"role": "system", "content": "你是 AI 人工智能助手"},
        {"role": "user", "content": "常见的十字花科植物有哪些？"},
    ],
    max_completion_tokens = 1024,
)
print(completion.choices[0].message.content)

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
)

response = client.responses.create(
    model="doubao-seed-1-6-251015",
    input=[
        {"role": "system", "content": "你是 AI 人工智能助手"},
        {"role": "user", "content": "常见的十字花科植物有哪些？"},
    ],
    max_output_tokens = 1024,
)
print(response)

import datetime
import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.environ.get("ARK_API_KEY"),
)

response = client.context.create(
    model=<YOUR_ENDPOINT_ID>,
    mode="session",
    messages=[
        {"role": "system", "content": "你是李雷"},
    ],
    ttl=datetime.timedelta(minutes=60),
)
print(response)

print("----- chat round 1 -----")
first_response = client.context.completions.create(
    context_id=response.id,
    model=<YOUR_ENDPOINT_ID>,
    messages=[
        {"role": "user", "content": "我是方方"},
    ]
)
print(first_response.choices[0].message.content)

print("----- chat round 2  -----")
second_response = client.context.completions.create(
    context_id=response.id,
    model=<YOUR_ENDPOINT_ID>,
    messages=[
        {"role": "user", "content": "你是谁，我是谁？"},
    ]
)
print(second_response.choices[0].message.content)

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
)

response = client.responses.create(
    model="doubao-seed-1-6-251015",
    input=[
        {"role": "system", "content": "你是李雷"},
    ],
    caching={"type": "enabled"},
    thinking={"type": "disabled"},
)
print(response.output[0].content[0].text)
print("----- chat round 1 -----")
first_response = client.responses.create(
    model="doubao-seed-1-6-251015",
    previous_response_id=response.id,
    input=[{"role": "user", "content": "我是方方"}],
    caching={"type": "enabled"},
    thinking={"type": "disabled"},
)
print(first_response.output[0].content[0].text)
print("----- chat round 2 -----")
second_response = client.responses.create(
    model="doubao-seed-1-6-251015",
    previous_response_id=first_response.id,
    input=[{"role": "user", "content": "你是谁，我是谁？"}],
    caching={"type": "enabled"},
    thinking={"type": "disabled"},
)
print(second_response.output[0].content[0].text)

[
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "根据城市名称查询该城市当日天气（含温度、天气状况）",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "城市名称，如北京、上海（仅支持国内地级市）"
          }
        },
        "required": [
          "location"
        ]
      }
    }
  }
]

[
  {
    "type": "function",
    "name": "get_weather",
    "description": "根据城市名称查询该城市当日天气（含温度、天气状况）",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "城市名称，如北京、上海（仅支持国内地级市）"
        }
      },
      "required": [
        "location"
      ]
    }
  }
]

通过 Web Search 工具可以获取实时公开网络信息（如新闻、商品、天气等），解决数据时效性、知识盲区、信息同步等核心问题，并且无需自行开发搜索引擎或维护数据资源。

Image Process 图像处理工具支持通过 Responses API 调用对输入图片执行画点、画线、旋转、缩放、框选/裁剪关键区域等基础操作，适用于需模型通过视觉处理提升图片理解的场景（如图文内容分析、物体定位标注、多轮视觉推理等）。工具通过模型自动判断图像处理逻辑，支持与自定义 Function 混合使用，且可处理多轮视觉输入（上一轮输出图片作为下一轮输入）。

import os
from volcenginesdkarkruntime import Ark

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
)

tools = [{
    "type": "web_search",
    "max_keyword": 2,  
}]

response = client.responses.create(
    model="doubao-seed-1-6-251015",
    input=[{"role": "user", "content": "北京的天气怎么样？"}],
    tools=tools,
)

print(response)

from openai import OpenAI
import os
# Initialize the client and configure the API address and tool call headers.
client = OpenAI(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
    default_headers={"ark-beta-image-process": "true"}
)

# Initiate an image processing request.
response = client.responses.create(
    model="doubao-seed-1-6-vision-250815",
    tools=[
        {
            "type": "image_process",
            "point": {
                "type": "disabled"
            },
            "grounding": {
                "type": "disabled"
            },
            "zoom": {
                "type": "enabled" # Enable the zoom tool.
            },
            "rotate": {
                "type": "disabled"
            }
        }
    ],
    input=[
        {
            "type": "message",
            "role": "user",
            "content": [
                {
                    "type": "input_image",
                    "image_url": "https://ark-project.tos-cn-beijing.volces.com/doc_image/image_process_1.jpg"  # Enter the image URL.
                },
                {
                    "type": "input_text",
                    "text": "前方路牌写了什么？"
                }
            ]
        }
    ],
    stream=True  # Enable streaming response to obtain processing results in real time.
)

# Print the streaming response results.
for chunk in response:
    if hasattr(chunk, 'delta'):
        print(chunk.delta, end="", flush=True)

私域知识库搜索工具 Knowledge Search 支持通过 Responses API 调用直接获取企业私域知识库中的信息（如内部文档、产品手册、行业资料等），适用于需基于企业专属数据解答问题的场景（如内部培训问答、产品功能咨询、行业方案查询等）。工具通过模型自动判断是否需要调用私域知识库，支持与自定义 Function、MCP 等工具混合使用，目前仅支持旗舰版知识库。

对接“MCP MarketPlace”，支持调用市场内各类垂直领域MCP工具（如巨量千川、知识库），无需自行开发工具逻辑。适用于复杂任务（如多步数据查询 + 分析）场景，支持与自定义 Function、Web Search 工具混合使用。

import os
from openai import OpenAI 

client = OpenAI(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY'),
    default_headers={"ark-beta-knowledge-search": "true"}  # Enable private domain knowledge base search.
)

# Initiate a knowledge base search request.
response = client.responses.create(
    model="doubao-seed-1-6-251015",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "应用实验室里有类似实时视频理解的agent demo么？"
                }
            ]
        }
    ],
    tools=[
        {
            "type": "knowledge_search",
            "knowledge_resource_id": "<knowledge_resource_id>",  # Replace with the actual knowledge base ID.
            "limit": 10,  # Return a maximum of 10 search results.
        }
    ],
    stream=True,  # Enable streaming response to obtain processing results in real time.
    extra_body={"thinking": {"type": "auto"}}  # The model automatically determines whether a search is necessary.
)

# Print the streaming response results.
for chunk in response:
    if hasattr(chunk, 'delta'):
        print(chunk.delta, end="", flush=True)

from volcenginesdkarkruntime import Ark
import os
# Initialize the client and enable MCP
client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=os.getenv('ARK_API_KEY')
)
# Send a basic MCP call request
response = client.responses.create(
    model="doubao-seed-1-6-251015",
    tools=[
        {
            "type": "mcp",
            "server_label": "deepwiki",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": "never"
        }
    ],
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "看一下volcengine/ai-app-lab这个repo的文档"
                }
            ]
        }
    ],
    extra_headers={"ark-beta-mcp": "true"},
    stream=True  # Stream results
)

# Print the streaming response results.
for chunk in response:
    if hasattr(chunk, 'delta'):
        print(chunk.delta, end="", flush=True)

输入

# Chat Completions API
completion = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=[
        {"role": "system", "content": "你是一个有帮助的助手。"},
        {"role": "user", "content": "你好！"}
    ]
)
print(completion.choices[0].message.content)

# Responses API - 可以使用相同的消息格式
response = client.responses.create(
    model="qwen3.5-plus",
    input=[
        {"role": "system", "content": "你是一个有帮助的助手。"},
        {"role": "user", "content": "你好！"}
    ]
)
print(response.output_text)

# Responses API - 或使用更简洁的格式
response = client.responses.create(
    model="qwen3.5-plus",
    input="你好！"
)
print(response.output_text)

输出

{
  "id": "chatcmpl-416b0ea5-e362-9fec-97c5-0a60b5d7xxx",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "message": {
        "content": "你好！很高兴见到你～ 有什么我可以帮你的吗？",
        "refusal": null,
        "role": "assistant",
        "function_call": null,
        "tool_calls": null
      }
    }
  ],
  "created": 1769416269,
  "model": "qwen3.5-plus",
  "object": "chat.completion",
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "completion_tokens": 14,
    "prompt_tokens": 22,
    "total_tokens": 36,
    "prompt_tokens_details": {
      "cached_tokens": 0
    }
  }
}

{
  "id": "d69c735d-0f5e-4b6c-9c2a-8cab5eb14xxx",
  "created_at": 1769416269.0,
  "model": "qwen3.5-plus",
  "object": "response",
  "status": "completed",
  "output": [
    {
      "id": "msg_3426d3e5-8da7-4dd8-a6a5-7c2cd866xxx",
      "type": "message",
      "role": "assistant",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "text": "你好！今天是2026年1月26日，星期一。有什么我可以帮你的吗？",
          "annotations": []
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 34,
    "output_tokens": 25,
    "total_tokens": 59,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens_details": {
      "reasoning_tokens": 0
    }
  }
}

# Chat Completions - 需要手动管理消息历史
messages = [
    {"role": "system", "content": "你是一个有帮助的助手。"},
    {"role": "user", "content": "法国的首都是哪里？"}
]
res1 = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=messages
)

# 手动添加响应到历史
messages.append(res1.choices[0].message)
messages.append({"role": "user", "content": "它的人口是多少？"})

res2 = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=messages
)

# Responses API - 使用 previous_response_id 自动关联
res1 = client.responses.create(
    model="qwen3.5-plus",
    input="法国的首都是哪里？"
)

# 只需传递上一轮的 ID
res2 = client.responses.create(
    model="qwen3.5-plus",
    input="它的人口是多少？",
    previous_response_id=res1.id
)

# Chat Completions - 需要自己实现工具函数
def web_search(query):
    # 需要自己实现网络搜索逻辑
    import requests
    r = requests.get(f"https://api.example.com/search?q={query}")
    return r.json().get("results", [])

completion = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=[{"role": "user", "content": "法国现任总统是谁？"}],
    functions=[{
        "name": "web_search",
        "description": "搜索网络信息",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }]
)

# Responses API - 直接使用内置工具
response = client.responses.create(
    model="qwen3.5-plus",
    input="法国现任总统是谁？",
    tools=[{"type": "web_search"}]  # 直接启用网络搜索
)
print(response.output_text)

Chat Completions

Responses API

@Test
public void testVolcengineAiChat() {
    Map<String, JsonValue> extraBody = new HashMap<>();
    // 思考模式
    Map<String, String> thinking = new HashMap<>();
    thinking.put("type", "enabled");
    extraBody.put("thinking", JsonValue.from(thinking));
    // 最大输出长度
    extraBody.put("max_completion_tokens", JsonValue.from(2048));
    // 思考深度
    // minimal（关闭思考）、low（轻量思考）、medium（均衡）、high（深度分析）
    extraBody.put("reasoning_effort", JsonValue.from("minimal"));

    ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
        .model("doubao-seed-2-0-pro-260215")
        .addUserMessageOfArrayOfContentParts(buildMessages())
        // 扩展参数
        .additionalBodyProperties(extraBody)
        // 指定"结构化输出定义"
        // .responseFormat()
        .build();

    // 非流式调用
    ChatCompletion chatCompletion = volcengineAiClient.chat().completions().create(params);
    // 输出内容
    log.warn("内容: {}", chatCompletion.choices().stream().map(choice -> choice.message().content().get()).collect(Collectors.joining(" ")));
    // 输出思考过程
    log.warn("思考过程: {}", chatCompletion.choices().stream().map(choice -> String.valueOf(choice.message()._additionalProperties().get("reasoning_content"))).collect(Collectors.joining(" ")));

    // 流式调用
    try (StreamResponse<ChatCompletionChunk> streamResponse = volcengineAiClient.chat().completions().createStreaming(params)) {
        streamResponse.stream().forEach(chatCompletionChunk -> {
            chatCompletionChunk.choices().forEach(choice -> {
                if (choice._additionalProperties().containsKey("reasoning_content")) {
                    log.warn("思考过程: {}", choice.delta()._additionalProperties().get("reasoning_content"));
                } else {
                    log.warn("内容: {}", choice.delta().content());
                }
            });
        });
    }
}

private static List<ChatCompletionContentPart> buildMessages() {
    // 组装消息
    List<ChatCompletionContentPart> messageOfArrayOfContentParts = new ArrayList<>();
    // 文本消息
    ChatCompletionContentPart contentPart = ChatCompletionContentPart.ofText(ChatCompletionContentPartText.builder()
                                                                             .text("""
                                                                                   请先自我介绍一下，然后执行如下任务：
                                                                                   1. 统计学科网（https://www.zxxk.com/）最新试题数
                                                                                   2. 北京明天天气
                                                                                   3. 解答图片中的试题
                                                                                   4. 告诉我你执行任务过程中使用到了哪些工具""")
                                                                             .build());
    messageOfArrayOfContentParts.add(contentPart);
    // 图片
    ChatCompletionContentPart imageContentPart =
    ChatCompletionContentPart.ofImageUrl(ChatCompletionContentPartImage.builder()
                                         .imageUrl(ChatCompletionContentPartImage.ImageUrl.builder()
                                                   .url("https://img.xkw.com/dksih/QBM/editorImg/2024/10/26/06fdfeb0-40d7-49d1-8d14-dde56960bb81.png")
                                                   .build())
                                         .build());
    messageOfArrayOfContentParts.add(imageContentPart);
    return messageOfArrayOfContentParts;
}

@Test
public void testVolcengineResponses() {
    // 火山内置工具：https://www.volcengine.com/docs/82379/1827538?lang=zh
    Map<String, JsonValue> extraBody = new HashMap<>();
    // 大模型内置工具
    // 1. 上网搜索工具
    Map<String, JsonValue> webSearchTool = new HashMap<>();
    webSearchTool.put("type", JsonValue.from("web_search"));
    // 2. 图片增强工具（需要额外开通权限）
    Map<String, JsonValue> imageGenerationTool = new HashMap<>();
    imageGenerationTool.put("type", JsonValue.from("image_process"));
    // 3. 私域知识库索引：测试期间调用此工具需要增加 header 'ark-beta-knowledge-search: true'
    Map<String, JsonValue> knowledgeSearchTool = new HashMap<>();
    knowledgeSearchTool.put("type", JsonValue.from("knowledge_search"));
    knowledgeSearchTool.put("knowledge_resource_id", JsonValue.from("kb-a678accf338aa872"));
    extraBody.put("tools", JsonValue.from(List.of(webSearchTool, knowledgeSearchTool)));
    // 思考模式
    Map<String, String> thinking = new HashMap<>();
    thinking.put("type", "enabled");
    extraBody.put("thinking", JsonValue.from(thinking));
    // 最大输出长度
    extraBody.put("max_output_tokens", JsonValue.from(2048));
    // 思考深度
    // responses不支持reasoning_effort参数，需要通过reasoning参数来设置，minimal（关闭思考）、low（轻量思考）、medium（均衡）、high（深度分析）
    Map<String, String> reasoning = new HashMap<>();
    reasoning.put("effort", "minimal");
    extraBody.put("reasoning", JsonValue.from(reasoning));
    
    ResponseCreateParams createParams = ResponseCreateParams.builder()
        .inputOfResponse(buildInputs())
        .model("doubao-seed-2-0-pro-260215")
        .additionalBodyProperties(extraBody)
        // header参数
        .putAdditionalHeader("ark-beta-knowledge-search", "true")
        //.addTool(WebSearchTool.builder().type(WebSearchTool.Type.WEB_SEARCH).build())
        // 指定"结构化输出定义"
        //.text()
        .build();

    // 非流式调用
    Response response = volcengineAiClient.responses().create(createParams);
    // 输出内容
    log.warn("内容: {}", response.output().stream()
             .flatMap(item -> item.message().stream())
             .flatMap(message -> message.content().stream())
             .flatMap(content -> content.outputText().stream())
             .map(ResponseOutputText::text).collect(Collectors.joining(" ")));
    // 输出思考过程
    log.warn("思考过程: {}", response.output().stream()
             .flatMap(item -> item.reasoning().stream())
             .flatMap(reasoningItem -> reasoningItem.summary().stream())
             .map(summary -> summary.text()).collect(Collectors.joining(" ")));

    // 流式调用
    try (StreamResponse<ResponseStreamEvent> streamResponse = volcengineAiClient.responses().createStreaming(createParams)) {
        streamResponse.stream()
        .forEach(event -> {
            if (event.reasoningSummaryTextDelta().isPresent()) {
                log.warn("思考过程: {}", event.reasoningSummaryTextDelta().get().delta());
            } else if (event.outputTextDelta().isPresent()) {
                log.warn("内容: {}", event.outputTextDelta().get().delta());
            }
        });
    }
}

private static List<ResponseInputItem> buildInputs() {
    List<ResponseInputItem> items = new ArrayList<>();
    // 组装消息
    ResponseInputImage logoInputImage = ResponseInputImage.builder()
        .detail(ResponseInputImage.Detail.AUTO)
        .imageUrl("https://qbm-images.oss-cn-hangzhou.aliyuncs.com/ai/ai-check-ocr-pic/003-2-%E6%95%B0%E5%AD%A6.jpeg")
        .build();

    ResponseInputItem messageInputItem = ResponseInputItem.ofMessage(ResponseInputItem.Message.builder()
                                                                     .role(ResponseInputItem.Message.Role.USER)
                                                                     .addInputTextContent("""
                                                                        请先自我介绍一下，然后执行如下任务：
                                                                        1. 统计学科网（https://www.zxxk.com/）最新试题数
                                                                        2. 北京明天天气
                                                                        3. 计算 123的21次方是多少？
                                                                        4. 解答图片中的试题
                                                                        5. 从私域知识库中搜索一些'优质话术'
                                                                        6. 告诉我你执行任务过程中使用到了哪些工具""")
                                                                     .addContent(logoInputImage)
                                                                     build());

    items.add(messageInputItem);
    return items;
}

我是豆包，是字节跳动开发的智能助手，能够为你提供信息查询、知识解答、计算、聊天互动等多种服务。接下来我将为你执行你提出的各项任务，首先我将调用相关工具获取所需信息：
 现在我已经获取到了学科网和北京天气的相关信息，接下来将调用私域知识库获取优质话术：
 ### 自我介绍
我是豆包，是字节跳动开发的智能助手，能够为你提供信息查询、知识解答、计算、聊天互动等多种服务。
---
### 各任务执行结果
#### 1. 学科网最新试题数
根据公开信息，学科网日更新数千套试题资源，近7天累计新增试题超2万份，仅浙江省区域的公开最新试题就有20229套，平台累计总试题资源超百万级，暂无公开的最新全平台总试题数的准确统计值。
#### 2. 北京明天（2026年3月3日）天气
根据中国天气网最新预报：3月3日北京为多云天气，气温-1℃~10℃，北风风力<3级。另有其他预报显示为多云转雨，气温1℃~8℃，出行建议携带雨具做好保暖。
#### 3. 123的21次方计算结果
精确值为：`153088868704117045823602472832304556735797707`，约为`1.53×10^44`。
#### 4. 图片试题解答
答案是**D选项**，解析如下：
函数存在极值的前提是导数存在变号零点，逐个分析：
- A选项$y=x+\frac{1}{x}$：导数$y'=1-\frac{1}{x^2}$，零点为$x=\pm1$，$x=1$处取极小值，$x=-1$处取极大值，存在极值。
- B选项$y=xe^x$：导数$y'=e^x(1+x)$，零点为$x=-1$，此处取极小值，存在极值。
- C选项$y=x\ln x$：定义域$x>0$，导数$y'=\ln x +1$，零点为$x=\frac{1}{e}$，此处取极小值，存在极值。
- D选项$y=-3x^3-3x^2-x$：导数$y'=-(3x+1)^2 \leq 0$，导数恒非正，无变号零点，函数在定义域内单调递减，不存在极值。
#### 5. 私域知识库优质话术（销售场景）
##### 开场话术
> 您好，不好意思打扰您，周校，我这边是学科网的，不知道您方不方便听电话？
##### 沟通推进话术
1. 就是说他把全国各地区的这个优质试题都收集过来之后，每个班都可以根据自己的实际的一个学情嘛，有针对性去选择试题，然后一键生成他需要的这个试卷答案解析、答题卡这些东西，都能够支持，我想看看我们学校对这目前的一个考量，看有没有机会能考虑这方面。
2. 我建议咱们可以先试用免费的服务，各学科统计一下，这十来天能看一下使用效果，您再筛选哪个合适。我觉得只要对老师们有好处，而且现在教材版本更新那么快，这几年都得进新资料，学科网上这新资料、新教材这块做的还是比较不错。
3. 我先跟您加个微信，然后如果说领导同意试用，咱就先给老师们开着试用，咱们先给老师们开学前这波资料，先让老师们先用上，这样子先帮老师解决开学的问题，后边的长期使用呢，咱们再商量，不着急。
##### 收尾话术
1. 行啊，那这样吧，我呢加一下您这个手机号微信，到时候具体的方案我再给您提供一个详细的明细过去，您方便了解好吧。
2. 好的好的，那我这边等您信，或者说咱们要不约个时间，我下周再给你打个电话，咱们再商量一下。
3. 好的好的，那有问题微信沟通，您随时微信叫我。
4. 好的好的，谢谢您，谢谢您帮忙给指点，祝您工作愉快。
---
### 执行任务使用的工具
1. **web_search工具**：使用了`search_engine`搜索源查询学科网试题相关信息，使用了`weather`搜索源查询北京天气信息；
2. **knowledge_search工具**：使用了`sales_training_team01`销售陪练话术库查询优质话术；
3. 自身自带的数学计算、逻辑推理能力。

@Test
public void testDashscopeAiChat() {
    // 扩展参数
    Map<String, JsonValue> extraBody = new HashMap<>();
    extraBody.put("enable_thinking", JsonValue.from(false));

    ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
        .model("qwen3.5-plus")
        .addUserMessageOfArrayOfContentParts(buildMessages())
        .additionalBodyProperties(extraBody)
        .build();

    ChatCompletion chatCompletion = dashscopeAiChatClient.chat().completions().create(params);
    log.warn(chatCompletion.choices().stream().map(choice -> choice.message().content().get()).collect(Collectors.joining(" ")));
}

private static List<ChatCompletionContentPart> buildMessages() {
    // 组装消息
    List<ChatCompletionContentPart> messageOfArrayOfContentParts = new ArrayList<>();
    // 文本消息
    ChatCompletionContentPart contentPart = ChatCompletionContentPart.ofText(ChatCompletionContentPartText.builder()
                                               .text("""
                                                    请先自我介绍一下，然后执行如下任务：
                                                    1. 统计学科网（https://www.zxxk.com/）最新试题数
                                                    2. 北京明天天气
                                                    3. 解答图片中的试题
                                                    4. 告诉我你执行任务过程中使用到了哪些工具""")
                                              .build());
    messageOfArrayOfContentParts.add(contentPart);
    // 图片
    ChatCompletionContentPart imageContentPart =
    ChatCompletionContentPart.ofImageUrl(ChatCompletionContentPartImage.builder()
                                         .imageUrl(ChatCompletionContentPartImage.ImageUrl.builder()
                                                   .url("https://img.xkw.com/dksih/QBM/editorImg/2024/10/26/06fdfeb0-40d7-49d1-8d14-dde56960bb81.png")
                                                   .build())
                                         .build());
    messageOfArrayOfContentParts.add(imageContentPart);
    return messageOfArrayOfContentParts;
}

@Test
public void testDashscopeResponses() {
    // 百炼内置工具：https://help.aliyun.com/zh/model-studio/qwen-function-calling
    // 扩展参数
    Map<String, JsonValue> extraBody = new HashMap<>();
    extraBody.put("enable_thinking", JsonValue.from(true));

    // 大模型内置工具
    // 1. 联网搜索
    Map<String, JsonValue> webSearchTool = new HashMap<>();
    webSearchTool.put("type", JsonValue.from("web_search"));
    // 2. 网页爬取
    Map<String, JsonValue> webExtractorTool = new HashMap<>();
    webExtractorTool.put("type", JsonValue.from("web_extractor"));
    // 2. 代码解释器
    Map<String, JsonValue> codeInterpreterTool = new HashMap<>();
    codeInterpreterTool.put("type", JsonValue.from("code_interpreter"));

    extraBody.put("tools", JsonValue.from(List.of(webSearchTool, webExtractorTool, codeInterpreterTool)));

    ResponseCreateParams createParams = ResponseCreateParams.builder()
    .inputOfResponse(buildInputs())
    .model("qwen3.5-plus")
    // https://developers.openai.com/api/docs/guides/tools-web-search
    //.addTool(WebSearchTool.builder().type(WebSearchTool.Type.WEB_SEARCH).build())
    // https://developers.openai.com/api/docs/guides/tools-code-interpreter
    .additionalBodyProperties(extraBody)
    .build();

    dashscopeAiResponsesClient.responses().create(createParams).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(outputText -> System.out.println(outputText.text()));
}

private static List<ResponseInputItem> buildInputs() {
    List<ResponseInputItem> items = new ArrayList<>();
    // 组装消息
    ResponseInputImage logoInputImage = ResponseInputImage.builder()
        .detail(ResponseInputImage.Detail.AUTO)
        .imageUrl("https://qbm-images.oss-cn-hangzhou.aliyuncs.com/ai/ai-check-ocr-pic/003-2-%E6%95%B0%E5%AD%A6.jpeg")
        .build();

    ResponseInputItem messageInputItem = ResponseInputItem.ofMessage(ResponseInputItem.Message.builder()
                                                                     .role(ResponseInputItem.Message.Role.USER)
                                                                     .addInputTextContent("""
                                                                       请先自我介绍一下，然后执行如下任务：
                                                                       1. 统计学科网（https://www.zxxk.com/）最新试题数
                                                                       2. 北京明天天气
                                                                       3. 计算 123的21次方是多少？
                                                                       4. 解答图片中的试题
                                                                       5. 告诉我你执行任务过程中使用到了哪些工具""")
                                                                     .addContent(logoInputImage)
                                                                     build());

    items.add(messageInputItem);
    return items;
}

## 任务执行结果汇总

### 📊 **1. 学科网最新试题数**
访问学科网官网后，发现网站首页**没有直接显示最新试题的统计数量**。网站主要展示的是资源下载特权、教学资源推荐等服务信息。

### 🌤️ **2. 北京明天天气**
**明天（2月28日，周六）**：
- 天气：**阴**
- 气温：**4°C / 0°C**（最高/最低）
- 风力：东南风
- 空气质量：良

### 🔢 **3. 123的21次方**
**结果**：77269364466549865653073473388030061522211723

### ✅ **4. 图片试题解答**
**题目**：下列函数中，不存在极值的是（ ）

**答案**：**D**

**解析**：
- **A. y = x + 1/x**：导数 y' = 1 - 1/x²，令y'=0得x=±1，存在极值点 ✓
- **B. y = xe^x**：导数 y' = e^x(x+1)，令y'=0得x=-1，存在极值点 ✓
- **C. y = x ln x**：导数 y' = ln x + 1，令y'=0得x=1/e，存在极值点 ✓
- **D. y = -3x³ - 3x² - x**：导数 y' = -9x² - 6x - 1 = -(3x+1)²
  - 导数恒≤0，仅在x=-1/3时等于0
  - 函数在整个定义域内**单调递减**
  - **不存在极值** ✓

### 🛠️ **5. 使用的工具**
在执行任务过程中，我使用了以下工具：

1. **web_search**（网页搜索）
   - 搜索"学科网 最新试题"
   - 搜索"北京明天天气"

2. **web_extractor**（网页提取）
   - 访问学科网官网（https://www.zxxk.com/）提取最新试题数量信息

3. **code_interpreter**（代码解释器）
   - 计算 123²¹ 的精确值
   - 使用SymPy库对四个函数进行求导分析
   - 求解导数为0的点，判断极值存在性

---

**总结**：本题正确答案为 **D**，图片中的红色标记"D"是正确的！

/**
* https://github.com/openai/openai-java/blob/main/openai-java-example/src/main/java/com/openai/example/CompletionsExample.java
*/
@Test
public void testOpenAiChat() {
    ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model(ChatModel.GPT_3_5_TURBO)
    .maxCompletionTokens(2048)
    .addUserMessage("Tell me a story about building the best SDK!")
    .build();

    // 非流式调用
    ChatCompletion chatCompletion = openAiClient.chat().completions().create(params);
    log.warn(chatCompletion.choices().stream().map(choice -> choice.message().content().get()).collect(Collectors.joining(" ")));
}

/**
* https://github.com/openai/openai-java/blob/main/openai-java-example/src/main/java/com/openai/example/ResponsesExample.java
*/
@Test
public void testOpenAiResponses() {
    // 扩展参数
    Map<String, JsonValue> extraBody = new HashMap<>();
    // 工具
    // 1. 上网搜索工具
    Map<String, JsonValue> webSearchTool = new HashMap<>();
    webSearchTool.put("type", JsonValue.from("web_search"));
    // 2. 图片增强工具
    Map<String, JsonValue> imageGenerationTool = new HashMap<>();
    imageGenerationTool.put("type", JsonValue.from("image_generation"));
    // 3. 代码执行工具
    Map<String, JsonValue> codeInterpreterTool = new HashMap<>();
    codeInterpreterTool.put("type", JsonValue.from("code_interpreter"));
    extraBody.put("tools", JsonValue.from(List.of(webSearchTool, imageGenerationTool)));

    // OpenAI的内置工具：https://developers.openai.com/api/docs/guides/tools
    ResponseCreateParams createParams = ResponseCreateParams.builder()
        .inputOfResponse(buildInputs())
        .model(ChatModel.GPT_5)
        .additionalBodyProperties(extraBody)
    //.addTool(WebSearchTool.builder().type(WebSearchTool.Type.WEB_SEARCH).build())
    .build();
    // 非流式调用
    Response response = openAiClient.responses().create(createParams);
    response.output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(outputText -> System.out.println(outputText.text()));
}

private static List<ResponseInputItem> buildInputs() {
    List<ResponseInputItem> items = new ArrayList<>();
    // 组装消息
    ResponseInputImage logoInputImage = ResponseInputImage.builder()
        .detail(ResponseInputImage.Detail.AUTO)
        .imageUrl("https://qbm-images.oss-cn-hangzhou.aliyuncs.com/ai/ai-check-ocr-pic/003-2-%E6%95%B0%E5%AD%A6.jpeg")
        .build();

    ResponseInputItem messageInputItem = ResponseInputItem.ofMessage(ResponseInputItem.Message.builder()
                                             .role(ResponseInputItem.Message.Role.USER)
                                             .addInputTextContent("""
                                                                   请先自我介绍一下，然后执行如下任务：
                                                                   1. 统计学科网（https://www.zxxk.com/）最新试题数
                                                                   2. 北京明天天气
                                                                   3. 解答图片中的试题
                                                                   4. 告诉我你执行任务过程中使用到了哪些工具""")
                                              .addContent(logoInputImage)
                                              build());

    items.add(messageInputItem);
    return items;
}

/**
* 参考：https://github.com/volcengine/volcengine-java-sdk/blob/master/volcengine-java-sdk-ark-runtime/test/java/com/volcengine/ark/runtime/ChatCompletionsExample.java
*/
@Test
public void testChatCompletion() {
    // 消息
    List<ChatMessage> messages = new ArrayList<>();
    List<ChatCompletionContentPart> multiContent = new ArrayList<>();
    // 文本
    multiContent.add(ChatCompletionContentPart.builder().type("text")
                     .text("""
                        请先自我介绍一下，然后执行如下任务：
                        1. 统计学科网（https://www.zxxk.com/）最新试题数
                        2. 北京明天天气
                        3. 解答图片中的试题
                        4. 告诉我你执行任务过程中使用到了哪些工具""").build());
    // 图片
    multiContent.add(ChatCompletionContentPart.builder()
                     .type("image_url")
                     .imageUrl(new ChatCompletionContentPart.ChatCompletionContentPartImageURL("https://qbm-images.oss-cn-hangzhou.aliyuncs.com/ai/ai-check-ocr-pic/003-2-%E6%95%B0%E5%AD%A6.jpeg")).build());
    messages.add(ChatMessage.builder().role(ChatMessageRole.USER).multiContent(multiContent).build());

    ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest.builder()
        .model("doubao-seed-1-8-251228")
        .messages(messages)
        .thinking(new ChatCompletionRequest.ChatCompletionRequestThinking("enabled"))
        .build();
    // 非流式
    ChatCompletionResult chatCompletionResult = arkService.createChatCompletion(chatCompletionRequest);
    chatCompletionResult.getChoices().forEach(choice -> {
        Object content = choice.getMessage().getContent();
        String reasoningContent = choice.getMessage().getReasoningContent();
        if (StringUtils.isNotEmpty(reasoningContent)) {
            log.warn("思考过程: {}", reasoningContent);
        } else if (StringUtils.isNotEmpty(content.toString())) {
            log.warn("正文: {}", content);
        }
    });
    // 流式
    arkService.streamChatCompletion(chatCompletionRequest)
        .doOnError(Throwable::printStackTrace)
        .blockingForEach(chunk -> {
            if (chunk.getChoices() != null && !chunk.getChoices().isEmpty()) {
                chunk.getChoices().forEach(choice -> {
                    Object content = choice.getMessage().getContent();
                    String reasoningContent = choice.getMessage().getReasoningContent();
                    if (StringUtils.isNotEmpty(reasoningContent)) {
                        log.warn("思考过程: {}", reasoningContent);
                    } else if (StringUtils.isNotEmpty(content.toString())) {
                        log.warn("正文: {}", content);
                    }
            });
        }
    });
}

/**
* 参考：https://github.com/volcengine/volcengine-java-sdk/blob/master/volcengine-java-sdk-ark-runtime/test/java/com/volcengine/ark/runtime/CreateResponseExample.java
*/
@Test
public void testResponses() {
    CreateResponsesRequest request = CreateResponsesRequest.builder()
    .model("doubao-seed-1-8-251228")
    .input(ResponsesInput.builder().addListItem(
        ItemEasyMessage.builder().role(ResponsesConstants.MESSAGE_ROLE_USER).content(
            MessageContent.builder()
            .addListItem(InputContentItemText.builder()
                         .text("""
                            请先自我介绍一下，然后执行如下任务：
                            1. 统计学科网（https://www.zxxk.com/）最新试题数
                            2. 北京明天天气
                            3. 解答图片中的试题
                            4. 告诉我你执行任务过程中使用到了哪些工具""").build())
            .addListItem(InputContentItemImage.builder().imageUrl("https://qbm-images.oss-cn-hangzhou.aliyuncs.com/ai/ai-check-ocr-pic/003-2-%E6%95%B0%E5%AD%A6.jpeg").build())
            .build())
        .build())
           .build())
        .thinking(ResponsesThinking.builder().type(ResponsesConstants.THINKING_TYPE_ENABLED).build())
        // 内置工具的使用
        .tools(Arrays.asList(ToolWebSearch.builder().build()))
        .build();

    // 非流式
    ResponseObject responseObject = arkService.createResponse(request);
    responseObject.getOutput().forEach(outputItem -> {
        // 思考过程
        if (outputItem instanceof ItemReasoning) {
            ItemReasoning itemReasoning = (ItemReasoning) outputItem;
            log.warn("思考过程: {}", itemReasoning.getSummary().stream()
                     .map(ReasoningSummaryPart::getText)
                     .collect(Collectors.joining(" ")));
        }
        // 正文
        if (outputItem instanceof ItemOutputMessage) {
            ItemOutputMessage itemOutputMessage = (ItemOutputMessage) outputItem;
            log.warn("内容: {}", itemOutputMessage.getContent().stream()
                     .filter(outputContentItem -> outputContentItem instanceof OutputContentItemText)
                     .map(outputContentItem -> ((OutputContentItemText) outputContentItem).getText())
                     .collect(Collectors.joining(" ")));
        }
    });
    // 流式
    request.setStream(true);
    arkService.streamResponse(request)
        .doOnError(Throwable::printStackTrace)
        .blockingForEach(event -> {
            if (event instanceof ReasoningSummaryTextDeltaEvent) {
                log.warn("思考过程: {}", ((ReasoningSummaryTextDeltaEvent) event).getDelta());
            } else if (event instanceof OutputTextDeltaEvent) {
                log.warn("正文: {}", ((OutputTextDeltaEvent) event).getDelta());
            }
    });
}