代码能力（Qwen-Coder）

请求示例

import os
from openai import OpenAI

client = OpenAI(
    # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    # 此处以qwen3-coder-plus为例，可按需更换模型名称。
    model="qwen3-coder-plus",
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': '请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。'}],
)
print(completion.choices[0].message.content)

返回结果

def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes

请求示例

import OpenAI from "openai";

const client = new OpenAI(
    {
        // 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
        // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
    }
);

async function main() {
    const completion = await client.chat.completions.create({
        model: "qwen3-coder-plus",  //此处以qwen3-coder-plus为例，可按需更换模型名称。
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。" }
        ],
    });
    console.log(completion.choices[0].message.content);
}

main();

返回结果

def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes

请求示例

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3-coder-plus",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user", 
            "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"
        }
    ]
}'

返回结果

{
    "choices": [
        {
            "message": {
                "content": "def find_prime_numbers(n):\n    if n <= 2:\n        return []\n    \n    primes = []\n    \n    for num in range(2, n):\n        is_prime = True\n        for i in range(2, int(num ** 0.5) + 1):\n            if num % i == 0:\n                is_prime = False\n                break\n        if is_prime:\n            primes.append(num)\n    \n    return primes",
                "role": "assistant"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 96,
        "completion_tokens": 90,
        "total_tokens": 186,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "created": 1761615592,
    "system_fingerprint": null,
    "model": "qwen3-coder-plus",
    "id": "chatcmpl-3de690bd-ae7f-461d-8eb6-d65b0577e803"
}

请求示例

import dashscope
import os

# 若使用新加坡地域的模型，请取消下行注释
# dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"
messages = [
    {
        "role": "system",
        "content": "You are a helpful assistant."
    },
    {
        "role": "user",
        "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"
    }
]

response = dashscope.Generation.call(
    # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key = "sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen3-coder-plus",
    messages=messages,
    result_format="message"
)

if response.status_code == 200:
    print(response.output.choices[0].message.content)
else:
    print(f"HTTP返回码：{response.status_code}")
    print(f"错误码：{response.code}")
    print(f"错误信息：{response.message}")

返回结果

def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes

请求示例

import java.util.Arrays;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.protocol.Protocol;


public class Main {
    public static GenerationResult callWithMessage()
            throws NoApiKeyException, ApiException, InputRequiredException {
        String apiKey = System.getenv("DASHSCOPE_API_KEY");
        // 以下为北京地域base_url，若使用新加坡地域的模型，需将base_url替换为：https://dashscope-intl.aliyuncs.com/api/v1
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope.aliyuncs.com/api/v1");
        Message sysMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant.").build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。").build();
        // 此处以qwen3-coder-plus为例，可按需更换模型名称。
        GenerationParam param = GenerationParam.builder()
                .apiKey(apiKey)
                .model("qwen3-coder-plus")
                .messages(Arrays.asList(sysMsg, userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args){
        try {
            GenerationResult result = callWithMessage();
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            System.err.println("请求异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

返回结果

def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes

请求示例

curl -X POST "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3-coder-plus",
    "input":{
        "messages":[      
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

返回结果

{
    "output": {
        "choices": [
            {
                "message": {
                    "content": "def find_prime_numbers(n):\n    if n <= 2:\n        return []\n    \n    primes = []\n    \n    for num in range(2, n):\n        is_prime = True\n        for i in range(2, int(num ** 0.5) + 1):\n            if num % i == 0:\n                is_prime = False\n                break\n        if is_prime:\n            primes.append(num)\n    \n    return primes",
                    "role": "assistant"
                },
                "finish_reason": "stop"
            }
        ]
    },
    "usage": {
        "total_tokens": 186,
        "output_tokens": 90,
        "input_tokens": 96,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "request_id": "b1b8d1f8-0d26-4651-a466-66eefa0e7c51"
}

请求示例

import os
from openai import OpenAI

client = OpenAI(
    # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3-coder-plus",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"}
    ],
    stream=True,
    # 在最后一个chunk中获取本次请求的Token用量
    stream_options={"include_usage": True}
)

content_parts = []
print("="*20+"回复内容"+"="*20)

for chunk in completion:
    # 最后一个chunk不包含choices，但包含usage信息
    if chunk.choices:
        # delta.content可能为None，使用`or ""`避免拼接时出错
        content = chunk.choices[0].delta.content or ""
        print(content, end="", flush=True)
        content_parts.append(content)
    elif chunk.usage:
        print("\n"+"="*20+"Token消耗"+"="*20)
        print(f"输入 Tokens: {chunk.usage.prompt_tokens}")
        print(f"输出 Tokens: {chunk.usage.completion_tokens}")
        print(f"总计 Tokens: {chunk.usage.total_tokens}")

full_response = "".join(content_parts)
# 如需获取完整响应字符串，请取消下行注释
# print(f"\n--- 完整回复 ---\n{full_response}")

返回结果

====================回复内容====================
def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes
====================Token消耗====================
输入 Tokens: 66
输出 Tokens: 89
总计 Tokens: 155

请求示例

import OpenAI from "openai";

const client = new OpenAI(
    {
        // 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
        // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
    }
);

async function main() {
    const stream = await client.chat.completions.create({
        model: "qwen3-coder-plus",
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。" },
        ],
        stream: true,
        // 在最后一个chunk中获取本次请求的Token用量
        stream_options: { include_usage: true },
    });

    const contentParts = [];
    console.log("=".repeat(20) + "回复内容" + "=".repeat(20));
    
    for await (const chunk of stream) {
        // 最后一个chunk不包含choices，但包含usage信息
        if (chunk.choices && chunk.choices.length > 0) {
            const content = chunk.choices[0]?.delta?.content || "";
            process.stdout.write(content);
            contentParts.push(content);
        } else if (chunk.usage) {
            // 请求结束，打印Token用量
            console.log("\n"+"=".repeat(20) + "Token消耗" + "=".repeat(20));
            console.log(`输入 Tokens: ${chunk.usage.prompt_tokens}`);
            console.log(`输出 Tokens: ${chunk.usage.completion_tokens}`);
            console.log(`总计 Tokens: ${chunk.usage.total_tokens}`);
        }
    }
    
    const fullResponse = contentParts.join("");
    // 如需获取完整响应字符串，请取消下行注释
    // console.log(`\n--- 完整回复 ---\n${fullResponse}`);
}

main();

返回结果

====================回复内容====================
def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes
====================Token消耗====================
输入 Tokens: 66
输出 Tokens: 89
总计 Tokens: 155

请求示例

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
--no-buffer \
-d '{
    "model": "qwen3-coder-plus",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"}
    ],
    "stream": true,
    "stream_options": {"include_usage": true}
}'

返回结果

data: {"choices":[{"delta":{"content":"","role":"assistant"},"index":0,"logprobs":null,"finish_reason":null}],"object":"chat.completion.chunk","usage":null,"created":1763085409,"system_fingerprint":null,"model":"qwen3-coder-plus","id":"chatcmpl-61f94113-f29b-4f7d-9730-551749d40ef4"}

data: {"choices":[{"finish_reason":null,"logprobs":null,"delta":{"content":"def"},"index":0}],"object":"chat.completion.chunk","usage":null,"created":1763085409,"system_fingerprint":null,"model":"qwen3-coder-plus","id":"chatcmpl-61f94113-f29b-4f7d-9730-551749d40ef4"}

data: {"choices":[{"delta":{"content":" find_prime_numbers(n"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1763085409,"system_fingerprint":null,"model":"qwen3-coder-plus","id":"chatcmpl-61f94113-f29b-4f7d-9730-551749d40ef4"}

......

data: {"choices":[{"delta":{"content":" primes"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1763085409,"system_fingerprint":null,"model":"qwen3-coder-plus","id":"chatcmpl-61f94113-f29b-4f7d-9730-551749d40ef4"}

data: {"choices":[{"finish_reason":"stop","delta":{"content":""},"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1763085409,"system_fingerprint":null,"model":"qwen3-coder-plus","id":"chatcmpl-61f94113-f29b-4f7d-9730-551749d40ef4"}

data: {"choices":[],"object":"chat.completion.chunk","usage":{"prompt_tokens":66,"completion_tokens":89,"total_tokens":155,"prompt_tokens_details":{"cached_tokens":0}},"created":1763085409,"system_fingerprint":null,"model":"qwen3-coder-plus","id":"chatcmpl-61f94113-f29b-4f7d-9730-551749d40ef4"}

data: [DONE]

请求示例

import os
from http import HTTPStatus
import dashscope
from dashscope import Generation

# 若使用新加坡地域的模型，请取消下行注释
# dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"},
]

responses = Generation.call(
    # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="qwen3-coder-plus",
    messages=messages,
    result_format="message",
    stream=True,
    # 增量输出，每个数据块仅包含新生成的内容
    incremental_output=True,
)

content_parts = []
print("="*20+"回复内容"+"="*20+"\n", end="", flush=True)

for resp in responses:
    if resp.status_code == HTTPStatus.OK:
        content = resp.output.choices[0].message.content
        print(content, end="", flush=True)
        content_parts.append(content)

        if resp.output.choices[0].finish_reason == "stop":
            print("\n"+"=" * 20 + "Token消耗" + "=" * 20)
            print(f"输入 Tokens: {resp.usage.input_tokens}")
            print(f"输出 Tokens: {resp.usage.output_tokens}")
            print(f"总计 Tokens: {resp.usage.total_tokens}")
    else:
        print(f"HTTP返回码：{resp.status_code}")
        print(f"错误码：{resp.code}")
        print(f"错误信息：{resp.message}")
full_response = "".join(content_parts)
# 如需获取完整响应字符串，请取消下行注释
# print(f"\n--- 完整回复 ---\n{full_response}")

返回结果

====================回复内容====================
def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes
====================Token消耗====================
输入 Tokens: 66
输出 Tokens: 89
总计 Tokens: 155

请求示例

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import io.reactivex.Flowable;
import io.reactivex.schedulers.Schedulers;
import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import com.alibaba.dashscope.protocol.Protocol;

public class Main {
    public static void main(String[] args) {
        String apiKey = System.getenv("DASHSCOPE_API_KEY");

        // 以下为北京地域base_url，若使用新加坡地域的模型，需将base_url替换为：https://dashscope-intl.aliyuncs.com/api/v1
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope.aliyuncs.com/api/v1");
        CountDownLatch latch = new CountDownLatch(1);

        GenerationParam param = GenerationParam.builder()
                .apiKey(apiKey)
                .model("qwen3-coder-plus")
                .messages(Arrays.asList(
                        Message.builder()
                                .role(Role.USER.getValue())
                                .content("请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。")
                                .build()
                ))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .incrementalOutput(true) // 开启增量输出，流式返回，每个数据块仅包含新生成的内容
                .build();
        try {
            Flowable<GenerationResult> result = gen.streamCall(param);
            StringBuilder fullContent = new StringBuilder();
            System.out.println("====================回复内容====================");
            result
                    .subscribeOn(Schedulers.io()) // IO线程执行请求
                    .observeOn(Schedulers.computation()) // 计算线程处理响应
                    .subscribe(
                            // onNext: 处理每个响应片段
                            message -> {
                                String content = message.getOutput().getChoices().get(0).getMessage().getContent();
                                String finishReason = message.getOutput().getChoices().get(0).getFinishReason();
                                // 输出内容
                                System.out.print(content);
                                fullContent.append(content);
                                // 当 finishReason 不为 null 时，表示是最后一个 chunk，输出用量信息
                                if (finishReason != null && !"null".equals(finishReason)) {
                                    System.out.println("\n====================Token消耗====================");
                                    System.out.println("输入 Tokens: " + message.getUsage().getInputTokens());
                                    System.out.println("输出 Tokens: " + message.getUsage().getOutputTokens());
                                    System.out.println("总计 Tokens: " + message.getUsage().getTotalTokens());
                                }
                                System.out.flush(); // 立即刷新输出
                            },
                            // onError: 处理错误
                            error -> {
                                System.err.println("\n请求失败: " + error.getMessage());
                                latch.countDown();
                            },
                            // onComplete: 完成回调
                            () -> {
                                System.out.println(); // 换行
                                // 如需获取完整响应字符串，请取消下行注释
                                // System.out.println("完整响应: " + fullContent.toString());
                                latch.countDown();
                            }
                    );
            // 主线程等待异步任务完成
            latch.await();
        } catch (Exception e) {
            System.err.println("请求异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

返回结果

====================回复内容====================
def find_prime_numbers(n):
    if n <= 2:
        return []
    
    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)
    
    return primes
====================Token消耗====================
输入 Tokens: 66
输出 Tokens: 89
总计 Tokens: 155

请求示例

curl -X POST https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-SSE: enable" \
-d '{
    "model": "qwen3-coder-plus",
    "input":{
        "messages":[      
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"
            }
        ]
    },
    "parameters": {
        "result_format": "message",
        "incremental_output":true
    }
}'

返回结果

id:1
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"def","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":67,"output_tokens":1,"input_tokens":66,"prompt_tokens_details":{"cached_tokens":0}},"request_id":"fadfc21b-4411-40d5-b143-8c3573284c42"}

id:2
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":" find_prime_numbers(n","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":71,"output_tokens":5,"input_tokens":66,"prompt_tokens_details":{"cached_tokens":0}},"request_id":"fadfc21b-4411-40d5-b143-8c3573284c42"}

id:3
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"):\n    if n","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":75,"output_tokens":9,"input_tokens":66,"prompt_tokens_details":{"cached_tokens":0}},"request_id":"fadfc21b-4411-40d5-b143-8c3573284c42"}

...

id:26
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":" primes","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":155,"output_tokens":89,"input_tokens":66,"prompt_tokens_details":{"cached_tokens":0}},"request_id":"fadfc21b-4411-40d5-b143-8c3573284c42"}

id:27
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","role":"assistant"},"finish_reason":"stop"}]},"usage":{"total_tokens":155,"output_tokens":89,"input_tokens":66,"prompt_tokens_details":{"cached_tokens":0}},"request_id":"fadfc21b-4411-40d5-b143-8c3573284c42"}

请求示例

import os
import json
from openai import OpenAI

client = OpenAI(
    # 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "将内容写入指定文件，若文件不存在则创建。",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "目标文件的相对或绝对路径"
                    },
                    "content": {
                        "type": "string",
                        "description": "写入文件的字符串内容"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]

# 工具函数实现
def write_file(path: str, content: str) -> str:
    """写入文件内容"""
    try:
        # 为安全起见，文件写入功能已默认禁用，如需使用请取消注释并确保路径安全
        # os.makedirs(os.path.dirname(path),exist_ok=True) if os.path.dirname(path) else None
        # with open(path, 'w', encoding='utf-8') as f:
        #     f.write(content)
        return f"成功: 文件 '{path}' 已写入"
    except Exception as e:
        return f"错误: 写入文件时发生异常 - {str(e)}"


messages = [{"role": "user", "content": "写一个python代码，快速排序，命名为quick_sort.py"}]

completion = client.chat.completions.create(
    model="qwen3-coder-plus",
    messages=messages,
    tools=tools
)

assistant_output = completion.choices[0].message
if assistant_output.content is None:
    assistant_output.content = ""
messages.append(assistant_output)

# 如果不需要调用工具，直接输出内容
if assistant_output.tool_calls is None:
    print(f"无需调用工具，直接回复：{assistant_output.content}")
else:
    # 进入工具调用循环
    while assistant_output.tool_calls is not None:
        for tool_call in assistant_output.tool_calls:
            tool_call_id = tool_call.id
            func_name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)
            print(f"正在调用工具 [{func_name}]，参数：{arguments}")
            # 执行工具
            tool_result = write_file(**arguments)
            # 构造工具返回信息
            tool_message = {
                "role": "tool",
                "tool_call_id": tool_call_id,
                "content": tool_result,
            }
            print(f"工具返回：{tool_message['content']}")
            messages.append(tool_message)
        # 再次调用模型，获取总结后的自然语言回复
        response = client.chat.completions.create(
            model="qwen3-coder-plus",
            messages=messages,
            tools=tools
        )
        assistant_output = response.choices[0].message
        if assistant_output.content is None:
            assistant_output.content = ""
        messages.append(assistant_output)
    print(f"模型最终回复：{assistant_output.content}")

返回结果

正在调用工具 [write_file]，参数：{'content': 'def quick_sort(arr):\\n    if len(arr) <= 1:\\n        return arr\\n    pivot = arr[len(arr) // 2]\\n    left = [x for x in arr if x < pivot]\\n    middle = [x for x in arr if x == pivot]\\n    right = [x for x in arr if x > pivot]\\n    return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\"__main__\\":\\n    example_list = [3, 6, 8, 10, 1, 2, 1]\\n    print(\\"Original list:\\", example_list)\\n    sorted_list = quick_sort(example_list)\\n    print(\\"Sorted list:\\", sorted_list)', 'path': 'quick_sort.py'}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：好的，已经为你创建了名为 `quick_sort.py` 的文件，其中包含了快速排序的 Python 实现。你可以运行这个文件查看示例输出。如果需要进一步修改或解释，请告诉我！

请求示例

import OpenAI from "openai";
import fs from "fs/promises";
import path from "path";

const client = new OpenAI({
    // 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
    // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
    apiKey: process.env.DASHSCOPE_API_KEY,
    // 以下是北京地域base_url，如果使用新加坡地域的模型，需要将base_url替换为：https://dashscope-intl.aliyuncs.com/compatible-mode/v1
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
});

const tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "将内容写入指定文件，若文件不存在则创建。",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "目标文件的相对或绝对路径"
                    },
                    "content": {
                        "type": "string",
                        "description": "写入文件的字符串内容"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
];

// 工具函数实现
async function write_file(filePath, content) {
    try {
        // 为安全起见，文件写入功能已默认禁用，如需使用请取消注释并确保路径安全
        // const dir = path.dirname(filePath);
        // if (dir) {
        //     await fs.mkdir(dir, { recursive: true });
        // }
        // await fs.writeFile(filePath, content, "utf-8");
        return `成功: 文件 '${filePath}' 已写入`;
    } catch (error) {
        return `错误: 写入文件时发生异常 - ${error.message}`;
    }
}

const messages = [{"role": "user", "content": "写一个python代码，快速排序，命名为quick_sort.py"}];

async function main() {
    const completion = await client.chat.completions.create({
        model: "qwen3-coder-plus",
        messages: messages,
        tools: tools
    });

    let assistant_output = completion.choices[0].message;
    // 确保 content 不是 null
    if (!assistant_output.content) assistant_output.content = "";
    messages.push(assistant_output);

    // 如果不需要调用工具，直接输出内容
    if (!assistant_output.tool_calls) {
        console.log(`无需调用工具，直接回复：${assistant_output.content}`);
    } else {
        // 进入工具调用循环
        while (assistant_output.tool_calls) {
            for (const tool_call of assistant_output.tool_calls) {
                const tool_call_id = tool_call.id;
                const func_name = tool_call.function.name;
                const args = JSON.parse(tool_call.function.arguments);
                console.log(`正在调用工具 [${func_name}]，参数：`, args);
                // 执行工具
                const tool_result = await write_file(args.path, args.content);
                // 构造工具返回信息
                const tool_message = {
                    "role": "tool",
                    "tool_call_id": tool_call_id,
                    "content": tool_result
                };
                console.log(`工具返回：${tool_message.content}`);
                messages.push(tool_message);
            }
            // 再次调用模型，获取总结后的自然语言回复
            const response = await client.chat.completions.create({
                model: "qwen3-coder-plus",
                messages: messages,
                tools: tools
            });
            assistant_output = response.choices[0].message;
            if (!assistant_output.content) assistant_output.content = "";
            messages.push(assistant_output);
        }
        console.log(`模型最终回复：${assistant_output.content}`);
    }
}

main();

返回结果

正在调用工具 [write_file]，参数： {
  content: 'def quick_sort(arr):\\n    if len(arr) <= 1:\\n        return arr\\n    pivot = arr[len(arr) // 2]\\n    left = [x for x in arr if x < pivot]\\n    middle = [x for x in arr if x == pivot]\\n    right = [x for x in arr if x > pivot]\\n    return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\"__main__\\":\\n    example_list = [3, 6, 8, 10, 1, 2, 1]\\n    print(\\"Original list:\\", example_list)\\n    sorted_list = quick_sort(example_list)\\n    print(\\"Sorted list:\\", sorted_list)',
  path: 'quick_sort.py'
}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：已成功创建 `quick_sort.py` 文件，其中包含快速排序的 Python 实现。你可以运行该文件以查看示例列表的排序结果。如果需要进一步修改或解释，请告诉我！

请求示例

该示例展示了工具调用流程的第一步：发起请求并获得模型的工具调用意图。

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3-coder-plus",
    "messages": [
        {
            "role": "user", 
            "content": "写一个python代码，快速排序，命名为quick_sort.py"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "将内容写入指定文件，若文件不存在则创建。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {
                            "type": "string",
                            "description": "目标文件的相对或绝对路径"
                        },
                        "content": {
                            "type": "string",
                            "description": "写入文件的字符串内容"
                        }
                    },
                    "required": ["path", "content"]
                }
            }
        }
    ]
}'

返回结果

{
    "choices": [
        {
            "message": {
                "content": "",
                "role": "assistant",
                "tool_calls": [
                    {
                        "index": 0,
                        "id": "call_0ca7505bb6e44471a40511e5",
                        "type": "function",
                        "function": {
                            "name": "write_file",
                            "arguments": "{\"content\": \"def quick_sort(arr):\\\\n    if len(arr) <= 1:\\\\n        return arr\\\\n    pivot = arr[len(arr) // 2]\\\\n    left = [x for x in arr if x < pivot]\\\\n    middle = [x for x in arr if x == pivot]\\\\n    right = [x for x in arr if x > pivot]\\\\n    return quick_sort(left) + middle + quick_sort(right)\\\\n\\\\nif __name__ == \\\\\\\"__main__\\\\\\\":\\\\n    example_list = [3, 6, 8, 10, 1, 2, 1]\\\\n    print(\\\\\\\"Original list:\\\\\\\", example_list)\\\\n    sorted_list = quick_sort(example_list)\\\\n    print(\\\\\\\"Sorted list:\\\\\\\", sorted_list)\", \"path\": \"quick_sort.py\"}"
                        }
                    }
                ]
            },
            "finish_reason": "tool_calls",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 494,
        "completion_tokens": 193,
        "total_tokens": 687,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "created": 1761620025,
    "system_fingerprint": null,
    "model": "qwen3-coder-plus",
    "id": "chatcmpl-20e96159-beea-451f-b3a4-d13b218112b5"
}

请求示例

import os
import json
import dashscope

# 若使用新加坡地域的模型，请取消下行注释
# dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"

tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "将内容写入指定文件，若文件不存在则创建。",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "目标文件的相对或绝对路径"
                    },
                    "content": {
                        "type": "string",
                        "description": "写入文件的字符串内容"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]

# 工具函数实现
def write_file(path: str, content: str) -> str:
    """写入文件内容"""
    try:
        # 为安全起见，文件写入功能已默认禁用，如需使用请取消注释并确保路径安全
        # os.makedirs(os.path.dirname(path),exist_ok=True) if os.path.dirname(path) else None
        # with open(path, 'w', encoding='utf-8') as f:
        #     f.write(content)
        return f"成功: 文件 '{path}' 已写入"
    except Exception as e:
        return f"错误: 写入文件时发生异常 - {str(e)}"


messages = [{"role": "user", "content": "写一个python代码，快速排序，命名为quick_sort.py"}]

response = dashscope.Generation.call(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model='qwen3-coder-plus',
    messages=messages,
    tools=tools,
    result_format='message'
)

if response.status_code == 200:
    assistant_output = response.output.choices[0].message
    messages.append(assistant_output)

    # 如果不需要调用工具，直接输出内容
    if "tool_calls" not in assistant_output or not assistant_output["tool_calls"]:
        print(f"无需调用工具，直接回复：{assistant_output['content']}")
    else:
        # 进入工具调用循环
        while "tool_calls" in assistant_output and assistant_output["tool_calls"]:
            for tool_call in assistant_output["tool_calls"]:
                func_name = tool_call["function"]["name"]
                arguments = json.loads(tool_call["function"]["arguments"])
                tool_call_id = tool_call.get("id")
                print(f"正在调用工具 [{func_name}]，参数：{arguments}")
                # 执行工具
                tool_result = write_file(**arguments)
                # 构造工具返回信息
                tool_message = {
                    "role": "tool",
                    "content": tool_result,
                    "tool_call_id": tool_call_id
                }
                print(f"工具返回：{tool_message['content']}")
                messages.append(tool_message)
            # 再次调用模型，获取总结后的自然语言回复
            response = dashscope.Generation.call(
                api_key=os.getenv('DASHSCOPE_API_KEY'),
                model='qwen3-coder-plus',
                messages=messages,
                tools=tools,
                result_format='message'
            )
            if response.status_code == 200:
                print(f"模型最终回复：{response.output.choices[0].message.content}")
                assistant_output = response.output.choices[0].message
                messages.append(assistant_output)
            else:
                print(f"总结回复时执行错误：{response}")
                break
else:
    print(f"执行错误：{response}")

返回结果

正在调用工具 [write_file]，参数：{'content': 'def quick_sort(arr):\\n    if len(arr) <= 1:\\n        return arr\\n    pivot = arr[len(arr) // 2]\\n    left = [x for x in arr if x < pivot]\\n    middle = [x for x in arr if x == pivot]\\n    right = [x for x in arr if x > pivot]\\n    return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\"__main__\\":\\n    example_list = [3, 6, 8, 10, 1, 2, 1]\\n    print(\\"Original list:\\", example_list)\\n    sorted_list = quick_sort(example_list)\\n    print(\\"Sorted list:\\", sorted_list)', 'path': 'quick_sort.py'}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：已成功创建 `quick_sort.py` 文件，其中包含快速排序的 Python 实现。你可以运行该文件以查看示例列表的排序结果。如果需要进一步修改或解释，请告诉我！

请求示例

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.protocol.Protocol;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.tools.FunctionDefinition;
import com.alibaba.dashscope.tools.ToolCallBase;
import com.alibaba.dashscope.tools.ToolCallFunction;
import com.alibaba.dashscope.tools.ToolFunction;
import com.alibaba.dashscope.utils.JsonUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

    /**
     * 写入文件内容
     * @param arguments 模型传入的、包含工具所需参数的JSON字符串。
     * @return 工具执行后的结果字符串。
     */
    public static String writeFile(String arguments) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode argsNode = objectMapper.readTree(arguments);
            String path = argsNode.get("path").asText();
            String content = argsNode.get("content").asText();
            // 为安全起见，文件写入功能已默认禁用，如需使用请取消注释并确保路径安全
            // File file = new File(path);
            // File parentDir = file.getParentFile();
            // if (parentDir != null && !parentDir.exists()) {
            //     parentDir.mkdirs();
            // }
            // Files.write(Paths.get(path), content.getBytes(StandardCharsets.UTF_8));
            return "成功: 文件 '" + path + "' 已写入";
        } catch (Exception e) {
            return "错误: 写入文件时发生异常 - " + e.getMessage();
        }
    }

    public static void main(String[] args) {
        try {
            // 定义工具参数模式
            String writePropertyParams =
                    "{\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\",\"description\":\"目标文件的相对或绝对路径\"},\"content\":{\"type\":\"string\",\"description\":\"写入文件的字符串内容\"}},\"required\":[\"path\",\"content\"]}";

            FunctionDefinition writeFileFunction = FunctionDefinition.builder()
                    .name("write_file")
                    .description("将内容写入指定文件，若文件不存在则创建。")
                    .parameters(JsonUtils.parseString(writePropertyParams).getAsJsonObject())
                    .build();

            // 以下为北京地域base_url，若使用新加坡地域的模型，需将base_url替换为：https://dashscope-intl.aliyuncs.com/api/v1
            Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope.aliyuncs.com/api/v1");

            String userInput = "写一个python代码，快速排序，命名为quick_sort.py";
            List<Message> messages = new ArrayList<>();
            messages.add(Message.builder().role(Role.USER.getValue()).content(userInput).build());

            // 首次调用模型
            GenerationParam param = GenerationParam.builder()
                    .model("qwen3-coder-plus")
                    .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                    .messages(messages)
                    .tools(Arrays.asList(ToolFunction.builder().function(writeFileFunction).build()))
                    .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                    .build();

            GenerationResult result = gen.call(param);
            Message assistantOutput = result.getOutput().getChoices().get(0).getMessage();
            messages.add(assistantOutput);

            // 如果不需要调用工具，直接输出内容
            if (assistantOutput.getToolCalls() == null || assistantOutput.getToolCalls().isEmpty()) {
                System.out.println("无需调用工具，直接回复：" + assistantOutput.getContent());
            } else {
                // 进入工具调用循环
                while (assistantOutput.getToolCalls() != null && !assistantOutput.getToolCalls().isEmpty()) {
                    for (ToolCallBase toolCall : assistantOutput.getToolCalls()) {
                        ToolCallFunction functionCall = (ToolCallFunction) toolCall;
                        String funcName = functionCall.getFunction().getName();
                        String arguments = functionCall.getFunction().getArguments();
                        System.out.println("正在调用工具 [" + funcName + "]，参数：" + arguments);

                        // 执行工具
                        String toolResult = writeFile(arguments);

                        // 构造工具返回信息
                        Message toolMessage = Message.builder()
                                .role("tool")
                                .toolCallId(toolCall.getId())
                                .content(toolResult)
                                .build();
                        System.out.println("工具返回：" + toolMessage.getContent());
                        messages.add(toolMessage);
                    }

                    // 再次调用模型，获取总结后的自然语言回复
                    param.setMessages(messages);
                    result = gen.call(param);
                    assistantOutput = result.getOutput().getChoices().get(0).getMessage();
                    messages.add(assistantOutput);
                }
                System.out.println("模型最终回复：" + assistantOutput.getContent());
            }

        } catch (NoApiKeyException | InputRequiredException e) {
            System.err.println("错误: " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

返回结果

正在调用工具 [write_file]，参数：{"content": "def quick_sort(arr):\\n    if len(arr) <= 1:\\n        return arr\\n    pivot = arr[len(arr) // 2]\\n    left = [x for x in arr if x < pivot]\\n    middle = [x for x in arr if x == pivot]\\n    right = [x for x in arr if x > pivot]\\n    return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\\"__main__\\\":\\n    example_array = [3, 6, 8, 10, 1, 2, 1]\\n    print(\\\"Original array:\\\", example_array)\\n    sorted_array = quick_sort(example_array)\\n    print(\\\"Sorted array:\\\", sorted_array)", "path": "quick_sort.py"}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：已成功为您创建了快速排序的Python代码文件 `quick_sort.py`。该文件包含一个 `quick_sort` 函数和一个示例用法，您可以在终端或编辑器中运行它来测试快速排序功能。

请求示例

该示例展示了工具调用流程的第一步：发起请求并获得模型的工具调用意图。

curl --location "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
    "model": "qwen3-coder-plus",
    "input": {
        "messages": [{
            "role": "user",
            "content": "写一个python代码，快速排序，命名为quick_sort.py"
        }]
    },
    "parameters": {
        "result_format": "message",
        "tools": [
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "将内容写入指定文件，若文件不存在则创建。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {
                            "type": "string",
                            "description": "目标文件的相对或绝对路径"
                        },
                        "content": {
                            "type": "string",
                            "description": "写入文件的字符串内容"
                        }
                    },
                    "required": ["path", "content"]
                }
            }
        }
    ]
    }
}'

返回结果

{
    "output": {
        "choices": [
            {
                "finish_reason": "tool_calls",
                "message": {
                    "role": "assistant",
                    "tool_calls": [
                        {
                            "function": {
                                "name": "write_file",
                                "arguments": "{\"content\": \"def quick_sort(arr):\\\\n    if len(arr) <= 1:\\\\n        return arr\\\\n    pivot = arr[len(arr) // 2]\\\\n    left = [x for x in arr if x < pivot]\\\\n    middle = [x for x in arr if x == pivot]\\\\n    right = [x for x in arr if x > pivot]\\\\n    return quick_sort(left) + middle + quick_sort(right)\\\\n\\\\nif __name__ == \\\\\\\"__main__\\\\\\\":\\\\n    example_list = [3, 6, 8, 10, 1, 2, 1]\\\\n    print(\\\\\\\"Original list:\\\\\\\", example_list)\\\\n    sorted_list = quick_sort(example_list)\\\\n    print(\\\\\\\"Sorted list:\\\\\\\", sorted_list), \"path\": \"quick_sort.py\"}"
                            },
                            "index": 0,
                            "id": "call_645b149bbd274e8bb3789aae",
                            "type": "function"
                        }
                    ],
                    "content": ""
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 684,
        "output_tokens": 193,
        "input_tokens": 491,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "request_id": "d2386acd-fce3-9d0f-8015-c5f3a8bf9f5c"
}