ರೀಸನಿಂಗ್ ಪ್ರಯತ್ನ
ಹೊಸರೀಸನಿಂಗ್ ಮಾಡುವ ಮಾಡೆಲ್ ತನ್ನ ರೀಸನಿಂಗ್ ಪಠ್ಯವನ್ನು ಉತ್ತರದ ಪಕ್ಕದಲ್ಲಿ, ತನ್ನದೇ ಫೀಲ್ಡ್ನಲ್ಲಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳಲ್ಲಿ, ಉತ್ತರಿಸುವ ಮೊದಲು ಮಾಡೆಲ್ ಎಷ್ಟು ಆಳವಾಗಿ ರೀಸನಿಂಗ್ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಒಂದು ವಿನಂತಿ ಫೀಲ್ಡ್ ಹೊಂದಿಸುತ್ತದೆ.
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 ನಲ್ಲಿ, ಮತ್ತು ರೀಸನಿಂಗ್ ಟೋಕನ್ಗಳನ್ನು 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 | ಹೌದು | — |
| ಪ್ರತಿ ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ | ಹೌದು | ಹೌದು |
ಇವು GET /v1/models ಪ್ರತಿ id ಗೆ ವರದಿ ಮಾಡುವ capabilities.reasoning ಮತ್ತು capabilities.reasoning_effort ಫ್ಲ್ಯಾಗ್ಗಳು. ಮಾಡೆಲ್ ಏನಾದರೂ ಉತ್ಪಾದಿಸಿದಾಗ ಮಾತ್ರ ಉತ್ತರ ರೀಸನಿಂಗ್ ಪಠ್ಯವನ್ನು ಹೊತ್ತಿರುತ್ತದೆ. ಮಾಡೆಲ್ಗಳು ಮತ್ತು ಬೆಲೆ
effort ಹೊಂದಿಸುವುದು
ಪ್ರತಿ ಎಂಡ್ಪಾಯಿಂಟ್ effort ಅನ್ನು ತನ್ನದೇ ರೀತಿಯಲ್ಲಿ ಬರೆಯುತ್ತದೆ. ಅವೆಲ್ಲವೂ ಒಂದೇ ನಾಲ್ಕು ಮಟ್ಟಗಳಲ್ಲಿ ಒಂದನ್ನು ಆರಿಸುತ್ತವೆ.
| ಫೀಲ್ಡ್ | ವಿಧ | ಡಿಫಾಲ್ಟ್ | ವಿವರಣೆ | ಅನ್ವಯಿಸುವವರು |
|---|---|---|---|---|
reasoning_effort | string | high | /v1/chat/completions. ಉತ್ತರಿಸುವ ಮೊದಲು ಮಾಡೆಲ್ ಎಷ್ಟು ಆಳವಾಗಿ ರೀಸನಿಂಗ್ ಮಾಡುತ್ತದೆ: off, low, medium ಅಥವಾ high. | ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳು |
reasoning | object | string | /v1/chat/completions. {"effort": "low"} ಆಗಿ ಅಥವಾ ಬರಿಯ string ಆಗಿ ಅದೇ ಮೌಲ್ಯ. ಎರಡೂ ಫೀಲ್ಡ್ಗಳನ್ನು ಕಳುಹಿಸಿದರೆ, reasoning_effort ಪರಿಗಣಿಸಲ್ಪಡುತ್ತದೆ. | ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳು | |
reasoning.effort | string | high | /v1/responses. {"effort": "low"} ಆಬ್ಜೆಕ್ಟ್ ಆಗಿ ಬರೆಯಲಾಗುತ್ತದೆ. | ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳು |
thinking | object | /v1/messages. {"type": "enabled", "budget_tokens": n} ಅಥವಾ {"type": "disabled"}. budget ಮಟ್ಟಗಳಲ್ಲಿ ಒಂದನ್ನು ಆರಿಸುತ್ತದೆ; ಕೆಳಗಿನ ಕೋಷ್ಟಕ ನೋಡಿ. | ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳು |
{
"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 ನಲ್ಲಿ ಚಿಂತನೆಯ ಬಜೆಟ್ (thinking budget)
/v1/messages ನಲ್ಲಿ thinking ಫೀಲ್ಡ್ ಮಟ್ಟವನ್ನು ಆರಿಸುತ್ತದೆ. budget_tokens ಮೇಲಿನ ಮಟ್ಟಗಳಲ್ಲಿ ಒಂದನ್ನು ಆರಿಸುತ್ತದೆ; ಅದು ತನ್ನದೇ ಟೋಕನ್ ಮಿತಿಯಲ್ಲ. adaptive ಅನ್ನು enabled ನಂತೆ ಓದಲಾಗುತ್ತದೆ.
| ನೀವು ಕಳುಹಿಸುವುದು | ಮಟ್ಟ |
|---|---|
{"type": "disabled"} | off |
n 2,048 ವರೆಗೆ ಇರುವ {"type": "enabled", "budget_tokens": n} | 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 ಇರುವ chunk ಗಳ ಮೊದಲು choices[0].delta.reasoning_content ಇರುವ chunk ಗಳು. |
/v1/responses | message ಐಟಂ ಮೊದಲು output ಐಟಂ {"type": "reasoning", "summary": [{"type": "summary_text", "text": "…"}]}. ರೀಸನಿಂಗ್ ಇಲ್ಲದಿದ್ದರೆ ಐಟಂ ಇರುವುದಿಲ್ಲ. | reasoning ಐಟಂ ಇರುವ response.output_item.added, ನಂತರ response.reasoning_summary_text.delta ಈವೆಂಟ್ಗಳು ಮತ್ತು ಒಂದು response.reasoning_summary_text.done. |
/v1/messages | ಮೊದಲ ಕಂಟೆಂಟ್ ಬ್ಲಾಕ್ {"type": "thinking", "thinking": "…"}, ನಂತರ text ಬ್ಲಾಕ್. ರೀಸನಿಂಗ್ ಇಲ್ಲದಿದ್ದರೆ thinking ಬ್ಲಾಕ್ ಇರುವುದಿಲ್ಲ. | thinking ಕಂಟೆಂಟ್ ಬ್ಲಾಕ್: content_block_start, thinking_delta ಇರುವ content_block_delta ಈವೆಂಟ್ಗಳು, content_block_stop. ಪಠ್ಯ ಬ್ಲಾಕ್ ಅನುಸರಿಸುತ್ತದೆ. |
{
"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
}
} ಎಲ್ಲಿ ನೋಡಬೇಕು, ಪ್ರತಿ ಮಾಡೆಲ್ಗೆ:
| ಮಾಡೆಲ್ಗಳು | ಪಠ್ಯ ಎಲ್ಲಿ ಬರುತ್ತದೆ |
|---|---|
| ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳು | ಪ್ರತಿ ಎಂಡ್ಪಾಯಿಂಟ್ನಲ್ಲಿ, stream ಮಾಡಿದ್ದಾಗಲೂ ಇಲ್ಲದಿದ್ದಾಗಲೂ. effort off ಇರುವ, ಅಥವಾ response_format / text.format ಇರುವ ವಿನಂತಿಗೆ ರೀಸನಿಂಗ್ ಪಠ್ಯವಿಲ್ಲದೆ ಉತ್ತರಿಸಲಾಗುತ್ತದೆ. |
shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro | ಪ್ರತಿ ಎಂಡ್ಪಾಯಿಂಟ್ನಲ್ಲಿ, stream ಮಾಡಿದ್ದಾಗಲೂ ಇಲ್ಲದಿದ್ದಾಗಲೂ, ಮಾಡೆಲ್ ರೀಸನಿಂಗ್ ಪಠ್ಯವನ್ನು ಉತ್ಪಾದಿಸಿದಾಗಲೆಲ್ಲಾ. |
shannon-2-lite, shannon-2-pro | /v1/chat/completions, stream ಮಾಡದಿದ್ದಾಗ: message.reasoning_content ನಲ್ಲಿ. stream ಮಾಡಿದಾಗ, tools ಅಥವಾ response_format ಇಲ್ಲದ ವಿನಂತಿಯಲ್ಲಿ: ಮಾಡೆಲ್ ರೀಸನಿಂಗ್ ಮಾಡುತ್ತಿರುವಾಗ stream : thinking ಕಾಮೆಂಟ್ ಸಾಲುಗಳನ್ನು ಹೊತ್ತಿರುತ್ತದೆ, ನಂತರ ಉತ್ತರದ chunk ಗಳು. /v1/messages, stream ಮಾಡಿದಾಗ: ಪಠ್ಯ ಬ್ಲಾಕ್ ಮೊದಲು thinking ಬ್ಲಾಕ್. |
shannon-1.6-pro, shannon-coder-1 | stream ಮಾಡಿದ ಉತ್ತರಗಳಲ್ಲಿ ಮತ್ತು tools ಹೊತ್ತ ವಿನಂತಿಗಳ ಉತ್ತರಗಳಲ್ಲಿ, ಮಾಡೆಲ್ ರೀಸನಿಂಗ್ ಪಠ್ಯವನ್ನು ಉತ್ಪಾದಿಸಿದಾಗಲೆಲ್ಲಾ. |
/v1/responses ನಲ್ಲಿ, stream ಮಾಡದ ಉತ್ತರ Shannon 3 ಕುಟುಂಬ ಮತ್ತು ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳಿಗೆ 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?"}
]
}' ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ನ ಮೊದಲ chunk, ರೀಸನಿಂಗ್ ಆಗಿರಲಿ ಉತ್ತರವಾಗಿರಲಿ, delta.role: "assistant" ಅನ್ನೂ ಹೊತ್ತಿರುತ್ತದೆ. ಸ್ಟ್ರೀಮಿಂಗ್
ರೀಸನಿಂಗ್ ಟೋಕನ್ಗಳು ಮತ್ತು ಬಿಲಿಂಗ್
ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳಲ್ಲಿ, ರೀಸನಿಂಗ್ ಟೋಕನ್ಗಳು ಔಟ್ಪುಟ್ ಟೋಕನ್ಗಳು: ಅವನ್ನು ಮಾಡೆಲ್ನ ಔಟ್ಪುಟ್ ಬೆಲೆಯಲ್ಲಿ ಬಿಲ್ ಮಾಡಲಾಗುತ್ತದೆ, ಮತ್ತು ಔಟ್ಪುಟ್ ಎಣಿಕೆ ಈಗಾಗಲೇ ಅವನ್ನು ಒಳಗೊಂಡಿದೆ. 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 | ರೀಸನಿಂಗ್ ಮತ್ತು ಉತ್ತರ ಒಟ್ಟಾಗಿ. ಈ ಫಾರ್ಮ್ಯಾಟ್ಗೆ ಪ್ರತ್ಯೇಕ ಎಣಿಕೆ ಇಲ್ಲ. |
- ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ಗಳಲ್ಲಿ
max_tokensಉತ್ತರ ಪಠ್ಯವನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ. ರೀಸನಿಂಗ್ ಟೋಕನ್ಗಳು ಅದರ ವಿರುದ್ಧ ಎಣಿಕೆಯಾಗುವುದಿಲ್ಲ. - ರೀಸನಿಂಗ್ ಅನ್ನು ಔಟ್ಪುಟ್ ಆಗಿ ಬಿಲ್ ಮಾಡುವುದರಿಂದ, effort ಮಟ್ಟವು ವೆಚ್ಚದ ಸೆಟ್ಟಿಂಗ್ ಕೂಡ ಆಗಿದೆ:
offಯಾವುದೇ ರೀಸನಿಂಗ್ ಟೋಕನ್ಗಳನ್ನು ಉತ್ಪಾದಿಸುವುದಿಲ್ಲ. - Shannon ಮಾಡೆಲ್ಗಳು
prompt_tokens,completion_tokensಮತ್ತುtotal_tokensಅನ್ನು (/v1/messagesನಲ್ಲಿinput_tokensಮತ್ತುoutput_tokens) ರೀಸನಿಂಗ್ ಪಾಲಿಲ್ಲದೆ ವರದಿ ಮಾಡುತ್ತವೆ, ಮತ್ತು ಪ್ರತಿ ಟೋಕನ್ಗೆ ಒಂದೇ ಸಮತಟ್ಟಾದ ಬೆಲೆಯನ್ನು ಬಿಲ್ ಮಾಡುತ್ತವೆ. ಮಾಡೆಲ್ಗಳು ಮತ್ತು ಬೆಲೆ
ಮುಂದಿನ ವಿನಂತಿಯಲ್ಲಿ ರೀಸನಿಂಗ್
ನೀವು ರೀಸನಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕಿಲ್ಲ. ನೀವು ಕಳುಹಿಸುವ ಸಂಭಾಷಣೆಯಲ್ಲಿನ thinking ಬ್ಲಾಕ್ ಅಥವಾ reasoning ಐಟಂ ಅನ್ನು ಮಾಡೆಲ್ಗೆ ಮುಂದುವರಿಸಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ assistant ಟರ್ನ್ ಅದರೊಂದಿಗೆ ಅಥವಾ ಅದಿಲ್ಲದೆ ಹಿಂತಿರುಗಬಹುದು. thinking ಬ್ಲಾಕ್ type ಮತ್ತು thinking ಎಂಬ ಎರಡು ಫೀಲ್ಡ್ಗಳನ್ನು ಹೊಂದಿದೆ; ಅದಕ್ಕೆ signature ಇಲ್ಲ.
ದೋಷಗಳು
| ಸ್ಥಿತಿ | ವಿಧ | ಸಂದೇಶ | ಯಾವಾಗ |
|---|---|---|---|
400 | invalid_request_error | unknown reasoning effort '<value>'; expected off, low, medium or high | ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ ಪಟ್ಟಿಯ ಹೊರಗಿನ ಮೌಲ್ಯವನ್ನು, ಉದಾಹರಣೆಗೆ xhigh, ಪಡೆದಿದೆ. ನಿಮ್ಮ ಬ್ಯಾಲೆನ್ಸ್ನಿಂದ ಏನನ್ನೂ ಕಡಿತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ. |
422 | invalid_request_error | Failed to deserialize the JSON body into the target type: … | reasoning_effort string ಅಲ್ಲ. |
ದೃಢೀಕರಣ, ಬ್ಯಾಲೆನ್ಸ್ ಮತ್ತು ಸರ್ವರ್ ದೋಷಗಳು ಪ್ರತಿ ವಿನಂತಿಗೂ ಒಂದೇ ಆಗಿವೆ. ದೋಷ ನಿರ್ವಹಣೆ