Create Message · MOSS API

Production HTTP requests use https://api.mosi.cn. Before running the examples below, set MOSS_API_ORIGIN to https://api.mosi.cn and MOSS_API_KEY to your MOSS API Key.

Request parameters

FieldTypeUsageDescription

model: stringRequired

Use nex-n2.6 or the pinned snapshot nex-n2.6-2026-11-05.

messages: array<object>Required

Pass the conversation messages and relevant history.

messages[].role: stringRequired

Use user or assistant. Send tool results in a user message.

messages[].content: string or arrayRequired

Use a string for text-only input. For images, use a content block with type: image and a URL or Base64 source. Messages does not support video.

max_tokens: integerProvide

Output token budget. The production default is 8192, and the parameter maximum is 131072. The examples pass 1024 explicitly.

stream: booleanOptional

Set to true to stream the response.

tools: array<object>Optional

Supports function tools executed by the client.

version: stringOptional

Optional. If supplied, use 2026-11-05 and make sure it matches the snapshot selected by model.

Response fields

FieldTypeDescription

model: string

ID of the snapshot used to generate this response.

content: array<object>

Read text from blocks with type set to text. Tool call blocks have type set to tool_use.

stop_reason: string or null

Stop reason. tool_use indicates that the client needs to execute a tool.

usage: object

Usage for this generation.

Anthropic client integration

Send requests to https://api.mosi.cn/v1/messages. Pass your MOSS API key in x-api-key and set anthropic-version: 2023-06-01.

Request example

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": "Reply with only the result of 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': 'Reply with only the result of 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": "Reply with only the result of 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;
});

Response excerpt. When a text reply ends naturally, stop_reason is 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"
    }
  ]
}

Set stream: true to stream the response. Read text from text_delta in content_block_delta. Stop reading at message_stop. Read input usage from message.usage in message_start, and output usage from usage in message_delta. Check the HTTP status first. Once streaming starts, check for error events and the expected termination marker. Treat an early disconnect as an incomplete response.

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": "Reply with only the result of 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': 'Reply with only the result of 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": "Reply with only the result of 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;
});

Streaming response excerpt.

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

Save the complete request and the non-streaming response from the previous turn as request.json and response.json. The HTTP example uses jq to assemble the follow-up request. The examples below send back a fixed demo result; in a real integration, validate and execute the tool first, then replace the result content.

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:"Lookup complete"}]}]' 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": "Lookup complete"}],
}
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: "Lookup complete" }],
  };
  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;
});

Place the image block in the content of a user message. Pass a URL or Base64 using Anthropic's source format. Messages does not support video, files, or file_id. Public media URLs must be accessible to MOSS. The entire request body, including encoded media, must be at most 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": "Describe this image."
        },
        {
          "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': 'Describe this image.'},
                           {'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": "Describe this image."
          },
          {
            "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;
});

Request parameters

Response fields

Anthropic client integration

Related documentation