创建消息 · MOSS API

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

请求参数

字段类型用法说明

model: string必填

使用 nex-n2.6 或固定快照 nex-n2.6-2026-11-05。

messages: array<object>必填

传入对话消息及所需历史。

messages[].role: string必填

使用 user 或 assistant。工具结果随 user 消息传入。

messages[].content: string 或 array必填

纯文本可用字符串。图片用 type: image 内容块，source 支持 URL 或 Base64。Messages 不支持视频。

max_tokens: integer请传入

输出 Token 预算，生产默认 8192，参数上限 131072。示例显式传入 1024。

stream: boolean可选

传 true 开启流式响应。

tools: array<object>可选

仅支持由客户端执行的函数工具。

version: string可选

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

返回值

字段类型说明

model: string

本次生成使用的快照 ID。

content: array<object>

从 type 为 text 的块读取 text。工具调用块的 type 为 tool_use。

stop_reason: string 或 null

结束原因。tool_use 表示需要由客户端执行工具。

usage: object

本次生成用量。

Anthropic 客户端接入

向 https://api.mosi.cn/v1/messages 发送请求。使用 x-api-key 传入MOSS API Key，并设置 anthropic-version: 2023-06-01。

请求示例

curl -X POST "$MOSS_API_ORIGIN/v1/messages" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $MOSS_API_KEY" \
  -H 'anthropic-version: 2023-06-01' \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": "只回答 17 × 23 的结果。"
    }
  ],
  "max_tokens": 1024
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/messages"
headers = {
    "Content-Type": 'application/json',
    "x-api-key": os.environ["MOSS_API_KEY"],
    "anthropic-version": '2023-06-01',
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user', 'content': '只回答 17 × 23 的结果。'}],
 '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/messages";
  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",
    "x-api-key": apiKey,
    "anthropic-version": "2023-06-01",
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": "只回答 17 × 23 的结果。"
      }
    ],
    "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;
});

响应示例（节选）。普通文本自然结束时 stop_reason 为 end_turn。

{
  "type": "message",
  "role": "assistant",
  "model": "nex-n2.6-2026-11-05",
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 22,
    "output_tokens": 22
  },
  "content": [
    {
      "type": "text",
      "text": "\n\n391"
    }
  ]
}

传入 stream: true 开启流式响应。从 content_block_delta 的 text_delta 读取文本，收到 message_stop 时结束。输入用量见 message_start 的 message.usage，输出用量见 message_delta 的 usage。先检查 HTTP 状态码。流开始后仍需检查错误事件和正常结束标记，连接提前断开时按未完整返回处理。

curl -N -X POST "$MOSS_API_ORIGIN/v1/messages" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $MOSS_API_KEY" \
  -H 'anthropic-version: 2023-06-01' \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": "只回答 17 × 23 的结果。"
    }
  ],
  "max_tokens": 1024,
  "stream": true
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/messages"
headers = {
    "Content-Type": 'application/json',
    "x-api-key": os.environ["MOSS_API_KEY"],
    "anthropic-version": '2023-06-01',
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user', 'content': '只回答 17 × 23 的结果。'}],
 'max_tokens': 1024,
 'stream': 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/messages";
  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",
    "x-api-key": apiKey,
    "anthropic-version": "2023-06-01",
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": "只回答 17 × 23 的结果。"
      }
    ],
    "max_tokens": 1024,
    "stream": 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;
});

流式响应示例（节选）。

data: {"type":"message_start","message":{"type":"message","role":"assistant","model":"nex-n2.6-2026-11-05","usage":{"input_tokens":22,"output_tokens":0}}}

data: {"type":"content_block_delta","index":1,"delta":{"type":"text_delta","text":"39"}}

data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":25}}

data: {"type":"message_stop"}

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

set -e
assistant="$(jq -c '{role:"assistant",content:.content}' response.json)"
tool_id="$(jq -er 'first(.content[] | select(.type == "tool_use") | .id) // empty' response.json)"
payload="$(jq --argjson assistant "$assistant" --arg id "$tool_id" \
  '.stream = false | del(.stream_options) | .messages += [$assistant, {role:"user",content:[{type:"tool_result",tool_use_id:$id,content:"查询完成"}]}]' request.json)"
curl -X POST "$MOSS_API_ORIGIN/v1/messages" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $MOSS_API_KEY" \
  -H 'anthropic-version: 2023-06-01' \
  --data-binary "$payload"

import json
from pathlib import Path
import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/messages"
headers = {
    "Content-Type": 'application/json',
    "x-api-key": os.environ["MOSS_API_KEY"],
    "anthropic-version": '2023-06-01',
}

payload = json.loads(Path("request.json").read_text(encoding="utf-8"))
reply = json.loads(Path("response.json").read_text(encoding="utf-8"))
assistant = {"role": "assistant", "content": reply["content"]}
tool_id = next(block["id"] for block in reply["content"] if block["type"] == "tool_use")
tool_result = {
    "role": "user",
    "content": [{"type": "tool_result", "tool_use_id": tool_id, "content": "查询完成"}],
}
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/messages";
  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",
    "x-api-key": apiKey,
    "anthropic-version": "2023-06-01",
  };

  const payload = JSON.parse(await readFile("request.json", "utf8"));
  const reply = JSON.parse(await readFile("response.json", "utf8"));
  const assistant = { role: "assistant", content: reply.content };
  const tool = reply.content.find((block: { type: string }) => block.type === "tool_use");
  if (!tool?.id) throw new Error("Missing tool_use block");
  const toolResult = {
    role: "user",
    content: [{ type: "tool_result", tool_use_id: tool.id, content: "查询完成" }],
  };
  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;
});

将图片内容块放入 user 消息的 content。按 Anthropic 的 source 格式传入 URL 或 Base64。Messages 不支持视频、文件或 file_id。公网媒体地址须能被 MOSS API 访问。媒体编码后的完整请求体不得超过 10 MiB。

curl -X POST "$MOSS_API_ORIGIN/v1/messages" \
  -H 'Content-Type: application/json' \
  -H "x-api-key: $MOSS_API_KEY" \
  -H 'anthropic-version: 2023-06-01' \
  -d '{
  "model": "nex-n2.6",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "请描述这张图片。"
        },
        {
          "type": "image",
          "source": {
            "type": "url",
            "url": "https://httpbin.org/image/png"
          }
        }
      ]
    }
  ],
  "max_tokens": 1024
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/messages"
headers = {
    "Content-Type": 'application/json',
    "x-api-key": os.environ["MOSS_API_KEY"],
    "anthropic-version": '2023-06-01',
}

payload = {'model': 'nex-n2.6',
 'messages': [{'role': 'user',
               'content': [{'type': 'text', 'text': '请描述这张图片。'},
                           {'type': 'image',
                            'source': {'type': '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/messages";
  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",
    "x-api-key": apiKey,
    "anthropic-version": "2023-06-01",
  };

  const payload = {
    "model": "nex-n2.6",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "请描述这张图片。"
          },
          {
            "type": "image",
            "source": {
              "type": "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;
});

创建消息（Messages）

请求参数

返回值

Anthropic 客户端接入

相关文档