创建对话补全

生产 HTTP 请求使用 https://api.mosi.cn。运行下方示例前，将 MOSS_API_ORIGIN 设为 https://api.mosi.cn，将 MOSS_API_KEY 设为你的MOSS API Key。OpenAI SDK 的 base_url 填 https://api.mosi.cn/v1。

请求参数

字段类型用法说明

model: string必填

使用 nex-n2.6。需要固定版本时使用 nex-n2.6-2026-11-05。

messages: array<object>必填

对话消息。纯文本请求可传入一条 role 为 user 的消息，继续对话时带上所需历史。

messages[].content: string 或 array按消息类型

文本使用字符串。图文消息使用包含 text 和 image_url 的内容项。视频通过 video_url 传入，支持 MP4、WebM。

max_tokens: integer可选

输出 Token 预算，生产默认 8192，参数上限 131072。与 max_completion_tokens 二选一。

max_completion_tokens: integer可选

max_tokens 的兼容字段。与 max_tokens 二选一。

stream: boolean可选

传 true 开启流式响应。

stream_options.include_usage: boolean可选

流式请求传 true 时读取流末用量。

tools: array<object>可选

仅支持由客户端执行的函数工具。服务端托管工具不适用。

thinking.type: string可选

可传 enabled。当前不支持 disabled。

response_format.type: string可选

设为 json_object 时，请求 JSON 对象形式的回复。

tool_choice: string 或 object可选

auto 由模型选择工具；none 禁用结构化工具调用；也可以传入对象指定函数。

version: string可选

可省略。显式传入时使用 2026-11-05，须与 model 指定的快照一致。

图片地址填入 image_url.url，可使用公网 HTTPS URL 或完整的 Base64 data URL。视频通过 video_url 传入，支持 MP4、WebM。公网媒体地址须能被 MOSS API 访问。媒体编码后的完整请求体不得超过 10 MiB。暂不支持文件、file_id 或资产库引用。

返回值

字段类型说明

model: string

实际使用的模型快照。

choices[].message.content: string

最终文本。输出预算被推理消耗时，文本可能为空。

choices[].message.tool_calls: array<object>

客户端要执行的结构化工具调用。

choices[].finish_reason: string

stop 表示自然结束，length 表示达到输出预算，tool_calls 表示生成了工具调用。

usage: object

读取 prompt_tokens、completion_tokens 和 total_tokens。缓存输入用量见 prompt_tokens_details.cached_tokens，推理用量见 completion_tokens_details.reasoning_tokens。

思考内容与最终回复

从 choices[].message.content 读取最终回复。如果工具调用的 assistant 消息含 reasoning_content，回传结果时应保留该字段。thinking.type 可设为 enabled，设为 disabled 会返回 HTTP 400，错误码为 invalid_field_value。

客户端接入

OpenAI SDK 的 base_url 填 https://api.mosi.cn/v1。流式解析时分别处理文本、结束原因和用量，读取 choices 前先检查数组是否为空。

请求示例

任选一种语言执行。Python 示例使用 requests，TypeScript 示例使用支持 fetch 的 Node.js 环境。

curl -X POST "$MOSS_API_ORIGIN/v1/chat/completions" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": "只回答 17 × 23 的结果。"
    }
  ],
  "max_tokens": 256
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/chat/completions"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user', 'content': '只回答 17 × 23 的结果。'}],
 'max_tokens': 256}

response = requests.post(url, headers=headers, json=payload, timeout=(10, 120))
response.raise_for_status()
print(response.text)

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/chat/completions";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": "只回答 17 × 23 的结果。"
      }
    ],
    "max_tokens": 256
  };

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  console.log(await response.text());
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

响应示例（节选）。自然结束时 finish_reason 为 stop。实际 Token 用量随请求和生成变化。

{
  "object": "chat.completion",
  "model": "nex-n2.6-2026-11-05",
  "usage": {
    "prompt_tokens": 22,
    "total_tokens": 44,
    "completion_tokens": 22,
    "prompt_tokens_details": {
      "cached_tokens": 0
    },
    "reasoning_tokens": 18,
    "completion_tokens_details": {
      "reasoning_tokens": 18
    }
  },
  "choices": [
    {
      "index": 0,
      "finish_reason": "stop",
      "message": {
        "role": "assistant",
        "content": "\n\n391"
      }
    }
  ]
}

图片地址填入 image_url.url，可使用公网 HTTPS URL 或完整的 Base64 data URL。使用 Base64 时，整个请求体不能超过 10 MiB。暂不支持内网 URL 和 file_id。

curl -X POST "$MOSS_API_ORIGIN/v1/chat/completions" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "请简要描述这张图片。"
        },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://httpbin.org/image/png"
          }
        }
      ]
    }
  ],
  "max_tokens": 1024
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/chat/completions"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user',
               'content': [{'type': 'text', 'text': '请简要描述这张图片。'},
                           {'type': 'image_url',
                            'image_url': {'url': 'https://httpbin.org/image/png'}}]}],
 'max_tokens': 1024}

response = requests.post(url, headers=headers, json=payload, timeout=(10, 120))
response.raise_for_status()
print(response.text)

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/chat/completions";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "请简要描述这张图片。"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://httpbin.org/image/png"
            }
          }
        ]
      }
    ],
    "max_tokens": 1024
  };

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  console.log(await response.text());
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

请求体增加 stream: true，curl 加 -N。拼接 choices[0].delta.content，收到 data: [DONE] 时结束。需要流末用量时，传入 stream_options.include_usage: true。先检查 HTTP 状态码。流开始后仍需检查错误事件和正常结束标记，连接提前断开时按未完整返回处理。

curl -N -X POST "$MOSS_API_ORIGIN/v1/chat/completions" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": "只回答 17 × 23 的结果。"
    }
  ],
  "max_tokens": 256,
  "stream": true,
  "stream_options": {
    "include_usage": true
  }
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/chat/completions"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user', 'content': '只回答 17 × 23 的结果。'}],
 'max_tokens': 256,
 'stream': True,
 'stream_options': {'include_usage': True}}

with requests.post(url, headers=headers, json=payload, stream=True, timeout=(10, 120)) as response:
    response.raise_for_status()
    response.encoding = "utf-8"
    for line in response.iter_lines(chunk_size=1, decode_unicode=True):
        print(line, flush=True)

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/chat/completions";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": "只回答 17 × 23 的结果。"
      }
    ],
    "max_tokens": 256,
    "stream": true,
    "stream_options": {
      "include_usage": true
    }
  };

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  if (!response.body) throw new Error("Missing response body");
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  try {
    while (true) {
      const { value, done } = await reader.read();
      if (done) break;
      process.stdout.write(decoder.decode(value, { stream: true }));
    }
    process.stdout.write(decoder.decode());
  } finally {
    reader.releaseLock();
  }
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

流式响应示例（节选）。启用 include_usage 后，在 [DONE] 前读取独立的 usage 块，该块的 choices 为空数组。

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","choices":[{"index":0,"finish_reason":null,"delta":{"content":"39"}}]}

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","choices":[{"index":0,"finish_reason":"stop","delta":{}}]}

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","usage":{"prompt_tokens":22,"total_tokens":44,"completion_tokens":22,"prompt_tokens_details":{"cached_tokens":0},"reasoning_tokens":18,"completion_tokens_details":{"reasoning_tokens":18}},"choices":[]}

data: [DONE]

达到 max_tokens 时，finish_reason 为 length。输出预算包含推理 Token。下面的请求把预算设为 8，全部用于推理，因此最终文本为空。

curl -X POST "$MOSS_API_ORIGIN/v1/chat/completions" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": "请完整输出从 1 到 80 的整数，每个整数一行。"
    }
  ],
  "max_tokens": 8
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/chat/completions"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user', 'content': '请完整输出从 1 到 80 的整数，每个整数一行。'}],
 'max_tokens': 8}

response = requests.post(url, headers=headers, json=payload, timeout=(10, 120))
response.raise_for_status()
print(response.text)

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/chat/completions";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": "请完整输出从 1 到 80 的整数，每个整数一行。"
      }
    ],
    "max_tokens": 8
  };

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  console.log(await response.text());
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

非流式响应（节选）

{
  "object": "chat.completion",
  "model": "nex-n2.6-2026-11-05",
  "usage": {
    "prompt_tokens": 28,
    "total_tokens": 36,
    "completion_tokens": 8,
    "prompt_tokens_details": {
      "cached_tokens": 0
    },
    "reasoning_tokens": 8,
    "completion_tokens_details": {
      "reasoning_tokens": 8
    }
  },
  "choices": [
    {
      "index": 0,
      "finish_reason": "length",
      "message": {
        "role": "assistant",
        "content": ""
      }
    }
  ]
}

开启 stream 和 stream_options.include_usage 后，流式请求同样在结束块中返回 length，之后仍可读取用量。

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","choices":[{"index":0,"finish_reason":"length","delta":{}}]}

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","usage":{"prompt_tokens":28,"total_tokens":36,"completion_tokens":8,"prompt_tokens_details":{"cached_tokens":0},"reasoning_tokens":8,"completion_tokens_details":{"reasoning_tokens":8}},"choices":[]}

data: [DONE]

在 tools 中声明函数。tool_choice 可用 auto 或 none。要指定函数，传入 {"type":"function","function":{"name":"函数名"}}。客户端只应执行结构化 tool_calls。

函数调用请求体示例

curl -X POST "$MOSS_API_ORIGIN/v1/chat/completions" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": "请调用 get_demo_status 查询演示记录 sample-a 的状态，收到工具结果后只输出状态。"
    }
  ],
  "max_tokens": 256,
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_demo_status",
        "description": "读取一个演示记录的固定状态。",
        "parameters": {
          "type": "object",
          "properties": {
            "record_id": {
              "type": "string",
              "enum": [
                "sample-a"
              ]
            }
          },
          "required": [
            "record_id"
          ]
        }
      }
    }
  ],
  "tool_choice": "auto"
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/chat/completions"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user',
               'content': '请调用 get_demo_status 查询演示记录 sample-a 的状态，收到工具结果后只输出状态。'}],
 'max_tokens': 256,
 'tools': [{'type': 'function',
            'function': {'name': 'get_demo_status',
                         'description': '读取一个演示记录的固定状态。',
                         'parameters': {'type': 'object',
                                        'properties': {'record_id': {'type': 'string',
                                                                     'enum': ['sample-a']}},
                                        'required': ['record_id']}}}],
 'tool_choice': 'auto'}

response = requests.post(url, headers=headers, json=payload, timeout=(10, 120))
response.raise_for_status()
print(response.text)

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/chat/completions";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": "请调用 get_demo_status 查询演示记录 sample-a 的状态，收到工具结果后只输出状态。"
      }
    ],
    "max_tokens": 256,
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_demo_status",
          "description": "读取一个演示记录的固定状态。",
          "parameters": {
            "type": "object",
            "properties": {
              "record_id": {
                "type": "string",
                "enum": [
                  "sample-a"
                ]
              }
            },
            "required": [
              "record_id"
            ]
          }
        }
      }
    ],
    "tool_choice": "auto"
  };

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  console.log(await response.text());
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

函数调用响应（节选）。function.arguments 是 JSON 字符串，解析并校验后再执行函数。call_example 代表实际响应中的工具调用 ID。

{
  "object": "chat.completion",
  "model": "nex-n2.6-2026-11-05",
  "usage": {
    "prompt_tokens": 190,
    "total_tokens": 233,
    "completion_tokens": 43,
    "prompt_tokens_details": {
      "cached_tokens": 0
    },
    "reasoning_tokens": 28,
    "completion_tokens_details": {
      "reasoning_tokens": 28
    }
  },
  "choices": [
    {
      "index": 0,
      "finish_reason": "tool_calls",
      "message": {
        "role": "assistant",
        "content": "",
        "tool_calls": [
          {
            "id": "call_example",
            "index": 0,
            "type": "function",
            "function": {
              "name": "get_demo_status",
              "arguments": "{\"record_id\": \"sample-a\"}"
            }
          }
        ]
      }
    }
  ]
}

流式返回时，按 choice.index 和工具调用的 index 归并片段。等待工具参数完整后再解析。下面节选了函数名、前两个参数片段、结束原因及流末用量。

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","usage":null,"choices":[{"index":0,"finish_reason":null,"delta":{"role":null,"content":null,"tool_calls":[{"id":"call_example","index":0,"type":"function","function":{"name":"get_demo_status","arguments":""}}]}}]}

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","usage":null,"choices":[{"index":0,"finish_reason":null,"delta":{"role":null,"content":null,"tool_calls":[{"id":"call_example","index":0,"type":"function","function":{"name":null,"arguments":"{"}}]}}]}

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","usage":null,"choices":[{"index":0,"finish_reason":null,"delta":{"role":null,"content":null,"tool_calls":[{"id":"call_example","index":0,"type":"function","function":{"name":null,"arguments":"\"record_id\": "}}]}}]}

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","choices":[{"index":0,"finish_reason":"tool_calls","delta":{}}]}

data: {"object":"chat.completion.chunk","model":"nex-n2.6-2026-11-05","usage":{"prompt_tokens":190,"total_tokens":258,"completion_tokens":68,"prompt_tokens_details":{"cached_tokens":0},"reasoning_tokens":53,"completion_tokens_details":{"reasoning_tokens":53}},"choices":[]}

data: [DONE]

将上一轮完整请求和非流式响应分别保存为 request.json 与 response.json。HTTP 示例使用 jq 组装回传请求。下列示例回传固定演示结果；实际接入时，先校验并执行工具，再替换结果内容。

完整保留上一轮 assistant 消息，包括响应中提供的 reasoning_content 和 tool_calls。

set -e
assistant="$(jq -c '.choices[0].message' response.json)"
tool_id="$(jq -er 'first(.choices[0].message.tool_calls[0].id) // empty' response.json)"
payload="$(jq --argjson assistant "$assistant" --arg id "$tool_id" \
  '.stream = false | del(.stream_options) | .messages += [$assistant, {role:"tool",tool_call_id:$id,content:({status:"verified"}|tojson)}]' request.json)"
curl -X POST "$MOSS_API_ORIGIN/v1/chat/completions" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  --data-binary "$payload"

import json
from pathlib import Path
import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/chat/completions"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = json.loads(Path("request.json").read_text(encoding="utf-8"))
reply = json.loads(Path("response.json").read_text(encoding="utf-8"))
assistant = reply["choices"][0]["message"]
tool_id = assistant["tool_calls"][0]["id"]
tool_result = {
    "role": "tool",
    "tool_call_id": tool_id,
    "content": json.dumps({"status": "verified"}, separators=(",", ":")),
}
payload["messages"] += [assistant, tool_result]
payload["stream"] = False
payload.pop("stream_options", None)

response = requests.post(url, headers=headers, json=payload, timeout=(10, 120))
response.raise_for_status()
print(response.text)

import { readFile } from "node:fs/promises";

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/chat/completions";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = JSON.parse(await readFile("request.json", "utf8"));
  const reply = JSON.parse(await readFile("response.json", "utf8"));
  const assistant = reply.choices[0].message;
  const tool = assistant.tool_calls?.[0];
  if (!tool?.id) throw new Error("Missing tool call");
  const toolResult = {
    role: "tool",
    tool_call_id: tool.id,
    content: JSON.stringify({ status: "verified" }),
  };
  payload.messages.push(assistant, toolResult);
  payload.stream = false;
  delete payload.stream_options;

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  console.log(await response.text());
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

再次发起请求后，模型根据工具结果生成最终回复。以下为该次回传后的响应节选。

{
  "object": "chat.completion",
  "model": "nex-n2.6-2026-11-05",
  "usage": {
    "prompt_tokens": 241,
    "total_tokens": 283,
    "completion_tokens": 42,
    "prompt_tokens_details": {
      "cached_tokens": 0
    },
    "reasoning_tokens": 39,
    "completion_tokens_details": {
      "reasoning_tokens": 39
    }
  },
  "choices": [
    {
      "index": 0,
      "finish_reason": "stop",
      "message": {
        "role": "assistant",
        "content": "\n\nverified"
      }
    }
  ]
}

创建对话补全（Chat Completions）

请求参数

返回值

思考内容与最终回复

客户端接入

相关文档