创建响应

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

response = client.responses.create(
    model="qwen3.8-max",
    input="你能做些什么？"
)

# 获取模型回复
print(response.output_text)

import OpenAI from "openai";

const openai = new OpenAI({
    // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx"
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
});

async function main() {
    const response = await openai.responses.create({
        model: "qwen3.8-max",
        input: "你能做些什么？"
    });

    // 获取模型回复
    console.log(response.output_text);
}

main();

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3.8-max",
    "input": "你能做些什么？"
}'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

stream = client.responses.create(
    model="qwen3.8-max",
    input="请简单介绍一下人工智能。",
    stream=True
)

print("开始接收流式输出:")
for event in stream:
    if event.type == 'response.output_text.delta':
        print(event.delta, end='', flush=True)
    elif event.type == 'response.completed':
        print("\n流式输出完成")
        print(f"总Token数: {event.response.usage.total_tokens}")

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
});

async function main() {
    const stream = await openai.responses.create({
        model: "qwen3.8-max",
        input: "请简单介绍一下人工智能。",
        stream: true
    });

    console.log("开始接收流式输出:");
    for await (const event of stream) {
        if (event.type === 'response.output_text.delta') {
            process.stdout.write(event.delta);
        } else if (event.type === 'response.completed') {
            console.log("\n流式输出完成");
            console.log(`总Token数: ${event.response.usage.total_tokens}`);
        }
    }
}

main();

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
--no-buffer \
-d '{
    "model": "qwen3.8-max",
    "input": "请简单介绍一下人工智能。",
    "stream": true
}'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

# 第一轮对话
response1 = client.responses.create(
    model="qwen3.8-max",
    input="我的名字是张三，请记住。"
)
print(f"第一轮回复: {response1.output_text}")

# 第二轮对话 - 使用 previous_response_id 关联上下文，响应id有效期为7天
response2 = client.responses.create(
    model="qwen3.8-max",
    input="你还记得我的名字吗？",
    previous_response_id=response1.id
)
print(f"第二轮回复: {response2.output_text}")

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
});

async function main() {
    // 第一轮对话
    const response1 = await openai.responses.create({
        model: "qwen3.8-max",
        input: "我的名字是张三，请记住。"
    });
    console.log(`第一轮回复: ${response1.output_text}`);

    // 第二轮对话 - 使用 previous_response_id 关联上下文，响应id有效期为7天
    const response2 = await openai.responses.create({
        model: "qwen3.8-max",
        input: "你还记得我的名字吗？",
        previous_response_id: response1.id
    });
    console.log(`第二轮回复: ${response2.output_text}`);
}

main();

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

response = client.responses.create(
    model="qwen3.8-max",
    input="帮我找一下阿里云官网，并提取首页的关键信息",
    # 建议同时开启内置工具以取得最佳效果
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter"},
        {"type": "web_extractor"}
    ],
)

# 取消以下注释查看中间过程输出
# print(response.output)
print(response.output_text)

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
});

async function main() {
    const response = await openai.responses.create({
        model: "qwen3.8-max",
        input: "帮我找一下阿里云官网，并提取首页的关键信息",
        tools: [
            { type: "web_search" },
            { type: "code_interpreter" },
            { type: "web_extractor" }
        ]
    });

    for (const item of response.output) {
        if (item.type === "reasoning") {
            console.log("模型正在思考...");
        } else if (item.type === "web_search_call") {
            console.log(`搜索查询: ${item.action.query}`);
        } else if (item.type === "web_extractor_call") {
            console.log("正在抽取网页内容...");
        } else if (item.type === "message") {
            console.log(`回复内容: ${item.content[0].text}`);
        }
    }
}

main();

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3.8-max",
    "input": "帮我找一下阿里云官网，并提取首页的关键信息",
    "tools": [
        {
            "type": "web_search"
        },
        {
            "type": "code_interpreter"
        },
        {
            "type": "web_extractor"
        }
    ]
}'

from openai import OpenAI
import json
import os
import random

# 初始化客户端
client = OpenAI(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)
# 模拟用户问题
USER_QUESTION = "北京天气咋样"
# 定义工具列表
tools = [
    {
        "type": "function",
        "name": "get_current_weather",
        "description": "当你想查询指定城市的天气时非常有用。",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "城市或县区，比如北京市、杭州市、余杭区等。",
                }
            },
            "required": ["location"],
        },
    }
]

# 模拟天气查询工具
def get_current_weather(arguments):
    weather_conditions = ["晴天", "多云", "雨天"]
    random_weather = random.choice(weather_conditions)
    location = arguments["location"]
    return f"{location}今天是{random_weather}。"

# 封装模型响应函数
def get_response(input_data):
    response = client.responses.create(
        model="qwen3.8-max",
        input=input_data,
        tools=tools,
    )
    return response

# 维护对话上下文
conversation = [{"role": "user", "content": USER_QUESTION}]

response = get_response(conversation)
function_calls = [item for item in response.output if item.type == "function_call"]
# 如果不需要调用工具，直接输出内容
if not function_calls:
    print(f"助手最终回复：{response.output_text}")
else:
    # 进入工具调用循环
    while function_calls:
        for fc in function_calls:
            func_name = fc.name
            arguments = json.loads(fc.arguments)
            print(f"正在调用工具 [{func_name}]，参数：{arguments}")
            # 执行工具
            tool_result = get_current_weather(arguments)
            print(f"工具返回：{tool_result}")
            # 将工具调用和结果成对追加到上下文中
            conversation.append(
                {
                    "type": "function_call",
                    "name": fc.name,
                    "arguments": fc.arguments,
                    "call_id": fc.call_id,
                }
            )
            conversation.append(
                {
                    "type": "function_call_output",
                    "call_id": fc.call_id,
                    "output": tool_result,
                }
            )
        # 携带完整上下文再次调用模型
        response = get_response(conversation)
        function_calls = [
            item for item in response.output if item.type == "function_call"
        ]
    print(f"助手最终回复：{response.output_text}")

import OpenAI from "openai";

// 初始化客户端
const openai = new OpenAI({
  // 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：apiKey: "sk-xxx",
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL:
    "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
});

// 定义工具列表
const tools = [
  {
    type: "function",
    name: "get_current_weather",
    description: "当你想查询指定城市的天气时非常有用。",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "城市或县区，比如北京市、杭州市、余杭区等。",
        },
      },
      required: ["location"],
    },
  },
];

// 模拟天气查询工具
const getCurrentWeather = (args) => {
  const weatherConditions = ["晴天", "多云", "雨天"];
  const randomWeather =
    weatherConditions[Math.floor(Math.random() * weatherConditions.length)];
  const location = args.location;
  return `${location}今天是${randomWeather}。`;
};

// 封装模型响应函数
const getResponse = async (inputData) => {
  const response = await openai.responses.create({
    model: "qwen3.8-max",
    input: inputData,
    tools: tools,
  });
  return response;
};

const main = async () => {
  const userQuestion = "北京天气";

  // 维护对话上下文
  const conversation = [{ role: "user", content: userQuestion }];

  let response = await getResponse(conversation);
  let functionCalls = response.output.filter(
    (item) => item.type === "function_call"
  );
  // 如果不需要调用工具，直接输出内容
  if (functionCalls.length === 0) {
    console.log(`助手最终回复：${response.output_text}`);
  } else {
    // 进入工具调用循环
    while (functionCalls.length > 0) {
      for (const fc of functionCalls) {
        const funcName = fc.name;
        const args = JSON.parse(fc.arguments);
        console.log(`正在调用工具 [${funcName}]，参数：`, args);
        // 执行工具
        const toolResult = getCurrentWeather(args);
        console.log(`工具返回：${toolResult}`);
        // 将工具调用和结果成对追加到上下文中
        conversation.push({
          type: "function_call",
          name: fc.name,
          arguments: fc.arguments,
          call_id: fc.call_id,
        });
        conversation.push({
          type: "function_call_output",
          call_id: fc.call_id,
          output: toolResult,
        });
      }
      // 携带完整上下文再次调用模型
      response = await getResponse(conversation);
      functionCalls = response.output.filter(
        (item) => item.type === "function_call"
      );
    }
    console.log(`助手最终回复：${response.output_text}`);
  }
};

// 启动程序
main().catch(console.error);

# 第一步：提交用户问题与工具定义，模型返回 function_call
curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3.8-max",
    "input": [
        {
            "role": "user",
            "content": "北京天气咋样"
        }
    ],
    "tools": [
        {
            "type": "function",
            "name": "get_current_weather",
            "description": "当你想查询指定城市的天气时非常有用。",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市或县区，比如北京市、杭州市、余杭区等。"
                    }
                },
                "required": ["location"]
            }
        }
    ]
}'

# 第二步：在本地执行函数后，将 function_call 与 function_call_output 成对追加到 input 中，获取最终回复
# 请将 call_id 与 arguments 替换为第一步响应中实际返回的值
curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3.8-max",
    "input": [
        {
            "role": "user",
            "content": "北京天气咋样"
        },
        {
            "type": "function_call",
            "name": "get_current_weather",
            "arguments": "{\"location\": \"北京市\"}",
            "call_id": "call_xxx"
        },
        {
            "type": "function_call_output",
            "call_id": "call_xxx",
            "output": "北京市今天是晴天。"
        }
    ],
    "tools": [
        {
            "type": "function",
            "name": "get_current_weather",
            "description": "当你想查询指定城市的天气时非常有用。",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市或县区，比如北京市、杭州市、余杭区等。"
                    }
                },
                "required": ["location"]
            }
        }
    ]
}'

from openai import OpenAI
import json
import os

# 初始化客户端
client = OpenAI(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)
# 模拟用户问题
USER_QUESTION = "画一张小狗的照片，然后告诉我图里的小狗是什么品种、在什么场景里"
# 定义工具列表
tools = [
    {
        "type": "function",
        "name": "generate_image",
        "description": "当你需要根据文字描述生成图片时非常有用。",
        "parameters": {
            "type": "object",
            "properties": {
                "prompt": {
                    "type": "string",
                    "description": "图片内容的文字描述。",
                }
            },
            "required": ["prompt"],
        },
    }
]

# 模拟文生图工具，实际使用时请替换为真实的图片生成调用
def generate_image(arguments):
    print(f"正在生成图片，提示词：{arguments['prompt']}")
    return "https://dashscope.oss-cn-beijing.aliyuncs.com/images/dog_and_girl.jpeg"

# 封装模型响应函数
def get_response(input_data):
    response = client.responses.create(
        model="qwen3.8-max",
        input=input_data,
        tools=tools,
    )
    return response

# 维护对话上下文
conversation = [{"role": "user", "content": USER_QUESTION}]

response = get_response(conversation)
function_calls = [item for item in response.output if item.type == "function_call"]
# 进入工具调用循环
while function_calls:
    for fc in function_calls:
        arguments = json.loads(fc.arguments)
        # 执行工具，得到图片地址
        image_url = generate_image(arguments)
        # 将工具调用和结果成对追加到上下文中
        conversation.append(
            {
                "type": "function_call",
                "name": fc.name,
                "arguments": fc.arguments,
                "call_id": fc.call_id,
            }
        )
        # output 传入内容数组，模型才能理解图片内容
        conversation.append(
            {
                "type": "function_call_output",
                "call_id": fc.call_id,
                "output": [
                    {"type": "input_text", "text": "图片生成成功。"},
                    {"type": "input_image", "image_url": image_url},
                ],
            }
        )
    # 携带完整上下文再次调用模型
    response = get_response(conversation)
    function_calls = [item for item in response.output if item.type == "function_call"]
print(f"助手最终回复：{response.output_text}")

import OpenAI from "openai";

// 初始化客户端
const openai = new OpenAI({
  // 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：apiKey: "sk-xxx",
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL:
    "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
});

// 定义工具列表
const tools = [
  {
    type: "function",
    name: "generate_image",
    description: "当你需要根据文字描述生成图片时非常有用。",
    parameters: {
      type: "object",
      properties: {
        prompt: {
          type: "string",
          description: "图片内容的文字描述。",
        },
      },
      required: ["prompt"],
    },
  },
];

// 模拟文生图工具，实际使用时请替换为真实的图片生成调用
const generateImage = (args) => {
  console.log(`正在生成图片，提示词：${args.prompt}`);
  return "https://dashscope.oss-cn-beijing.aliyuncs.com/images/dog_and_girl.jpeg";
};

// 封装模型响应函数
const getResponse = async (inputData) => {
  const response = await openai.responses.create({
    model: "qwen3.8-max",
    input: inputData,
    tools: tools,
  });
  return response;
};

const main = async () => {
  const userQuestion = "画一张小狗的照片，然后告诉我图里的小狗是什么品种、在什么场景里";

  // 维护对话上下文
  const conversation = [{ role: "user", content: userQuestion }];

  let response = await getResponse(conversation);
  let functionCalls = response.output.filter(
    (item) => item.type === "function_call"
  );
  // 进入工具调用循环
  while (functionCalls.length > 0) {
    for (const fc of functionCalls) {
      const args = JSON.parse(fc.arguments);
      // 执行工具，得到图片地址
      const imageUrl = generateImage(args);
      // 将工具调用和结果成对追加到上下文中
      conversation.push({
        type: "function_call",
        name: fc.name,
        arguments: fc.arguments,
        call_id: fc.call_id,
      });
      // output 传入内容数组，模型才能理解图片内容
      conversation.push({
        type: "function_call_output",
        call_id: fc.call_id,
        output: [
          { type: "input_text", text: "图片生成成功。" },
          { type: "input_image", image_url: imageUrl },
        ],
      });
    }
    // 携带完整上下文再次调用模型
    response = await getResponse(conversation);
    functionCalls = response.output.filter(
      (item) => item.type === "function_call"
    );
  }
  console.log(`助手最终回复：${response.output_text}`);
};

// 启动程序
main().catch(console.error);

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

response = client.responses.create(
    model="qwen3.5-ocr",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260616/qmycjl/1506.02640v5.pdf",
                },
                {
                    "type": "input_text",
                    "text": "Read all the text in the file.",
                },
            ],
        }
    ],
    extra_body={
        "ocr_options": {"task": "document_parsing"}
    },
)

print(response.output_text)

import OpenAI from 'openai';

const client = new OpenAI({
    // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx"
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
});

async function main() {
    const response = await client.responses.create({
        model: "qwen3.5-ocr",
        input: [{
            role: "user",
            content: [{
                type: "input_file",
                file_url: "https://example.com/your-document.pdf"
            }]
        }],
        ocr_options: { task: "document_parsing" }
    });

    // 获取定制任务结果
    console.log(response.output[0].content[0].ocr_result);
}

main();

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3.5-ocr",
    "input": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260616/qmycjl/1506.02640v5.pdf"
                },
                {
                    "type": "input_text",
                    "text": "Read all the text in the file."
                }
            ]
        }
    ],
    "ocr_options": {"task": "document_parsing"}
}'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
    # 通过 default_headers 开启 Session 缓存
    default_headers={"x-dashscope-session-cache": "enable"}
)

# 构造超过 1024 Token 的长文本，确保能触发缓存创建（若未达到1024 Token，后续累积对话上下文超过1024 Token时将触发缓存创建）
long_context = "人工智能是计算机科学的一个重要分支，致力于研究和开发能够模拟、延伸和扩展人类智能的理论、方法、技术及应用系统。" * 50

# 第一轮对话
response1 = client.responses.create(
    model="qwen3.8-max",
    input=long_context + "\n\n基于以上背景知识，请简短介绍机器学习中的随机森林算法。",
)
print(f"第一轮回复: {response1.output_text}")

# 第二轮对话：通过 previous_response_id 关联上下文，缓存由服务端自动处理
response2 = client.responses.create(
    model="qwen3.8-max",
    input="它和 GBDT 有什么主要区别？",
    extra_body={"previous_response_id": response1.id},
)
print(f"第二轮回复: {response2.output_text}")

# 查看缓存命中情况
usage = response2.usage
print(f"输入 Token: {usage.input_tokens}")
print(f"缓存命中 Token: {usage.input_tokens_details.cached_tokens}")

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
    // 通过 defaultHeaders 开启 Session 缓存
    defaultHeaders: {"x-dashscope-session-cache": "enable"}
});

// 构造超过 1024 Token 的长文本，确保能触发缓存创建（若未达到1024 Token，后续累积对话上下文超过1024 Token时将触发缓存创建）
const longContext = "人工智能是计算机科学的一个重要分支，致力于研究和开发能够模拟、延伸和扩展人类智能的理论、方法、技术及应用系统。".repeat(50);

async function main() {
    // 第一轮对话
    const response1 = await openai.responses.create({
        model: "qwen3.8-max",
        input: longContext + "\n\n基于以上背景知识，请简短介绍机器学习中的随机森林算法，包括基本原理和应用场景。"
    });
    console.log(`第一轮回复: ${response1.output_text}`);

    // 第二轮对话：通过 previous_response_id 关联上下文，缓存由服务端自动处理
    const response2 = await openai.responses.create(
        {
            model: "qwen3.8-max",
            input: "它和 GBDT 有什么主要区别？",
        },
        {
            body: { previous_response_id: response1.id }
        }
    );
    console.log(`第二轮回复: ${response2.output_text}`);

    // 查看缓存命中情况
    console.log(`输入 Token: ${response2.usage.input_tokens}`);
    console.log(`缓存命中 Token: ${response2.usage.input_tokens_details.cached_tokens}`);
}

main();

# 第一轮对话
# 长文本重复 50 次以确保超过 1024 Token，触发缓存创建
curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "x-dashscope-session-cache: enable" \
-d '{
    "model": "qwen3.8-max",
    "input": "人工智能是计算机科学的一个重要分支..."
}'

# 第二轮对话 - 使用上一轮返回的 id 作为 previous_response_id
curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "x-dashscope-session-cache: enable" \
-d '{
    "model": "qwen3.8-max",
    "input": "它和 GBDT 有什么主要区别？",
    "previous_response_id": "第一轮返回的响应id"
}'