ਰੀਜ਼ਨਿੰਗ effort
ਨਵਾਂਰੀਜ਼ਨਿੰਗ ਕਰਨ ਵਾਲਾ ਮਾਡਲ ਆਪਣਾ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਜਵਾਬ ਦੇ ਨਾਲ, ਇੱਕ ਵੱਖਰੇ ਫੀਲਡ ਵਿੱਚ, ਵਾਪਸ ਕਰਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਇੱਕ ਰਿਕੁਐਸਟ ਫੀਲਡ ਤੈਅ ਕਰਦਾ ਹੈ ਕਿ ਮਾਡਲ ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿੰਨੀ ਡੂੰਘੀ ਰੀਜ਼ਨਿੰਗ ਕਰੇ।
POST https://api.shannon-ai.com/v1/chat/completions
from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")
response = client.chat.completions.create(
model="Kimi-K3-3BIT-REAP",
reasoning_effort="low",
messages=[{"role": "user", "content": "Is 221 a prime number?"}],
)
message = response.choices[0].message
print("Reasoning:", getattr(message, "reasoning_content", None))
print("Answer:", message.content)
print("Reasoning tokens:", response.usage.completion_tokens_details.reasoning_tokens) import OpenAI from "openai";
const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://api.shannon-ai.com/v1" });
const response = await client.chat.completions.create({
model: "Kimi-K3-3BIT-REAP",
reasoning_effort: "low",
messages: [{ role: "user", content: "Is 221 a prime number?" }],
});
const message = response.choices[0].message;
console.log("Reasoning:", message.reasoning_content);
console.log("Answer:", message.content);
console.log("Reasoning tokens:", response.usage.completion_tokens_details.reasoning_tokens); curl https://api.shannon-ai.com/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "Kimi-K3-3BIT-REAP",
"reasoning_effort": "low",
"messages": [
{"role": "user", "content": "Is 221 a prime number?"}
]
}' ਜਵਾਬ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਨੂੰ reasoning_content ਵਿੱਚ, ਉੱਤਰ ਨੂੰ content ਵਿੱਚ, ਅਤੇ ਰੀਜ਼ਨਿੰਗ tokens ਨੂੰ usage ਵਿੱਚ ਲੈ ਕੇ ਆਉਂਦਾ ਹੈ:
{
"id": "chatcmpl-2a6c8e0b4d1f4a3c9e7b5d3f1a8c6e4b",
"object": "chat.completion",
"created": 1791590400,
"model": "Kimi-K3-3BIT-REAP",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "No. 221 = 13 x 17, so it is not prime.",
"reasoning_content": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 14,
"completion_tokens": 43,
"total_tokens": 57,
"prompt_tokens_details": {"cached_tokens": 0},
"completion_tokens_details": {"reasoning_tokens": 27}
}
} ਕਿਹੜੇ ਮਾਡਲ ਰੀਜ਼ਨਿੰਗ ਕਰਦੇ ਹਨ
| ਮਾਡਲ | ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਵਾਪਸ ਕਰਦਾ ਹੈ | effort ਫੀਲਡ ਲਾਗੂ ਕਰਦਾ ਹੈ |
|---|---|---|
shannon-1.6-lite | — | — |
shannon-1.6-pro, shannon-2-lite, shannon-2-pro, shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro, shannon-coder-1 | ਹਾਂ | — |
| ਹਰ ਹੋਸਟ ਕੀਤਾ open-weight ਮਾਡਲ | ਹਾਂ | ਹਾਂ |
ਇਹ ਉਹ ਫਲੈਗ capabilities.reasoning ਅਤੇ capabilities.reasoning_effort ਹਨ ਜੋ GET /v1/models ਹਰ id ਲਈ ਦੱਸਦਾ ਹੈ। ਜਵਾਬ ਵਿੱਚ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਸਿਰਫ਼ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਮਾਡਲ ਨੇ ਕੁਝ ਪੈਦਾ ਕੀਤਾ ਹੋਵੇ। ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ
effort ਸੈੱਟ ਕਰਨਾ
ਹਰ endpoint ਦੀ effort ਲਿਖਣ ਦੀ ਆਪਣੀ ਸ਼ੈਲੀ ਹੈ। ਉਹ ਸਭ ਇੱਕੋ ਚਾਰ ਪੱਧਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਚੁਣਦੇ ਹਨ।
| ਫੀਲਡ | ਕਿਸਮ | ਡਿਫੌਲਟ | ਵੇਰਵਾ | ਲਾਗੂ ਕਰਨ ਵਾਲੇ |
|---|---|---|---|---|
reasoning_effort | string | high | /v1/chat/completions। ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਮਾਡਲ ਕਿੰਨੀ ਡੂੰਘੀ ਰੀਜ਼ਨਿੰਗ ਕਰਦਾ ਹੈ: off, low, medium ਜਾਂ high। | ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ |
reasoning | object | string | /v1/chat/completions। ਉਹੀ ਮੁੱਲ {"effort": "low"} ਵਜੋਂ ਜਾਂ ਸਿੱਧੀ string ਵਜੋਂ। ਜਦੋਂ ਦੋਵੇਂ ਫੀਲਡ ਭੇਜੇ ਜਾਣ, reasoning_effort ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ। | ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ | |
reasoning.effort | string | high | /v1/responses। object {"effort": "low"} ਵਜੋਂ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। | ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ |
thinking | object | /v1/messages। {"type": "enabled", "budget_tokens": n} ਜਾਂ {"type": "disabled"}। ਬਜਟ ਪੱਧਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਚੁਣਦਾ ਹੈ; ਹੋਰ ਹੇਠਾਂ ਦਿੱਤਾ ਟੇਬਲ ਵੇਖੋ। | ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ |
{
"model": "Kimi-K3-3BIT-REAP",
"reasoning_effort": "low",
"messages": [{"role": "user", "content": "Is 221 a prime number?"}]
} {
"model": "Kimi-K3-3BIT-REAP",
"reasoning": {"effort": "low"},
"input": "Is 221 a prime number?"
} {
"model": "Kimi-K3-3BIT-REAP",
"max_tokens": 1024,
"thinking": {"type": "enabled", "budget_tokens": 2048},
"messages": [{"role": "user", "content": "Is 221 a prime number?"}]
} | ਮੁੱਲ | ਇਹ ਵੀ ਸਵੀਕਾਰ ਹਨ | ਅਸਰ |
|---|---|---|
off | none, minimal | ਕੋਈ ਰੀਜ਼ਨਿੰਗ ਨਹੀਂ। ਜਵਾਬ ਵਿੱਚ ਕੋਈ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਨਹੀਂ ਹੁੰਦਾ। |
low | ਸੰਖੇਪ ਰੀਜ਼ਨਿੰਗ। | |
medium | default | ਦਰਮਿਆਨੀ ਡੂੰਘਾਈ। |
high | max | ਸਭ ਤੋਂ ਡੂੰਘਾ ਪੱਧਰ। ਜੋ ਰਿਕੁਐਸਟ ਕੋਈ ਮੁੱਲ ਨਹੀਂ ਭੇਜਦੀ, ਉਸ ਦਾ ਪੱਧਰ ਇਹੀ ਹੈ। |
- ਮੁੱਲ ਵੱਡੇ ਜਾਂ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ ਪੜ੍ਹੇ ਜਾਂਦੇ ਹਨ।
- ਮੁੱਲ
defaultਦਾ ਮਤਲਬmediumਹੈ। ਫੀਲਡ ਨੂੰ ਛੱਡ ਦੇਣ ਦਾ ਮਤਲਬhighਹੈ। - Shannon ਮਾਡਲ (
shannon-*) ਹਰ ਰਿਕੁਐਸਟ ਵਿੱਚ ਆਪਣੀ ਡੂੰਘਾਈ ਆਪ ਤੈਅ ਕਰਦੇ ਹਨ;GET /v1/modelsਉਨ੍ਹਾਂ ਲਈreasoning_effort: falseਦੱਸਦਾ ਹੈ।
/v1/messages ਉੱਤੇ ਸੋਚਣ ਦਾ ਬਜਟ
/v1/messages ਉੱਤੇ thinking ਫੀਲਡ ਪੱਧਰ ਚੁਣਦਾ ਹੈ। budget_tokens ਉੱਪਰ ਦਿੱਤੇ ਪੱਧਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਚੁਣਦਾ ਹੈ; ਇਹ token ਦੀ ਆਪਣੀ ਕੋਈ ਸੀਮਾ ਨਹੀਂ ਹੈ। adaptive ਨੂੰ enabled ਵਾਂਗ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ।
| ਤੁਸੀਂ ਭੇਜਦੇ ਹੋ | ਪੱਧਰ |
|---|---|
{"type": "disabled"} | off |
{"type": "enabled", "budget_tokens": n}, ਜਿੱਥੇ n ਵੱਧ ਤੋਂ ਵੱਧ 2,048 ਹੋਵੇ | low |
n 2,049 ਤੋਂ 8,192 ਤੱਕ | medium |
ਵੱਡਾ n, ਜਾਂ budget_tokens ਤੋਂ ਬਿਨਾਂ enabled | high |
ਕੋਈ thinking ਫੀਲਡ ਨਹੀਂ | high |
ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਕਿੱਥੇ ਪਹੁੰਚਦਾ ਹੈ
ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਹਮੇਸ਼ਾ ਜਵਾਬ ਤੋਂ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ। ਹਰ ਫਾਰਮੈਟ ਵਿੱਚ ਇਸ ਲਈ ਆਪਣੀ ਥਾਂ ਹੈ:
| ਐਂਡਪੁਆਇੰਟ | stream ਨਹੀਂ ਕੀਤਾ | stream ਕੀਤਾ |
|---|---|---|
/v1/chat/completions | choices[0].message.reasoning_content: ਇੱਕ string, ਜਾਂ ਜਦੋਂ ਮਾਡਲ ਨੇ ਕੁਝ ਪੈਦਾ ਨਾ ਕੀਤਾ ਹੋਵੇ ਤਾਂ null। | delta.content ਵਾਲੇ chunks ਤੋਂ ਪਹਿਲਾਂ choices[0].delta.reasoning_content ਵਾਲੇ chunks। |
/v1/responses | message ਆਈਟਮ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ output ਆਈਟਮ {"type": "reasoning", "summary": [{"type": "summary_text", "text": "…"}]}। ਰੀਜ਼ਨਿੰਗ ਨਾ ਹੋਣ ਉੱਤੇ ਕੋਈ ਆਈਟਮ ਨਹੀਂ। | reasoning ਆਈਟਮ ਵਾਲਾ response.output_item.added, ਫਿਰ response.reasoning_summary_text.delta events ਅਤੇ ਇੱਕ response.reasoning_summary_text.done। |
/v1/messages | ਪਹਿਲਾ content block {"type": "thinking", "thinking": "…"}, ਫਿਰ text block। ਰੀਜ਼ਨਿੰਗ ਨਾ ਹੋਣ ਉੱਤੇ ਕੋਈ thinking block ਨਹੀਂ। | ਇੱਕ thinking content block: content_block_start, thinking_delta ਵਾਲੇ content_block_delta events, content_block_stop। ਟੈਕਸਟ block ਬਾਅਦ ਵਿੱਚ ਆਉਂਦਾ ਹੈ। |
{
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "No. 221 = 13 x 17, so it is not prime.",
"reasoning_content": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 14,
"completion_tokens": 43,
"total_tokens": 57,
"prompt_tokens_details": {"cached_tokens": 0},
"completion_tokens_details": {"reasoning_tokens": 27}
}
} {
"output": [
{
"id": "rs_6f0a2c4e8b1d4f3a9c7e5b3d1f8a6c4e",
"type": "reasoning",
"summary": [
{
"type": "summary_text",
"text": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
}
]
},
{
"id": "msg_1b3d5f7a9c2e4b6d8f0a2c4e6b8d0f1a",
"type": "message",
"role": "assistant",
"status": "completed",
"content": [
{
"type": "output_text",
"text": "No. 221 = 13 x 17, so it is not prime.",
"annotations": []
}
]
}
],
"usage": {
"input_tokens": 14,
"input_tokens_details": {"cached_tokens": 0},
"output_tokens": 43,
"output_tokens_details": {"reasoning_tokens": 27},
"total_tokens": 57
}
} {
"content": [
{
"type": "thinking",
"thinking": "Try small primes. 221 / 13 = 17, so 221 = 13 x 17."
},
{"type": "text", "text": "No. 221 = 13 x 17, so it is not prime."}
],
"stop_reason": "end_turn",
"usage": {
"input_tokens": 14,
"cache_read_input_tokens": 0,
"cache_creation_input_tokens": 0,
"output_tokens": 43
}
} ਕਿੱਥੇ ਵੇਖਣਾ ਹੈ, ਮਾਡਲ ਅਨੁਸਾਰ:
| ਮਾਡਲ | ਟੈਕਸਟ ਕਿੱਥੇ ਪਹੁੰਚਦਾ ਹੈ |
|---|---|
| ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ | ਹਰ endpoint ਉੱਤੇ, stream ਕੀਤਾ ਜਾਂ ਨਹੀਂ। effort off ਵਾਲੀ ਰਿਕੁਐਸਟ, ਜਾਂ response_format / text.format ਵਾਲੀ ਰਿਕੁਐਸਟ, ਦਾ ਜਵਾਬ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਤੋਂ ਬਿਨਾਂ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। |
shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro | ਹਰ endpoint ਉੱਤੇ, stream ਕੀਤਾ ਜਾਂ ਨਹੀਂ, ਜਦੋਂ ਵੀ ਮਾਡਲ ਨੇ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਪੈਦਾ ਕੀਤਾ ਹੋਵੇ। |
shannon-2-lite, shannon-2-pro | /v1/chat/completions, stream ਨਹੀਂ ਕੀਤਾ: message.reasoning_content ਵਿੱਚ। stream ਕੀਤਾ, tools ਜਾਂ response_format ਤੋਂ ਬਿਨਾਂ ਰਿਕੁਐਸਟ ਵਿੱਚ: ਜਦੋਂ ਤੱਕ ਮਾਡਲ ਰੀਜ਼ਨਿੰਗ ਕਰਦਾ ਹੈ stream ਟਿੱਪਣੀ ਲਾਈਨਾਂ : thinking ਲੈ ਕੇ ਆਉਂਦੀ ਹੈ, ਫਿਰ ਜਵਾਬ ਦੇ chunks। /v1/messages, stream ਕੀਤਾ: ਟੈਕਸਟ block ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ thinking block। |
shannon-1.6-pro, shannon-coder-1 | stream ਕੀਤੇ ਜਵਾਬਾਂ ਵਿੱਚ ਅਤੇ tools ਵਾਲੀਆਂ ਰਿਕੁਐਸਟਾਂ ਦੇ ਜਵਾਬਾਂ ਵਿੱਚ, ਜਦੋਂ ਵੀ ਮਾਡਲ ਨੇ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਪੈਦਾ ਕੀਤਾ ਹੋਵੇ। |
/v1/responses ਉੱਤੇ, stream ਨਾ ਕੀਤਾ ਜਵਾਬ Shannon 3 ਪਰਿਵਾਰ ਅਤੇ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਲਈ reasoning ਆਈਟਮ ਲੈ ਕੇ ਆਉਂਦਾ ਹੈ।
stream ਪੜ੍ਹਨਾ
stream ਵਿੱਚ ਰੀਜ਼ਨਿੰਗ ਟੈਕਸਟ ਪਹਿਲਾਂ, ਆਪਣੇ ਵੱਖਰੇ deltas ਵਿੱਚ, ਆਉਂਦਾ ਹੈ, ਅਤੇ ਜਵਾਬ ਬਾਅਦ ਵਿੱਚ। ਦੋਵਾਂ ਨੂੰ ਵੱਖਰਾ-ਵੱਖਰਾ ਛਾਪੋ ਜਾਂ ਸੰਭਾਲੋ:
from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")
stream = client.chat.completions.create(
model="Kimi-K3-3BIT-REAP",
reasoning_effort="medium",
stream=True,
messages=[{"role": "user", "content": "Is 221 a prime number?"}],
)
for chunk in stream:
if not chunk.choices:
continue
delta = chunk.choices[0].delta
reasoning = getattr(delta, "reasoning_content", None)
if reasoning:
print(reasoning, end="", flush=True) # the reasoning text comes first
if delta.content:
print(delta.content, end="", flush=True) # then the answer import OpenAI from "openai";
const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://api.shannon-ai.com/v1" });
const stream = await client.chat.completions.create({
model: "Kimi-K3-3BIT-REAP",
reasoning_effort: "medium",
stream: true,
messages: [{ role: "user", content: "Is 221 a prime number?" }],
});
for await (const chunk of stream) {
const delta = chunk.choices[0]?.delta ?? {};
if (delta.reasoning_content) process.stdout.write(delta.reasoning_content); // the reasoning text comes first
if (delta.content) process.stdout.write(delta.content); // then the answer
} curl -N https://api.shannon-ai.com/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "Kimi-K3-3BIT-REAP",
"reasoning_effort": "medium",
"stream": true,
"messages": [
{"role": "user", "content": "Is 221 a prime number?"}
]
}' ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਦੇ ਪਹਿਲੇ chunk ਵਿੱਚ, ਰੀਜ਼ਨਿੰਗ ਹੋਵੇ ਜਾਂ ਜਵਾਬ, delta.role: "assistant" ਵੀ ਹੁੰਦਾ ਹੈ। ਸਟ੍ਰੀਮਿੰਗ
ਰੀਜ਼ਨਿੰਗ tokens ਅਤੇ ਬਿਲਿੰਗ
ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਰੀਜ਼ਨਿੰਗ tokens ਆਉਟਪੁੱਟ tokens ਹਨ: ਉਨ੍ਹਾਂ ਦਾ ਬਿਲ ਮਾਡਲ ਦੀ ਆਉਟਪੁੱਟ ਕੀਮਤ ਉੱਤੇ ਬਣਦਾ ਹੈ, ਅਤੇ ਆਉਟਪੁੱਟ ਗਿਣਤੀ ਵਿੱਚ ਉਹ ਪਹਿਲਾਂ ਹੀ ਸ਼ਾਮਲ ਹਨ। usage ਇੱਥੇ ਰੀਜ਼ਨਿੰਗ ਦਾ ਹਿੱਸਾ ਦਿਖਾਉਂਦੀ ਹੈ:
| ਐਂਡਪੁਆਇੰਟ | ਫੀਲਡ | ਨੋਟ |
|---|---|---|
/v1/chat/completions | usage.completion_tokens_details.reasoning_tokens | completion_tokens ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਸ਼ਾਮਲ। |
/v1/responses | usage.output_tokens_details.reasoning_tokens | output_tokens ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਸ਼ਾਮਲ। |
/v1/messages | usage.output_tokens | ਰੀਜ਼ਨਿੰਗ ਅਤੇ ਜਵਾਬ ਇਕੱਠੇ। ਇਸ ਫਾਰਮੈਟ ਵਿੱਚ ਵੱਖਰੀ ਗਿਣਤੀ ਨਹੀਂ ਹੈ। |
- ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ
max_tokensਜਵਾਬ ਦੇ ਟੈਕਸਟ ਨੂੰ ਸੀਮਤ ਕਰਦਾ ਹੈ। ਰੀਜ਼ਨਿੰਗ tokens ਇਸ ਵਿੱਚ ਨਹੀਂ ਗਿਣੇ ਜਾਂਦੇ। - ਕਿਉਂਕਿ ਰੀਜ਼ਨਿੰਗ ਦਾ ਬਿਲ ਆਉਟਪੁੱਟ ਵਜੋਂ ਬਣਦਾ ਹੈ, ਇਸ ਲਈ effort ਪੱਧਰ ਇੱਕ ਲਾਗਤ ਸੈਟਿੰਗ ਵੀ ਹੈ:
offਕੋਈ ਰੀਜ਼ਨਿੰਗ tokens ਪੈਦਾ ਨਹੀਂ ਕਰਦਾ। - Shannon ਮਾਡਲ
prompt_tokens,completion_tokensਅਤੇtotal_tokens(/v1/messagesਉੱਤੇinput_tokensਅਤੇoutput_tokens) ਰੀਜ਼ਨਿੰਗ ਦੇ ਹਿੱਸੇ ਤੋਂ ਬਿਨਾਂ ਦੱਸਦੇ ਹਨ, ਅਤੇ ਪ੍ਰਤੀ token ਇੱਕ ਸਮਤਲ ਕੀਮਤ ਦਾ ਬਿਲ ਬਣਾਉਂਦੇ ਹਨ। ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ
ਅਗਲੀ ਰਿਕੁਐਸਟ ਵਿੱਚ ਰੀਜ਼ਨਿੰਗ
ਤੁਹਾਨੂੰ ਰੀਜ਼ਨਿੰਗ ਵਾਪਸ ਭੇਜਣ ਦੀ ਲੋੜ ਨਹੀਂ। ਤੁਹਾਡੀ ਭੇਜੀ ਗੱਲਬਾਤ ਵਿੱਚ thinking block ਜਾਂ reasoning ਆਈਟਮ ਮਾਡਲ ਨੂੰ ਅੱਗੇ ਨਹੀਂ ਦਿੱਤੀ ਜਾਂਦੀ, ਇਸ ਲਈ assistant turn ਇਸ ਦੇ ਨਾਲ ਜਾਂ ਬਿਨਾਂ ਵਾਪਸ ਜਾ ਸਕਦਾ ਹੈ। thinking block ਵਿੱਚ ਦੋ ਫੀਲਡ type ਅਤੇ thinking ਹੁੰਦੇ ਹਨ; ਇਸ ਵਿੱਚ ਕੋਈ signature ਨਹੀਂ ਹੁੰਦਾ।
ਗਲਤੀਆਂ
| ਸਟੇਟਸ | ਕਿਸਮ | ਸੁਨੇਹਾ | ਕਦੋਂ |
|---|---|---|---|
400 | invalid_request_error | unknown reasoning effort '<value>'; expected off, low, medium or high | ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਨੂੰ ਸੂਚੀ ਤੋਂ ਬਾਹਰ ਦਾ ਮੁੱਲ ਮਿਲਿਆ, ਉਦਾਹਰਣ ਵਜੋਂ xhigh। ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚੋਂ ਕੁਝ ਨਹੀਂ ਕੱਟਿਆ ਜਾਂਦਾ। |
422 | invalid_request_error | Failed to deserialize the JSON body into the target type: … | reasoning_effort ਕੋਈ string ਨਹੀਂ ਹੈ। |
ਪ੍ਰਮਾਣਿਕਤਾ, ਬੈਲੇਂਸ ਅਤੇ ਸਰਵਰ ਦੀਆਂ ਗਲਤੀਆਂ ਉਹੀ ਹਨ ਜੋ ਹਰ ਰਿਕੁਐਸਟ ਲਈ ਹੁੰਦੀਆਂ ਹਨ। ਗਲਤੀਆਂ