Create Chat Completion

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. Set the OpenAI SDK base_url to https://api.mosi.cn/v1.

Request parameters

FieldTypeUsageDescription

model: stringRequired

Use nex-n2.6. To pin a version, use nex-n2.6-2026-11-05.

messages: array<object>Required

Conversation messages. For a text-only request, send one message with role set to user. To continue a conversation, include the relevant history.

messages[].content: string or arrayDepends on the message type

Use a string for text. For text with images, send content items with text and image_url. Use video_url for MP4 or WebM video.

max_tokens: integerOptional

Output token budget. The production default is 8,192 and the maximum is 131,072. Specify either this field or max_completion_tokens.

max_completion_tokens: integerOptional

Compatibility alias for max_tokens. Specify either this field or max_tokens.

stream: booleanOptional

Set to true to stream the response.

stream_options.include_usage: booleanOptional

Set to true on a streaming request to receive usage at the end of the stream.

tools: array<object>Optional

Supports function tools executed by the client. Server-hosted tools are unavailable.

thinking.type: stringOptional

Accepts enabled. disabled is currently unsupported.

response_format.type: stringOptional

Set to json_object to request a JSON object reply.

tool_choice: string or objectOptional

Use auto to let the model choose a tool, none to disable structured tool calls, or an object to select a function.

version: stringOptional

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

Set image_url.url to a public HTTPS URL or a complete Base64 data URL. Use video_url for MP4 or WebM video. Public media URLs must be accessible to MOSS. The entire request body, including encoded media, must be at most 10 MiB. Files, file_id, and asset library references are currently unsupported.

Response fields

FieldTypeDescription

model: string

The model snapshot used to generate the response.

choices[].message.content: string

Final text. This may be empty if reasoning consumes the entire output budget.

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

Structured tool calls for the client to execute.

choices[].finish_reason: string

stop indicates natural completion, length indicates that the output budget was reached, and tool_calls indicates that the model generated tool calls.

usage: object

Read prompt_tokens, completion_tokens, and total_tokens. Cached input usage is in prompt_tokens_details.cached_tokens. Reasoning usage is in completion_tokens_details.reasoning_tokens.

Reasoning and final replies

Read the final reply from choices[].message.content. If the assistant message for a tool call contains reasoning_content, preserve it when sending back the tool result. thinking.type accepts enabled. Setting it to disabled returns HTTP 400 with invalid_field_value.

Client integration

Set the OpenAI SDK base_url to https://api.mosi.cn/v1. In streaming responses, handle text, finish reasons, and usage separately. Check whether choices is empty before reading it.

Request example

Run the example in any of the three languages. The Python examples use requests. The TypeScript examples require a Node.js environment with fetch.

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

Response excerpt. On natural completion, finish_reason is stop. Actual token usage varies with the request and generated output.

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

Put the image address in image_url.url. You can use a public HTTPS URL or a complete Base64 data URL. With Base64, the entire request body cannot exceed 10 MiB. Private network URLs and file_id are not supported yet.

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": "Briefly describe this image."
        },
        {
          "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': 'Briefly describe this image.'},
                           {'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": "Briefly describe this image."
          },
          {
            "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;
});

Set stream: true and pass -N to curl. Check the HTTP status and handle any error events. For each chunk, append choices[0].delta.content only when the choice and its text delta are present. To receive usage, set stream_options.include_usage: true and read the final usage chunk separately because its choices array is empty. Stop at data: [DONE]. Treat a disconnect before that marker as incomplete.

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

Streaming response excerpt. With include_usage enabled, a separate usage chunk with an empty choices array appears before [DONE].

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]

When output reaches max_tokens, finish_reason is length. The output budget includes reasoning tokens. The example sets the budget to 8. Reasoning consumes it all, so the final text is empty.

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": "Output every integer from 1 to 80 in full, one integer per line."
    }
  ],
  "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': 'Output every integer from 1 to 80 in full, one integer per line.'}],
 '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": "Output every integer from 1 to 80 in full, one integer per line."
      }
    ],
    "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;
});

Non-streaming response excerpt

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

With stream and stream_options.include_usage enabled, the streaming response also returns length in the final choice chunk. The usage chunk follows.

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]

Declare functions in tools. Set tool_choice to auto or none, or pass {"type":"function","function":{"name":"function_name"}} to select a function. Execute only structured tool_calls.

Function call request body example

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": "Call get_demo_status to look up the status of demo record sample-a. After you receive the tool result, output only the status."
    }
  ],
  "max_tokens": 256,
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_demo_status",
        "description": "Read the fixed status of a demo record.",
        "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': 'Call get_demo_status to look up the status of demo record sample-a. After you receive the tool result, output only the status.'}],
 'max_tokens': 256,
 'tools': [{'type': 'function',
            'function': {'name': 'get_demo_status',
                         'description': 'Read the fixed status of a demo record.',
                         '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": "Call get_demo_status to look up the status of demo record sample-a. After you receive the tool result, output only the status."
      }
    ],
    "max_tokens": 256,
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "get_demo_status",
          "description": "Read the fixed status of a demo record.",
          "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 call response excerpt. function.arguments is a JSON string. Parse and validate it before executing the function. call_example stands for the tool call ID returned in the actual response.

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

When streaming, group fragments by choice.index and the tool call index. Wait until the arguments are complete before parsing them. The excerpt shows the function name, the first two argument fragments, the finish reason, and the final usage.

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]

Save the complete previous request and non-streaming response as request.json and response.json, respectively. The HTTP example uses jq to assemble the follow-up request. The examples send a fixed result for demonstration. In production, validate and execute the tool, then substitute its actual result.

Keep the entire previous assistant message, including any reasoning_content and tool_calls returned in the response.

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;
});

After the follow-up request, the model uses the tool result to generate a final reply. The following is an excerpt from that response.

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

Request parameters

Response fields

Reasoning and final replies

Client integration

Related documentation