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 ઓબ્જેક્ટ છે. મોડેલે રીઝનિંગ કર્યું હોય તો તેનું 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 જોઈએ. કોણ લાગુ કરે છે કૉલમ એ મોડેલ્સ જણાવે છે જેમાં ફીલ્ડ જવાબ બદલે છે. હોસ્ટેડ open-weight મોડેલ્સ મોડેલ યાદીના બાર 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 સ્ટ્રિંગ છે અથવા ભાગોની એરે.

સૂચનાઓ instructions ફીલ્ડમાં મૂકો. Shannon 3 ફેમિલી id સાથે, જે સૂચનાઓ પળાવી જ જોઈએ તે user મેસેજમાં મૂકો.

જવાબના output ની આઇટમ્સ જેમ છે તેમ input માં પાછી જઈ શકે: message અને function_call આઇટમ્સ વંચાય છે, reasoning આઇટમ્સ છોડી દેવાય છે.

કન્ટેન્ટ ભાગો

Shannon ટિયર પર ઇમેજ અને ફાઇલ્સ input ની છેલ્લી user આઇટમમાંથી વંચાય છે. કદ અને મર્યાદાઓનું પોતાનું પેજ છે. ઇમેજ અને ફાઇલ્સ

સૂચનાઓ અને વિકલ્પો સાથેની રિક્વેસ્ટ

આ રિક્વેસ્ટ સૂચનાઓ, ઇનપુટ આઇટમ્સ તરીકે વાતચીત, આઉટપુટ મર્યાદા, temperature અને રીઝનિંગ 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 ઓબ્જેક્ટ

id, object, status, output અને usage દરેક જવાબમાં હોય છે. તમારો કોડ તેમના પર બનાવો.

આઉટપુટ આઇટમ્સ

OpenAI SDKs મેસેજનો ટેક્સ્ટ તમારા માટે response.output_text માં જોડી આપે છે.

Streaming

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}, …}}

નિષ્ફળ થતો સ્ટ્રીમ

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 મોડેલ્સ લાગુ કરે છે.

ટૂલ લૂપનું પૂરું વર્ણન તેના પોતાના પેજ પર છે. ફંક્શન કોલિંગ

સ્ટ્રક્ચર્ડ આઉટપુટ

આ ફોર્મેટ સ્ટ્રક્ચર્ડ આઉટપુટને text.format તરીકે લખે છે. schema સીધું format માં, name અને strict ની બાજુમાં હોય છે, Chat Completions ની જેમ json_schema સભ્ય હેઠળ નહીં.

• {"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 ભાગમાં ટેક્સ્ટ તરીકે આવે છે; તેને જાતે પાર્સ કરો. સ્ટ્રક્ચર્ડ આઉટપુટ વિનાનું હોસ્ટેડ open-weight મોડેલ 400 પાછું આપે છે.

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

કયું મોડેલ કયું સ્વરૂપ લે છે તે તેના પોતાના પેજ પર આપેલું છે. રચિત આઉટપુટ્સ

Reasoning

રીઝનિંગ કરતું મોડેલ તેનું રીઝનિંગ મેસેજ પહેલાં reasoning પ્રકારની આઉટપુટ આઇટમ તરીકે પાછું આપે છે. સ્ટ્રીમમાં તે response.reasoning_summary_text.delta ઇવેન્ટ્સ તરીકે આવે છે.

હોસ્ટેડ open-weight મોડેલ્સ reasoning.effort લાગુ કરે છે: off, low, medium અથવા high, અને તમે કંઈ ન મોકલો તો high. off હોય તો રીઝનિંગ આઇટમ પાછી આવતી નથી. તેને ઓબ્જેક્ટ તરીકે મોકલો; આ એન્ડપોઇન્ટ પર ફક્ત સ્ટ્રિંગ વાંચવામાં આવતી નથી.

effort નું વર્ણન તેમના પોતાના પેજ પર છે. Reasoning effort

આઉટપુટ મર્યાદા

તમે max_output_tokens ન મોકલો ત્યારે તે 4,096 છે. રિક્વેસ્ટ શરૂ થાય ત્યારે તમારા બેલેન્સમાંથી અલગ રખાતા ટોકન્સની સંખ્યા તે છે; જવાબ પૂરો થાય ત્યારે તે રકમ રિક્વેસ્ટે વાપરેલી રકમથી બદલાય છે. તમારા બાકી બેલેન્સમાં ન સમાતી કિંમત 429 Quota exceeded પાછું આપે છે.

તે shannon-1.6-*, shannon-2-* અને shannon-coder-1 પર જવાબની લંબાઈ, અને હોસ્ટેડ open-weight મોડેલ્સ પર જવાબ ટેક્સ્ટની લંબાઈ મર્યાદિત કરે છે.

આ એન્ડપોઇન્ટ પર shannon-coder-1 અન્ય દરેક મોડેલની જેમ તમારા બેલેન્સના ટોકન્સમાં ચાર્જ થાય છે.

રિક્વેસ્ટ બોડી 32 MiB સુધીનો હોઈ શકે. મર્યાદાઓ અને બેલેન્સ

એરર્સ

એરર્સ OpenAI એરર બોડી વાપરે છે: type અને message સાથેનો error ઓબ્જેક્ટ; કેટલાક code અને કિંમત null સાથે param પણ લઈ જાય છે. ટેબલ આ એન્ડપોઇન્ટ સૌથી વધુ વાર શું પાછું આપે છે તે બતાવે છે. કઈ એરર ફરી અજમાવવી તે સાથેની સંપૂર્ણ યાદીનું પોતાનું પેજ છે. ભૂલ સંભાળ