Responses API

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

ਸਭ ਤੋਂ ਛੋਟੀ ਰਿਕੁਐਸਟ ਇੱਕ ਮਾਡਲ id ਅਤੇ ਇੱਕ ਟੈਕਸਟ ਹੈ। ਜਵਾਬ ਸਟ੍ਰੀਮ ਨਹੀਂ ਹੁੰਦਾ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਇਸਦੀ ਮੰਗ ਨਾ ਕਰੋ।

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 object ਹੈ। ਇਸਦੇ 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 ਚਾਹੀਦੇ ਹਨ। Applied by ਕਾਲਮ ਉਹ ਮਾਡਲ ਦੱਸਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਉੱਤੇ ਕੋਈ ਫੀਲਡ ਜਵਾਬ ਬਦਲਦਾ ਹੈ। ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਮਾਡਲ ਸੂਚੀ ਦੀਆਂ ਬਾਰਾਂ ids ਹਨ; 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 ਇਸ ਲਈ ਸਵੀਕਾਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਕਿ ਮੌਜੂਦਾ ਕਲਾਇੰਟ ਕੋਡ ਬਿਨਾਂ ਬਦਲਾਅ ਦੇ ਚੱਲੇ। ਉਹ ਜਵਾਬ ਨਹੀਂ ਬਦਲਦੇ। ਕਿਉਂਕਿ ਕੋਈ ਗੱਲਬਾਤ ਸਟੋਰ ਨਹੀਂ ਹੁੰਦੀ, ਅਗਲੀ ਰਿਕੁਐਸਟ ਪਿਛਲੇ turns ਨੂੰ input ਵਿੱਚ ਲੈ ਕੇ ਜਾਂਦੀ ਹੈ।

ਇਨਪੁਟ ਆਈਟਮਾਂ

ਇਨਪੁਟ ਆਈਟਮ ਜਾਂ ਤਾਂ role ਅਤੇ content ਵਾਲਾ ਇੱਕ message ਹੈ, ਜਾਂ ਕਿਸਮ ਵਾਲੀ ਆਈਟਮ ਜੋ ਟੂਲ ਕਾਲ ਜਾਂ ਉਸ ਦਾ ਨਤੀਜਾ ਲੈ ਕੇ ਜਾਂਦੀ ਹੈ। content ਇੱਕ string ਜਾਂ parts ਦਾ array ਹੈ।

ਹਦਾਇਤਾਂ ਨੂੰ instructions ਫੀਲਡ ਵਿੱਚ ਪਾਓ। Shannon 3 ਪਰਿਵਾਰ ਦੀ id ਨਾਲ, ਜੋ ਹਦਾਇਤਾਂ ਲਾਜ਼ਮੀ ਹਨ ਉਨ੍ਹਾਂ ਨੂੰ user message ਵਿੱਚ ਪਾਓ।

ਜਵਾਬ ਦੇ output ਦੀਆਂ ਆਈਟਮਾਂ ਜਿਉਂ ਦੀਆਂ ਤਿਉਂ input ਵਿੱਚ ਵਾਪਸ ਜਾ ਸਕਦੀਆਂ ਹਨ: message ਅਤੇ function_call ਆਈਟਮਾਂ ਪੜ੍ਹੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, reasoning ਆਈਟਮਾਂ ਛੱਡ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

Content parts

Shannon ਟੀਅਰਾਂ ਉੱਤੇ ਇਮੇਜਾਂ ਅਤੇ ਫਾਈਲਾਂ input ਦੀ ਆਖਰੀ user ਆਈਟਮ ਤੋਂ ਪੜ੍ਹੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਆਕਾਰ ਅਤੇ ਸੀਮਾਵਾਂ ਦਾ ਆਪਣਾ ਪੰਨਾ ਹੈ। ਇਮੇਜਾਂ ਅਤੇ ਫਾਈਲਾਂ

ਹਦਾਇਤਾਂ ਅਤੇ ਵਿਕਲਪਾਂ ਵਾਲੀ ਰਿਕੁਐਸਟ

ਇਹ ਰਿਕੁਐਸਟ instructions, ਇਨਪੁਟ ਆਈਟਮਾਂ ਵਜੋਂ ਇੱਕ ਗੱਲਬਾਤ, ਆਉਟਪੁੱਟ ਦੀ ਸੀਮਾ, ਇੱਕ temperature ਅਤੇ ਇੱਕ reasoning effort ਭੇਜਦੀ ਹੈ। ਇਹ ਇੱਕ ਹੋਸਟ ਕੀਤਾ open-weight ਮਾਡਲ ਵਰਤਦੀ ਹੈ, ਜੋ ਇਨ੍ਹਾਂ ਸਭ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।

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

ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਦੇ ਜਵਾਬ ਵਿੱਚ 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 object

id, object, status, output ਅਤੇ usage ਹਰ ਜਵਾਬ ਵਿੱਚ ਹੁੰਦੇ ਹਨ। ਆਪਣਾ ਕੋਡ ਇਨ੍ਹਾਂ ਉੱਤੇ ਬਣਾਓ।

ਆਉਟਪੁੱਟ ਆਈਟਮ

OpenAI SDK ਸੰਦੇਸ਼ ਦਾ ਟੈਕਸਟ ਤੁਹਾਡੇ ਲਈ response.output_text ਵਿੱਚ ਜੋੜ ਦਿੰਦੇ ਹਨ।

ਸਟ੍ਰੀਮਿੰਗ

server-sent events ਲਈ stream ਨੂੰ true ਕਰੋ। ਹਰ ਫਰੇਮ ਵਿੱਚ ਇਵੈਂਟ ਦੇ ਨਾਮ ਵਾਲੀ ਇੱਕ event: ਲਾਈਨ ਅਤੇ JSON object ਵਾਲੀ ਇੱਕ data: ਲਾਈਨ ਹੁੰਦੀ ਹੈ; object 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}, …}}

ਅਸਫਲ ਹੋਣ ਵਾਲੀ ਸਟ੍ਰੀਮ

Shannon ਟੀਅਰਾਂ ਉੱਤੇ ਅਸਫਲ ਜਵਾਬ response.completed ਦੀ ਥਾਂ response.failed ਨਾਲ ਖਤਮ ਹੁੰਦਾ ਹੈ। ਇਸਦਾ response.status failed ਹੁੰਦਾ ਹੈ ਅਤੇ response.error ਵਿੱਚ ਇੱਕ code, ਜੋ rate_limit_exceeded ਜਾਂ server_error ਹੈ, ਅਤੇ ਇੱਕ message ਹੁੰਦਾ ਹੈ।

ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਅਸਫਲਤਾ ਇੱਕ error ਇਵੈਂਟ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ code api_error ਅਤੇ ਇੱਕ message ਹੁੰਦਾ ਹੈ। ਇਸਦੇ ਬਾਅਦ ਵੀ response.completed ਆਉਂਦਾ ਹੈ।

ਜਦੋਂ ਸਟ੍ਰੀਮ ਵਿੱਚ 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 ਅਤੇ ਨਾਮ ਦੇ ਕੇ ਚੁਣਿਆ ਫੰਕਸ਼ਨ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ ਲਾਗੂ ਕਰਦੇ ਹਨ।

ਟੂਲ ਲੂਪ ਦਾ ਪੂਰਾ ਵੇਰਵਾ ਉਸਦੇ ਆਪਣੇ ਪੰਨੇ ਉੱਤੇ ਹੈ। ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ

ਸੰਗਠਿਤ ਆਉਟਪੁੱਟ

ਇਹ ਫਾਰਮੈਟ structured output ਨੂੰ text.format ਵਜੋਂ ਲਿਖਦਾ ਹੈ। schema ਸਿੱਧੀ format ਵਿੱਚ, name ਅਤੇ strict ਦੇ ਕੋਲ ਹੁੰਦੀ ਹੈ, json_schema ਮੈਂਬਰ ਹੇਠ ਨਹੀਂ ਜਿਵੇਂ Chat Completions ਵਿੱਚ ਹੁੰਦੀ ਹੈ।

• {"type": "json_object"} ਕਿਸੇ ਵੀ JSON object ਦੀ ਮੰਗ ਕਰਦਾ ਹੈ।
• {"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 ਹਿੱਸੇ ਵਿੱਚ ਟੈਕਸਟ ਵਜੋਂ ਆਉਂਦਾ ਹੈ; ਇਸਨੂੰ ਆਪ parse ਕਰੋ। structured output ਤੋਂ ਬਿਨਾਂ ਹੋਸਟ ਕੀਤਾ open-weight ਮਾਡਲ 400 ਵਾਪਸ ਕਰਦਾ ਹੈ।

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

ਕਿਹੜਾ ਮਾਡਲ ਕਿਹੜਾ ਰੂਪ ਲੈਂਦਾ ਹੈ, ਇਹ ਉਸਦੇ ਆਪਣੇ ਪੰਨੇ ਉੱਤੇ ਦਿੱਤਾ ਹੈ। ਸਟ੍ਰਕਚਰਡ ਆਉਟਪੁੱਟਸ

ਰੀਜ਼ਨਿੰਗ

ਰੀਜ਼ਨਿੰਗ ਕਰਨ ਵਾਲਾ ਮਾਡਲ ਆਪਣੀ ਰੀਜ਼ਨਿੰਗ reasoning ਕਿਸਮ ਦੀ ਆਉਟਪੁੱਟ ਆਈਟਮ ਵਜੋਂ, ਸੰਦੇਸ਼ ਤੋਂ ਪਹਿਲਾਂ, ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਟ੍ਰੀਮ ਵਿੱਚ ਇਹ response.reasoning_summary_text.delta ਇਵੈਂਟਾਂ ਵਜੋਂ ਆਉਂਦੀ ਹੈ।

ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲ reasoning.effort ਲਾਗੂ ਕਰਦੇ ਹਨ: off, low, medium ਜਾਂ high; ਕੁਝ ਨਾ ਭੇਜਣ ਉੱਤੇ high ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। off ਕੋਈ reasoning ਆਈਟਮ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। ਇਸਨੂੰ object ਵਜੋਂ ਭੇਜੋ; ਇਸ endpoint ਉੱਤੇ ਸਿਰਫ਼ string ਪੜ੍ਹੀ ਨਹੀਂ ਜਾਂਦੀ।

effort ਦੇ ਪੱਧਰਾਂ ਦਾ ਵੇਰਵਾ ਉਨ੍ਹਾਂ ਦੇ ਆਪਣੇ ਪੰਨੇ ਉੱਤੇ ਹੈ। ਰੀਜ਼ਨਿੰਗ effort

ਆਉਟਪੁੱਟ ਦੀ ਸੀਮਾ

ਜਦੋਂ ਤੁਸੀਂ max_output_tokens ਨਾ ਭੇਜੋ ਤਾਂ ਇਹ 4,096 ਹੁੰਦਾ ਹੈ। ਇਹ ਉਹ tokens ਦੀ ਗਿਣਤੀ ਹੈ ਜੋ ਰਿਕੁਐਸਟ ਸ਼ੁਰੂ ਹੋਣ ਸਮੇਂ ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਵਿੱਚੋਂ ਵੱਖ ਰੱਖੇ ਜਾਂਦੇ ਹਨ; ਜਵਾਬ ਪੂਰਾ ਹੋਣ ਉੱਤੇ ਉਹ ਰਕਮ ਉਸ ਨਾਲ ਬਦਲ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਰਿਕੁਐਸਟ ਨੇ ਵਰਤਿਆ। ਜੋ ਮੁੱਲ ਤੁਹਾਡੇ ਬਾਕੀ ਬੈਲੇਂਸ ਵਿੱਚ ਨਹੀਂ ਸਮਾਉਂਦਾ ਉਹ 429 Quota exceeded ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਇਹ shannon-1.6-*, shannon-2-* ਅਤੇ shannon-coder-1 ਉੱਤੇ ਜਵਾਬ ਦੀ ਲੰਬਾਈ ਨੂੰ, ਅਤੇ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਉੱਤੇ ਜਵਾਬ ਦੇ ਟੈਕਸਟ ਦੀ ਲੰਬਾਈ ਨੂੰ ਸੀਮਤ ਕਰਦਾ ਹੈ।

ਇਸ endpoint ਉੱਤੇ shannon-coder-1 ਦਾ ਚਾਰਜ ਹਰ ਹੋਰ ਮਾਡਲ ਵਾਂਗ ਤੁਹਾਡੇ ਬੈਲੇਂਸ ਦੇ tokens ਵਿੱਚ ਲੱਗਦਾ ਹੈ।

ਰਿਕੁਐਸਟ body 32 MiB ਤੱਕ ਹੋ ਸਕਦੀ ਹੈ। ਸੀਮਾਵਾਂ ਅਤੇ ਬੈਲੇਂਸ

ਗਲਤੀਆਂ

ਗਲਤੀਆਂ OpenAI ਦੀ ਗਲਤੀ body ਵਰਤਦੀਆਂ ਹਨ: type ਅਤੇ message ਵਾਲਾ error object; ਕੁਝ ਵਿੱਚ ਮੁੱਲ null ਨਾਲ code ਅਤੇ param ਵੀ ਹੁੰਦੇ ਹਨ। ਟੇਬਲ ਉਹ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ ਜੋ ਇਹ endpoint ਸਭ ਤੋਂ ਵੱਧ ਵਾਰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਪੂਰੀ ਸੂਚੀ, ਇਸ ਸਮੇਤ ਕਿ ਕੀ ਦੁਬਾਰਾ ਅਜ਼ਮਾਉਣਾ ਹੈ, ਦਾ ਆਪਣਾ ਪੰਨਾ ਹੈ। ਗਲਤੀਆਂ