Alibaba Cloud Model Studio:Coding capabilities (Qwen-Coder)

Request example

import os
from openai import OpenAI

client = OpenAI(
    # API keys vary by region. To get an API key, see https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    # If you have not configured an environment variable, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    model="qwen3-coder-next", 
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'Write a Python function find_prime_numbers that takes an integer n as an argument and returns a list of all prime numbers less than n. Do not output any non-code content or Markdown code blocks.'}],
)
print(completion.choices[0].message.content)

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

Request example

import OpenAI from "openai";

const client = new OpenAI(
    {
        // API keys vary by region. To get an API key, see https://www.alibabacloud.com/help/zh/model-studio/get-api-key
        // If you have not configured an environment variable, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // To use a model in the China (Beijing) region, replace the base_url with https://dashscope.aliyuncs.com/compatible-mode/v1
        baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
    }
);

async function main() {
    const completion = await client.chat.completions.create({
        model: "qwen3-coder-next",
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "Write a Python function find_prime_numbers that takes an integer n as an argument and returns a list of all prime numbers less than n. Do not output any non-code content or Markdown code blocks." }
        ],
    });
    console.log(completion.choices[0].message.content);
}

main();

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

Request example

curl -X POST https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3-coder-next",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user", 
            "content": "Write a Python function find_prime_numbers that takes an integer n as an argument and returns a list of all prime numbers less than n. Do not output any non-code content or Markdown code blocks."
        }
    ]
}'

Response

{
    "model": "qwen3-coder-next",
    "id": "chatcmpl-3123d5cb-01b8-9a90-98cc-5bffbb369xxx",
    "choices": [
        {
            "message": {
                "content": "def find_prime_numbers(n):\n    if n <= 2:\n        return []\n    \n    primes = []\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"
            },
            "index": 0,
            "finish_reason": "stop"
        }
    ],
    "created": 1770108104,
    "object": "chat.completion",
    "usage": {
        "total_tokens": 155,
        "completion_tokens": 89,
        "prompt_tokens": 66
    }
}

Request example

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": "Write a Python function find_prime_numbers that takes an integer n as an argument and returns a list of all prime numbers less than n. Do not output any non-code content or Markdown code blocks."
    }
]

response = dashscope.Generation.call(
    # API keys vary by region. To get an API key, see https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    # If you have not configured an environment variable, replace the following line with your Alibaba Cloud Model Studio API key: api_key = "sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen3-coder-next",
    messages=messages,
    result_format="message"
)

if response.status_code == 200:
    print(response.output.choices[0].message.content)
else:
    print(f"HTTP status code: {response.status_code}")
    print(f"Error code: {response.code}")
    print(f"Error message: {response.message}")

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

Request example

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");
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope-intl.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("Write a Python function find_prime_numbers that takes an integer n as an argument and returns a list of all prime numbers less than n. Do not output any non-code content or Markdown code blocks.").build();
        GenerationParam param = GenerationParam.builder()
                .apiKey(apiKey)
                .model("qwen3-coder-next")
                .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("Request failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

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

Request example

curl -X POST "https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3-coder-next",
    "input":{
        "messages":[      
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "Write a Python function find_prime_numbers that takes an integer n as an argument and returns a list of all prime numbers less than n. Do not output any non-code content or Markdown code blocks."
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

Response

{
    "output": {
        "choices": [
            {
                "message": {
                    "content": "def find_prime_numbers(n):\n    if n <= 2:\n        return []\n    \n    primes = []\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": 155,
        "input_tokens": 66,
        "output_tokens": 89
    },
    "request_id": "dd78b1cf-8029-46bb-9bea-b794ded7bxxx"
}

import os
import json
from openai import OpenAI

client = OpenAI(
    # API keys vary by region. To get an API key, see https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    # If you have not configured an environment variable, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Writes content to a specified file. Creates the file if it does not exist.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "The relative or absolute path of the object file"
                    },
                    "content": {
                        "type": "string",
                        "description": "The string content to write to the file"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]

# Tool function implementation
def write_file(path: str, content: str) -> str:
    """Write file content"""
    try:
        # Make sure the directory exists.
        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"Success: File '{path}' has been written."
    except Exception as e:
        return f"Error: An exception occurred while writing the file - {str(e)}"


messages = [{"role": "user", "content": "Write a Python script for quick sort and name it quick_sort.py."}]

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

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

# If no tool call is required, directly output the content.
if assistant_output.tool_calls is None:
    print(f"No tool call is required. Direct response: {assistant_output.content}")
else:
    # Enter the tool calling loop.
    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"Calling tool [{func_name}] with arguments: {arguments}")
            # Execute the tool.
            tool_result = write_file(**arguments)
            # Construct the tool return message.
            tool_message = {
                "role": "tool",
                "tool_call_id": tool_call_id,
                "content": tool_result,
            }
            print(f"Tool returns: {tool_message['content']}")
            messages.append(tool_message)
        # Call the model again to get a summarized natural language response.
        response = client.chat.completions.create(
            model="qwen3-coder-next",
            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"Final model response: {assistant_output.content}")

Response

Calling tool [write_file] with 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'}
Tool returns: Success: File 'quick_sort.py' has been written.
Final model response: OK. I have created a file named `quick_sort.py` for you, which contains the Python implementation of quick sort. You can run this file to see the sample output. Let me know if you need any further modifications or explanations!

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

const client = new OpenAI({
    // API keys vary by region. To get an API key, see https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // If you have not configured an environment variable, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
});

const tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Writes content to a specified file. Creates the file if it does not exist.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "The relative or absolute path of the object file"
                    },
                    "content": {
                        "type": "string",
                        "description": "The string content to write to the file"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
];

// Tool function implementation
async function write_file(filePath, content) {
    try {
        // For security reasons, the file writing feature is disabled by default. To use it, uncomment the code and ensure that the path is secure.
        // const dir = path.dirname(filePath);
        // if (dir) {
        //     await fs.mkdir(dir, { recursive: true });
        // }
        // await fs.writeFile(filePath, content, "utf-8");
        return `Success: File '${filePath}' has been written.`;
    } catch (error) {
        return `Error: An exception occurred while writing the file - ${error.message}`;
    }
}

const messages = [{"role": "user", "content": "Write a Python script for quick sort and name it quick_sort.py."}];

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

    let assistant_output = completion.choices[0].message;
    // Make sure content is not null.
    if (!assistant_output.content) assistant_output.content = "";
    messages.push(assistant_output);

    // If no tool call is required, directly output the content.
    if (!assistant_output.tool_calls) {
        console.log(`No tool call is required. Direct response: ${assistant_output.content}`);
    } else {
        // Enter the tool calling loop.
        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(`Calling tool [${func_name}] with arguments:`, args);
                // Execute the tool.
                const tool_result = await write_file(args.path, args.content);
                // Construct the tool return message.
                const tool_message = {
                    "role": "tool",
                    "tool_call_id": tool_call_id,
                    "content": tool_result
                };
                console.log(`Tool returns: ${tool_message.content}`);
                messages.push(tool_message);
            }
            // Call the model again to get a summarized natural language response.
            const response = await client.chat.completions.create({
                model: "qwen3-coder-next",
                messages: messages,
                tools: tools
            });
            assistant_output = response.choices[0].message;
            if (!assistant_output.content) assistant_output.content = "";
            messages.push(assistant_output);
        }
        console.log(`Final model response: ${assistant_output.content}`);
    }
}

main();

Response

Calling tool [write_file] with 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'
}
Tool returns: Success: File 'quick_sort.py' has been written.
Final model response: The `quick_sort.py` file has been successfully created with the Python implementation of quick sort. You can run the file to see the sorting result for the example list. Let me know if you need any further modifications or explanations!

This example shows the first step of the tool calling process: making a request and getting the model's intent to call a tool.

curl -X POST https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3-coder-next",
    "messages": [
        {
            "role": "user", 
            "content": "Write a Python script for quick sort and name it quick_sort.py."
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "Writes content to a specified file. Creates the file if it does not exist.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {
                            "type": "string",
                            "description": "The relative or absolute path of the object file"
                        },
                        "content": {
                            "type": "string",
                            "description": "The string content to write to the file"
                        }
                    },
                    "required": ["path", "content"]
                }
            }
        }
    ]
}'

Response

{
    "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-next",
    "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": "Writes content to a specified file. Creates the file if it does not exist.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "The relative or absolute path of the object file"
                    },
                    "content": {
                        "type": "string",
                        "description": "The string content to write to the file"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]

# Tool function implementation
def write_file(path: str, content: str) -> str:
    """Write file content"""
    try:
        # For security reasons, the file writing feature is disabled by default. To use it, uncomment the code and ensure that the path is secure.
        # 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"Success: File '{path}' has been written."
    except Exception as e:
        return f"Error: An exception occurred while writing the file - {str(e)}"


messages = [{"role": "user", "content": "Write a Python script for quick sort and name it quick_sort.py."}]

response = dashscope.Generation.call(
    # If you have not configured an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model='qwen3-coder-next',
    messages=messages,
    tools=tools,
    result_format='message'
)

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

    # If no tool call is required, directly output the content.
    if "tool_calls" not in assistant_output or not assistant_output["tool_calls"]:
        print(f"No tool call is required. Direct response: {assistant_output['content']}")
    else:
        # Enter the tool calling loop.
        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"Calling tool [{func_name}] with arguments: {arguments}")
                # Execute the tool.
                tool_result = write_file(**arguments)
                # Construct the tool return message.
                tool_message = {
                    "role": "tool",
                    "content": tool_result,
                    "tool_call_id": tool_call_id
                }
                print(f"Tool returns: {tool_message['content']}")
                messages.append(tool_message)
            # Call the model again to get a summarized natural language response.
            response = dashscope.Generation.call(
                api_key=os.getenv('DASHSCOPE_API_KEY'),
                model='qwen3-coder-next',
                messages=messages,
                tools=tools,
                result_format='message'
            )
            if response.status_code == 200:
                print(f"Final model response: {response.output.choices[0].message.content}")
                assistant_output = response.output.choices[0].message
                messages.append(assistant_output)
            else:
                print(f"Error during summary response generation: {response}")
                break
else:
    print(f"Execution error: {response}")

Response

Calling tool [write_file], parameters: {'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'}
Tool returned: Success: File 'quick_sort.py' has been written
Final model response: The `quick_sort.py` file has been successfully created. It contains a Python implementation of quick sort. You can run the file to view the sorting result for the example list. If you need any further modifications or explanations, please let me know!

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 {

    /**
     * Write file content
     * @param arguments A JSON string passed by the model, containing the parameters required by the tool.
     * @return A string result after the tool is executed.
     */
    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();

            // For security reasons, the file writing feature is disabled by default. To use it, uncomment the code and ensure that the path is secure.
            // 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 "Success: File '" + path + "' has been written.";
        } catch (Exception e) {
            return "Error: An exception occurred while writing the file - " + e.getMessage();
        }
    }

    public static void main(String[] args) {
        try {
            // Define the tool parameter schema.
            String writePropertyParams =
                    "{\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\",\"description\":\"The relative or absolute path of the object file\"},\"content\":{\"type\":\"string\",\"description\":\"The string content to write to the file\"}},\"required\":[\"path\",\"content\"]}";

            FunctionDefinition writeFileFunction = FunctionDefinition.builder()
                    .name("write_file")
                    .description("Writes content to a specified file. Creates the file if it does not exist.")
                    .parameters(JsonUtils.parseString(writePropertyParams).getAsJsonObject())
                    .build();

            Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope-intl.aliyuncs.com/api/v1");

            String userInput = "Write a Python script for quick sort and name it quick_sort.py.";
            List<Message> messages = new ArrayList<>();
            messages.add(Message.builder().role(Role.USER.getValue()).content(userInput).build());

            // First call to the model
            GenerationParam param = GenerationParam.builder()
                    .model("qwen3-coder-next")
                    .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 no tool call is required, directly output the content.
            if (assistantOutput.getToolCalls() == null || assistantOutput.getToolCalls().isEmpty()) {
                System.out.println("No tool call is required. Direct response: " + assistantOutput.getContent());
            } else {
                // Enter the tool calling loop.
                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("Calling tool [" + funcName + "] with arguments: " + arguments);

                        // Execute the tool.
                        String toolResult = writeFile(arguments);

                        // Construct the tool return message.
                        Message toolMessage = Message.builder()
                                .role("tool")
                                .toolCallId(toolCall.getId())
                                .content(toolResult)
                                .build();
                        System.out.println("Tool returns: " + toolMessage.getContent());
                        messages.add(toolMessage);
                    }

                    // Call the model again to get a summarized natural language response.
                    param.setMessages(messages);
                    result = gen.call(param);
                    assistantOutput = result.getOutput().getChoices().get(0).getMessage();
                    messages.add(assistantOutput);
                }
                System.out.println("Final model response: " + assistantOutput.getContent());
            }

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

Response

Calling tool [write_file] with 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_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"}
Tool returns: Success: File 'quick_sort.py' has been written.
Final model response: I have successfully created the Python code file `quick_sort.py` for you. This file contains a `quick_sort` function and an example of its usage. You can run it in your terminal or editor to test the quick sort functionality.

This example shows the first step of the tool calling process: making a request and getting the model's intent to call a tool.

curl --location "https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
    "model": "qwen3-coder-next",
    "input": {
        "messages": [{
            "role": "user",
            "content": "Write a Python script for quick sort and name it quick_sort.py."
        }]
    },
    "parameters": {
        "result_format": "message",
        "tools": [
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "Writes content to a specified file. Creates the file if it does not exist.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {
                            "type": "string",
                            "description": "The relative or absolute path of the object file"
                        },
                        "content": {
                            "type": "string",
                            "description": "The string content to write to the file"
                        }
                    },
                    "required": ["path", "content"]
                }
            }
        }
    ]
    }
}'

Response

{
    "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"
}