Responses API

POST https://api.shannon-ai.com/v1/responses

ಅತಿ ಚಿಕ್ಕ ವಿನಂತಿ ಎಂದರೆ ಮಾಡೆಲ್ id ಮತ್ತು ಒಂದು ಪಠ್ಯ. ನೀವು ಕೇಳದ ಹೊರತು ಉತ್ತರವನ್ನು stream ಮಾಡಲಾಗುವುದಿಲ್ಲ.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1",
)

response = client.responses.create(
    model="shannon-3",
    input="Say hello in one sentence.",
)

print(response.output_text)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.shannon-ai.com/v1",
});

const response = await client.responses.create({
  model: "shannon-3",
  input: "Say hello in one sentence.",
});

console.log(response.output_text);

curl https://api.shannon-ai.com/v1/responses \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-3",
    "input": "Say hello in one sentence."
  }'

ಉತ್ತರ ಒಂದು response ಆಬ್ಜೆಕ್ಟ್. ಅದರ output ಮಾಡೆಲ್ ರೀಸನಿಂಗ್ ಮಾಡಿದ್ದರೆ ರೀಸನಿಂಗ್ ಅನ್ನು, ಮತ್ತು ಸಂದೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ:

{
  "id": "resp_5f0c1e7a9b3d4c62a8e1f07d2b46c9a3",
  "object": "response",
  "created_at": 1791625200,
  "model": "shannon-3",
  "status": "completed",
  "error": null,
  "incomplete_details": null,
  "instructions": null,
  "metadata": {},
  "parallel_tool_calls": true,
  "temperature": null,
  "tool_choice": "auto",
  "tools": [],
  "top_p": null,
  "output": [
    {
      "id": "rs_8a2e6c1f4b7d4e03b9c5a1d70f3e2b64",
      "type": "reasoning",
      "summary": [
        {
          "type": "summary_text",
          "text": "The user wants a greeting in one sentence. Keep it short and friendly."
        }
      ]
    },
    {
      "id": "msg_1c7b9e3a5d2f4a86b0e4c8d19a6f7e25",
      "type": "message",
      "role": "assistant",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "text": "Hello, it is good to meet you.",
          "annotations": []
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 1184,
    "output_tokens": 46,
    "total_tokens": 1230
  }
}

ವಿನಂತಿ ಕ್ಷೇತ್ರಗಳು

ವಿನಂತಿಗೆ model ಮತ್ತು input ಬೇಕು. ಅನ್ವಯಿಸುವವರು ಕಾಲಮ್ ಫೀಲ್ಡ್ ಉತ್ತರವನ್ನು ಬದಲಾಯಿಸುವ ಮಾಡೆಲ್‌ಗಳನ್ನು ಹೆಸರಿಸುತ್ತದೆ. ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್‌ಗಳು ಮಾಡೆಲ್ ಪಟ್ಟಿಯ ಹನ್ನೆರಡು id ಗಳು; Shannon 3 ಕುಟುಂಬ ಎಂದರೆ shannon-3, shannon-3-pro, shannon-3.1 ಮತ್ತು shannon-3.1-pro. ಮಾಡೆಲ್‌ಗಳು ಮತ್ತು ಬೆಲೆ

previous_response_id, store, metadata, parallel_tool_calls, truncation, include, user ಮತ್ತು prompt_cache_key ಅನ್ನು ಈಗಿರುವ ಕ್ಲೈಂಟ್ ಕೋಡ್ ಬದಲಾವಣೆ ಇಲ್ಲದೆ ಚಲಿಸುವಂತೆ ಸ್ವೀಕರಿಸಲಾಗುತ್ತದೆ. ಅವು ಉತ್ತರವನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ. ಯಾವುದೇ ಸಂಭಾಷಣೆಯನ್ನು ಉಳಿಸದ ಕಾರಣ, ಮುಂದಿನ ವಿನಂತಿ ಹಿಂದಿನ ಟರ್ನ್‌ಗಳನ್ನು input ನಲ್ಲಿ ಹೊತ್ತಿರುತ್ತದೆ.

ಇನ್‌ಪುಟ್ ಐಟಂಗಳು

ಇನ್‌ಪುಟ್ ಐಟಂ ಎಂದರೆ role ಮತ್ತು content ಇರುವ ಸಂದೇಶ, ಅಥವಾ ಟೂಲ್ ಕರೆ ಅಥವಾ ಅದರ ಫಲಿತಾಂಶವನ್ನು ಹೊತ್ತ ವಿಧ-ಸಹಿತ ಐಟಂ. content ಒಂದು string ಅಥವಾ ಭಾಗಗಳ array.

ಸೂಚನೆಗಳನ್ನು instructions ಫೀಲ್ಡ್‌ನಲ್ಲಿ ಇಡಿ. Shannon 3 ಕುಟುಂಬದ id ಯೊಂದಿಗೆ, ಪಾಲಿಸಲೇಬೇಕಾದ ಸೂಚನೆಗಳನ್ನು user ಸಂದೇಶದಲ್ಲಿ ಇಡಿ.

ಉತ್ತರದ output ನ ಐಟಂಗಳನ್ನು ಅದೇ ರೂಪದಲ್ಲಿ input ಗೆ ಹಿಂತಿರುಗಿಸಬಹುದು: message ಮತ್ತು function_call ಐಟಂಗಳನ್ನು ಓದಲಾಗುತ್ತದೆ, reasoning ಐಟಂಗಳನ್ನು ಬಿಡಲಾಗುತ್ತದೆ.

ವಿಷಯ ಭಾಗಗಳು

Shannon ಟಿಯರ್‌ಗಳಲ್ಲಿ ಚಿತ್ರಗಳು ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು input ನ ಕೊನೆಯ user ಐಟಂನಿಂದ ಓದಲಾಗುತ್ತದೆ. ಗಾತ್ರಗಳು ಮತ್ತು ಮಿತಿಗಳಿಗೆ ತನ್ನದೇ ಪುಟವಿದೆ. ಚಿತ್ರಗಳು ಮತ್ತು ಫೈಲ್‌ಗಳು

ಸೂಚನೆಗಳು ಮತ್ತು ಆಯ್ಕೆಗಳೊಂದಿಗೆ ವಿನಂತಿ

ಈ ವಿನಂತಿ ಸೂಚನೆಗಳು, ಇನ್‌ಪುಟ್ ಐಟಂಗಳಾಗಿ ಸಂಭಾಷಣೆ, ಔಟ್‌ಪುಟ್ ಮಿತಿ, temperature ಮತ್ತು ರೀಸನಿಂಗ್ effort ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಇದು ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಅದು ಇವೆಲ್ಲವನ್ನೂ ಅನ್ವಯಿಸುತ್ತದೆ.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1",
)

response = client.responses.create(
    model="DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    instructions="You are a physics teacher. Answer in two sentences.",
    input=[
        {"role": "user", "content": "Why is the sky blue?"},
        {"role": "assistant", "content": "Air scatters blue light more than red light."},
        {"role": "user", "content": "And why are sunsets red?"},
    ],
    max_output_tokens=512,
    temperature=0.3,
    reasoning={"effort": "low"},
)

for item in response.output:
    if item.type == "reasoning":
        print("reasoning:", item.summary[0].text)
    elif item.type == "message":
        print("answer:", item.content[0].text)
print(response.usage)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.shannon-ai.com/v1",
});

const response = await client.responses.create({
  model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
  instructions: "You are a physics teacher. Answer in two sentences.",
  input: [
    { role: "user", content: "Why is the sky blue?" },
    { role: "assistant", content: "Air scatters blue light more than red light." },
    { role: "user", content: "And why are sunsets red?" },
  ],
  max_output_tokens: 512,
  temperature: 0.3,
  reasoning: { effort: "low" },
});

for (const item of response.output) {
  if (item.type === "reasoning") console.log("reasoning:", item.summary[0].text);
  if (item.type === "message") console.log("answer:", item.content[0].text);
}
console.log(response.usage);

curl https://api.shannon-ai.com/v1/responses \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
    "instructions": "You are a physics teacher. Answer in two sentences.",
    "input": [
      {"role": "user", "content": "Why is the sky blue?"},
      {"role": "assistant", "content": "Air scatters blue light more than red light."},
      {"role": "user", "content": "And why are sunsets red?"}
    ],
    "max_output_tokens": 512,
    "temperature": 0.3,
    "reasoning": {"effort": "low"}
  }'

ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್‌ನ ಉತ್ತರ id, object, model, created_at, status, output ಮತ್ತು usage ಹೊಂದಿದೆ. ಅದರ usage ಕ್ಯಾಶ್‌ನಿಂದ ಓದಿದ ಟೋಕನ್‌ಗಳು ಮತ್ತು ರೀಸನಿಂಗ್‌ಗೆ ಖರ್ಚಾದ ಟೋಕನ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ:

{
  "usage": {
    "input_tokens": 58,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens": 67,
    "output_tokens_details": {
      "reasoning_tokens": 19
    },
    "total_tokens": 125
  }
}

response ಆಬ್ಜೆಕ್ಟ್

id, object, status, output ಮತ್ತು usage ಪ್ರತಿ ಉತ್ತರದಲ್ಲೂ ಇರುತ್ತವೆ. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅವುಗಳ ಮೇಲೆ ಕಟ್ಟಿ.

ಔಟ್‌ಪುಟ್ ಐಟಂಗಳು

OpenAI SDK ಗಳು ಸಂದೇಶದ ಪಠ್ಯವನ್ನು ನಿಮಗಾಗಿ response.output_text ನಲ್ಲಿ ಜೋಡಿಸುತ್ತವೆ.

ಸ್ಟ್ರೀಮಿಂಗ್

server-sent events ಗಾಗಿ stream ಅನ್ನು true ಗೆ ಹೊಂದಿಸಿ. ಪ್ರತಿ ಫ್ರೇಮ್ ಈವೆಂಟ್‌ನ ಹೆಸರಿರುವ event: ಸಾಲು ಮತ್ತು JSON ಆಬ್ಜೆಕ್ಟ್ ಇರುವ data: ಸಾಲನ್ನು ಹೊಂದಿದೆ; ಆಬ್ಜೆಕ್ಟ್ ಹೆಸರನ್ನು type ನಲ್ಲಿ ಪುನರಾವರ್ತಿಸುತ್ತದೆ. deltas ಅನ್ನು output_index ಮೂಲಕ ಅವುಗಳ ಐಟಂಗೆ ಹೊಂದಿಸಿ.

OpenAI SDK ಯೊಂದಿಗೆ, ಈವೆಂಟ್‌ಗಳನ್ನು ಅವುಗಳ type ಮೂಲಕ ಓದಿ:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.shannon-ai.com/v1",
)

stream = client.responses.create(
    model="shannon-3",
    input="Explain server-sent events in three sentences.",
    stream=True,
)

for event in stream:
    kind = getattr(event, "type", "error")     # an event without a type is an error event
    if kind == "response.reasoning_summary_text.delta":
        pass                                   # a piece of reasoning: event.delta
    elif kind == "response.output_text.delta":
        print(event.delta, end="", flush=True)
    elif kind == "response.output_item.done" and event.item.type == "function_call":
        print("\ntool call:", event.item.name, event.item.arguments)
    elif kind == "response.completed":
        print("\n", event.response.usage)
    elif kind in ("response.failed", "error"):
        raise RuntimeError("the stream failed, send the request again")

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.shannon-ai.com/v1",
});

const stream = await client.responses.create({
  model: "shannon-3",
  input: "Explain server-sent events in three sentences.",
  stream: true,
});

for await (const event of stream) {
  if (event.type === "response.reasoning_summary_text.delta") {
    // a piece of reasoning: event.delta
  } else if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  } else if (event.type === "response.output_item.done" && event.item.type === "function_call") {
    console.log("\ntool call:", event.item.name, event.item.arguments);
  } else if (event.type === "response.completed") {
    console.log("\n", event.response.usage);
  } else if (event.type === "response.failed" || event.type === "error") {
    throw new Error("the stream failed, send the request again");
  }
}

curl -N https://api.shannon-ai.com/v1/responses \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "shannon-3",
    "input": "Explain server-sent events in three sentences.",
    "stream": true
  }'

ಈವೆಂಟ್‌ಗಳು ಈ ಕ್ರಮದಲ್ಲಿ ಬರುತ್ತವೆ. ರೀಸನಿಂಗ್, ಸಂದೇಶ ಮತ್ತು ಟೂಲ್ ಕರೆಗಳ ಗುಂಪುಗಳು ಉತ್ತರದಲ್ಲಿ ಅವು ಇದ್ದಾಗ ಮಾತ್ರ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.

event: response.created
data: {"type":"response.created","response":{"id":"resp_5f0c…","object":"response","status":"in_progress","output":[], …}}

event: response.in_progress
data: {"type":"response.in_progress","response":{"id":"resp_5f0c…","object":"response","status":"in_progress","output":[], …}}

event: response.output_item.added
data: {"type":"response.output_item.added","output_index":0,"item":{"id":"msg_1c7b…","type":"message","role":"assistant","status":"in_progress","content":[]}}

event: response.content_part.added
data: {"type":"response.content_part.added","output_index":0,"content_index":0,"part":{"type":"output_text","text":""}}

event: response.output_text.delta
data: {"type":"response.output_text.delta","output_index":0,"content_index":0,"delta":"Server-sent"}

event: response.output_text.delta
data: {"type":"response.output_text.delta","output_index":0,"content_index":0,"delta":" events let a server push text over one HTTP reply."}

event: response.output_text.done
data: {"type":"response.output_text.done","output_index":0,"content_index":0,"text":"Server-sent events let a server push text over one HTTP reply."}

event: response.content_part.done
data: {"type":"response.content_part.done","output_index":0,"content_index":0,"part":{"type":"output_text","text":"Server-sent events let a server push text over one HTTP reply."}}

event: response.output_item.done
data: {"type":"response.output_item.done","output_index":0,"item":{"id":"msg_1c7b…","type":"message","role":"assistant","status":"completed","content":[{"type":"output_text","text":"Server-sent events let a server push text over one HTTP reply.","annotations":[]}]}}

event: response.completed
data: {"type":"response.completed","response":{"id":"resp_5f0c…","object":"response","status":"completed","output":[…],"usage":{"input_tokens":1190,"output_tokens":18,"total_tokens":1208}, …}}

ವಿಫಲವಾಗುವ stream

Shannon ಟಿಯರ್‌ಗಳಲ್ಲಿ ವಿಫಲ ಉತ್ತರ response.completed ಬದಲು response.failed ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಅದರ response.status failed ಆಗಿದ್ದು response.error code (rate_limit_exceeded ಅಥವಾ server_error) ಮತ್ತು message ಹೊಂದಿರುತ್ತದೆ.

ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್‌ಗಳಲ್ಲಿ ವೈಫಲ್ಯ ಎಂದರೆ code api_error ಮತ್ತು message ಇರುವ error ಈವೆಂಟ್. response.completed ಆಗಲೂ ಅದರ ನಂತರ ಬರುತ್ತದೆ.

stream response.failed ಅಥವಾ error ಈವೆಂಟ್ ಹೊಂದಿದ್ದರೆ ಅದನ್ನು ವಿಫಲ ಎಂದು ಪರಿಗಣಿಸಿ, ಮತ್ತು ವಿನಂತಿಯನ್ನು ಮತ್ತೆ ಕಳುಹಿಸಿ.

ಟೂಲ್‌ಗಳು

ಟೂಲ್ ಎಂದರೆ ನಿಮ್ಮ ಕೋಡ್ ಚಲಾಯಿಸುವ ಫಂಕ್ಷನ್. ಅದನ್ನು tools ನಲ್ಲಿ ವಿವರಿಸಿ; ಮಾಡೆಲ್‌ಗೆ ಅದು ಬೇಕಾದಾಗ, ಉತ್ತರ ಸಂದೇಶದ ಬದಲು ಅಥವಾ ಅದರ ಜೊತೆಗೆ function_call ಐಟಂ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

tools ನಲ್ಲಿ ಟೂಲ್ ವ್ಯಾಖ್ಯಾನ:

[
  {
    "type": "function",
    "name": "get_weather",
    "description": "Current weather for a city.",
    "parameters": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string"
        }
      },
      "required": [
        "city"
      ]
    }
  }
]

ಅದನ್ನು ಕರೆಯುವ ಉತ್ತರದ output:

[
  {
    "id": "call_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
    "type": "function_call",
    "name": "get_weather",
    "call_id": "call_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
    "arguments": "{\"city\":\"Paris\"}"
  }
]

ಫಂಕ್ಷನ್ ಅನ್ನು ಚಲಾಯಿಸಿ, ನಂತರ ಕರೆ ಮತ್ತು ಅದರ ಫಲಿತಾಂಶವನ್ನು input ಗೆ ಸೇರಿಸಿ ವಿನಂತಿಯನ್ನು ಮತ್ತೆ ಕಳುಹಿಸಿ:

[
  {
    "role": "user",
    "content": "What is the weather in Paris?"
  },
  {
    "type": "function_call",
    "call_id": "call_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
    "name": "get_weather",
    "arguments": "{\"city\":\"Paris\"}"
  },
  {
    "type": "function_call_output",
    "call_id": "call_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
    "output": "{\"temperature_c\": 18, \"sky\": \"cloudy\"}"
  }
]

function ವಿಧದ ಟೂಲ್‌ಗಳನ್ನು ಮಾತ್ರ ಓದಲಾಗುತ್ತದೆ. shannon-1.6-*, shannon-2-* ಮತ್ತು shannon-coder-1 ನಲ್ಲಿ parameters schema ಅನ್ನು ಸಾಮಾನ್ಯ JSON Schema ಕೀವರ್ಡ್‌ಗಳಿಗೆ ಇಳಿಸಲಾಗುತ್ತದೆ: oneOf ಅನ್ನು anyOf ಎಂದು ಓದಲಾಗುತ್ತದೆ, ಮತ್ತು $ref, additionalProperties, const, default ಮತ್ತು title ನಂತಹ ಕೀವರ್ಡ್‌ಗಳನ್ನು ಮಾಡೆಲ್‌ಗೆ ನೀಡಲಾಗುವುದಿಲ್ಲ.

tool_choice ಮೌಲ್ಯಗಳಾದ required ಮತ್ತು ಹೆಸರಿಸಿದ ಫಂಕ್ಷನ್ ಅನ್ನು ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್‌ಗಳು ಅನ್ವಯಿಸುತ್ತವೆ.

ಟೂಲ್ ಲೂಪ್ ಅನ್ನು ಅದರ ಸ್ವಂತ ಪುಟದಲ್ಲಿ ಪೂರ್ಣವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ. ಫಂಕ್ಷನ್ ಕಾಲಿಂಗ್

ರಚನಾತ್ಮಕ ಔಟ್‌ಪುಟ್

ಈ ಫಾರ್ಮ್ಯಾಟ್ ರಚನಾತ್ಮಕ ಔಟ್‌ಪುಟ್ ಅನ್ನು text.format ಎಂದು ಬರೆಯುತ್ತದೆ. schema Chat Completions ನಲ್ಲಿರುವಂತೆ json_schema ಸದಸ್ಯದ ಅಡಿಯಲ್ಲಿ ಅಲ್ಲ, name ಮತ್ತು strict ಪಕ್ಕದಲ್ಲಿ ನೇರವಾಗಿ format ನಲ್ಲಿ ಇರುತ್ತದೆ.

• {"type": "json_object"} ಯಾವುದೇ JSON ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಕೇಳುತ್ತದೆ.
• {"type": "json_schema", "name", "schema", "strict"} ನಿಮ್ಮ schema ಅನ್ನು ಅನುಸರಿಸುವ JSON ಅನ್ನು ಕೇಳುತ್ತದೆ. ನೀವು ಬಿಟ್ಟರೆ strict true ಆಗಿರುತ್ತದೆ.

{
  "model": "shannon-1.6-lite",
  "input": "Extract the city and the date: 'The conference opens in Lisbon on 12 May 2027.'",
  "text": {
    "format": {
      "type": "json_schema",
      "name": "event",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "city": {
            "type": "string"
          },
          "date": {
            "type": "string",
            "description": "ISO 8601 date"
          }
        },
        "required": [
          "city",
          "date"
        ]
      }
    }
  }
}

JSON ಸಂದೇಶದ output_text ಭಾಗದಲ್ಲಿ ಪಠ್ಯವಾಗಿ ಬರುತ್ತದೆ; ಅದನ್ನು ನೀವೇ ಪಾರ್ಸ್ ಮಾಡಿ. ರಚನಾತ್ಮಕ ಔಟ್‌ಪುಟ್ ಇಲ್ಲದ ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್ 400 ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

{"city": "Lisbon", "date": "2027-05-12"}

ಯಾವ ಮಾಡೆಲ್ ಯಾವ ರೂಪವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ಅದರ ಸ್ವಂತ ಪುಟದಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ. ರಚಿತ ಔಟ್‌ಪುಟ್‌ಗಳು

ರೀಸನಿಂಗ್

ರೀಸನಿಂಗ್ ಮಾಡುವ ಮಾಡೆಲ್ ತನ್ನ ರೀಸನಿಂಗ್ ಅನ್ನು ಸಂದೇಶದ ಮೊದಲು reasoning ವಿಧದ ಔಟ್‌ಪುಟ್ ಐಟಂ ಆಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. stream ನಲ್ಲಿ ಅದು response.reasoning_summary_text.delta ಈವೆಂಟ್‌ಗಳಾಗಿ ಬರುತ್ತದೆ.

ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್‌ಗಳು reasoning.effort ಅನ್ನು ಅನ್ವಯಿಸುತ್ತವೆ: off, low, medium ಅಥವಾ high, ಏನನ್ನೂ ಕಳುಹಿಸದಿದ್ದರೆ high. off ರೀಸನಿಂಗ್ ಐಟಂ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ. ಅದನ್ನು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿ ಕಳುಹಿಸಿ; ಈ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ನಲ್ಲಿ ಬರಿಯ string ಅನ್ನು ಓದಲಾಗುವುದಿಲ್ಲ.

effort ಗಳನ್ನು ಅವುಗಳ ಸ್ವಂತ ಪುಟದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. ರೀಸನಿಂಗ್ ಪ್ರಯತ್ನ

ಔಟ್‌ಪುಟ್ ಮಿತಿ

ನೀವು ಕಳುಹಿಸದಿದ್ದರೆ max_output_tokens 4,096. ವಿನಂತಿ ಆರಂಭವಾದಾಗ ನಿಮ್ಮ ಬ್ಯಾಲೆನ್ಸ್‌ನಿಂದ ಮೀಸಲಿಡುವ ಟೋಕನ್‌ಗಳ ಸಂಖ್ಯೆ ಇದು; ಉತ್ತರ ಪೂರ್ಣಗೊಂಡಾಗ, ಆ ಮೊತ್ತವನ್ನು ವಿನಂತಿ ಬಳಸಿದ್ದರಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ. ನಿಮ್ಮ ಉಳಿದ ಬ್ಯಾಲೆನ್ಸ್‌ಗೆ ಹೊಂದದ ಮೌಲ್ಯಕ್ಕೆ 429 Quota exceeded ಹಿಂತಿರುಗುತ್ತದೆ.

ಇದು shannon-1.6-*, shannon-2-* ಮತ್ತು shannon-coder-1 ನಲ್ಲಿ ಉತ್ತರದ ಉದ್ದವನ್ನು, ಮತ್ತು ಹೋಸ್ಟ್ ಮಾಡಿದ ಓಪನ್-ವೇಟ್ ಮಾಡೆಲ್‌ಗಳಲ್ಲಿ ಉತ್ತರ ಪಠ್ಯದ ಉದ್ದವನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ.

ಈ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ನಲ್ಲಿ shannon-coder-1 ಗೆ, ಇತರ ಪ್ರತಿ ಮಾಡೆಲ್‌ನಂತೆ, ನಿಮ್ಮ ಬ್ಯಾಲೆನ್ಸ್‌ನಿಂದ ಟೋಕನ್‌ಗಳಲ್ಲಿ ಶುಲ್ಕ ವಿಧಿಸಲಾಗುತ್ತದೆ.

ವಿನಂತಿ ಬಾಡಿ 32 MiB ವರೆಗೆ ಇರಬಹುದು. ಮಿತಿಗಳು ಮತ್ತು ಬ್ಯಾಲೆನ್ಸ್

ದೋಷಗಳು

ದೋಷಗಳು OpenAI ದೋಷ ಬಾಡಿಯನ್ನು ಬಳಸುತ್ತವೆ: type ಮತ್ತು message ಇರುವ error ಆಬ್ಜೆಕ್ಟ್; ಕೆಲವು null ಮೌಲ್ಯದ code ಮತ್ತು param ಅನ್ನೂ ಹೊತ್ತಿರುತ್ತವೆ. ಕೋಷ್ಟಕ ಈ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಹೆಚ್ಚಾಗಿ ಹಿಂತಿರುಗಿಸುವುದನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಯಾವುದನ್ನು ಮರುಪ್ರಯತ್ನಿಸಬೇಕು ಎಂಬುದರೊಂದಿಗೆ ಪೂರ್ಣ ಪಟ್ಟಿಗೆ ತನ್ನದೇ ಪುಟವಿದೆ. ದೋಷ ನಿರ್ವಹಣೆ