Responses API

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

ഏറ്റവും ചെറിയ റിക്വസ്റ്റ് ഒരു മോഡൽ ഐഡിയും ഒരു ടെക്സ്റ്റും ആണ്. നിങ്ങൾ ആവശ്യപ്പെടാത്ത പക്ഷം മറുപടി സ്ട്രീം ചെയ്യില്ല.

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

മറുപടി ഒരു റെസ്പോൺസ് ഒബ്ജക്റ്റ് ആണ്. അതിന്റെ 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-ഉം വേണം. പ്രയോഗിക്കുന്നത് കോളം ഒരു ഫീൽഡ് മറുപടിയെ മാറ്റുന്ന മോഡലുകളെ പേരുപറയുന്നു. ഹോസ്റ്റ് ചെയ്ത ഓപ്പൺ-വെയിറ്റ് മോഡലുകൾ മോഡൽ ലിസ്റ്റിലെ പന്ത്രണ്ട് ഐഡികളാണ്; 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 കുടുംബത്തിലെ ഐഡി ഉപയോഗിക്കുമ്പോൾ, നിർബന്ധമായും പാലിക്കേണ്ട നിർദ്ദേശങ്ങൾ user മെസേജിൽ വയ്ക്കുക.

മറുപടിയുടെ output-ലെ ഇനങ്ങൾ അതേപടി input-ലേക്ക് തിരികെ പോകാം: message, function_call ഇനങ്ങൾ വായിക്കും, reasoning ഇനങ്ങൾ ഒഴിവാക്കും.

കണ്ടന്റ് ഭാഗങ്ങൾ

Shannon ടിയറുകളിൽ ചിത്രങ്ങളും ഫയലുകളും input-ലെ അവസാനത്തെ user ഇനത്തിൽ നിന്ന് വായിക്കുന്നു. വലിപ്പങ്ങൾക്കും പരിധികൾക്കും സ്വന്തം പേജ് ഉണ്ട്. ചിത്രങ്ങളും ഫയലുകളും

നിർദ്ദേശങ്ങളും ഓപ്ഷനുകളുമുള്ള റിക്വസ്റ്റ്

ഈ റിക്വസ്റ്റ് നിർദ്ദേശങ്ങൾ, ഇൻപുട്ട് ഇനങ്ങളായി ഒരു സംഭാഷണം, ഔട്ട്പുട്ട് പരിധി, ടെമ്പറേച്ചർ, റീസണിംഗ് എഫർട്ട് എന്നിവ അയയ്ക്കുന്നു. ഇത് ഹോസ്റ്റ് ചെയ്ത ഓപ്പൺ-വെയിറ്റ് മോഡൽ ഉപയോഗിക്കുന്നു, അത് ഇവയെല്ലാം പ്രയോഗിക്കുന്നു.

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

റെസ്പോൺസ് ഒബ്ജക്റ്റ്

id, object, status, output, usage എന്നിവ എല്ലാ മറുപടിയിലും ഉണ്ട്. നിങ്ങളുടെ കോഡ് അവയെ അടിസ്ഥാനമാക്കി നിർമ്മിക്കുക.

ഔട്ട്പുട്ട് ഇനങ്ങൾ

OpenAI SDK-കൾ മെസേജിന്റെ ടെക്സ്റ്റ് നിങ്ങൾക്കായി response.output_text-ൽ ചേർത്തു തരുന്നു.

സ്ട്രീമിംഗ്

server-sent events-ന് stream true ആക്കുക. ഓരോ ഫ്രെയിമിലും ഇവന്റിന്റെ പേരുള്ള event: വരിയും JSON ഒബ്ജക്റ്റുള്ള data: വരിയും ഉണ്ട്; ഒബ്ജക്റ്റ് പേര് type-ൽ ആവർത്തിക്കുന്നു. ഡെൽറ്റകളെ 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-ൽ rate_limit_exceeded അല്ലെങ്കിൽ server_error എന്ന code-ഉം message-ഉം ഉണ്ട്.

ഹോസ്റ്റ് ചെയ്ത ഓപ്പൺ-വെയിറ്റ് മോഡലുകളിൽ പരാജയം code api_error-ഉം message-ഉം ഉള്ള error ഇവന്റാണ്. 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 സ്കീമ സാധാരണ JSON Schema കീവേഡുകളിലേക്ക് ചുരുക്കുന്നു: oneOf എന്നത് anyOf ആയി വായിക്കും, $ref, additionalProperties, const, default, title തുടങ്ങിയ കീവേഡുകൾ മോഡലിന് കൈമാറില്ല.

tool_choice മൂല്യങ്ങളായ required, പേരുള്ള ഫംഗ്ഷൻ എന്നിവ ഹോസ്റ്റ് ചെയ്ത ഓപ്പൺ-വെയിറ്റ് മോഡലുകൾ പ്രയോഗിക്കുന്നു.

ടൂൾ ലൂപ്പ് സ്വന്തം പേജിൽ പൂർണ്ണമായി വിവരിച്ചിട്ടുണ്ട്. ഫംഗ്ഷൻ കോളിംഗ്

ഘടനയുള്ള ഔട്ട്പുട്ട്

ഈ ഫോർമാറ്റ് ഘടനയുള്ള ഔട്ട്പുട്ട് text.format ആയി എഴുതുന്നു. സ്കീമ നേരിട്ട് format-ൽ, name-നും strict-നും അടുത്ത് ഇരിക്കുന്നു, Chat Completions-ലെ പോലെ json_schema അംഗത്തിന് കീഴിലല്ല.

• {"type": "json_object"} ഏതെങ്കിലും JSON ഒബ്ജക്റ്റ് ആവശ്യപ്പെടുന്നു.
• {"type": "json_schema", "name", "schema", "strict"} നിങ്ങളുടെ സ്കീമ പിന്തുടരുന്ന 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 ടൈപ്പിലുള്ള ഔട്ട്പുട്ട് ഇനമായി തിരികെ നൽകുന്നു. സ്ട്രീമിൽ അത് response.reasoning_summary_text.delta ഇവന്റുകളായി എത്തുന്നു.

ഹോസ്റ്റ് ചെയ്ത ഓപ്പൺ-വെയിറ്റ് മോഡലുകൾ reasoning.effort പ്രയോഗിക്കുന്നു: off, low, medium അല്ലെങ്കിൽ high, ഒന്നും അയച്ചില്ലെങ്കിൽ high. off റീസണിംഗ് ഇനം തിരികെ നൽകുന്നില്ല. ഇത് ഒബ്ജക്റ്റ് ആയി അയയ്ക്കുക; ഈ എൻഡ്‌പോയിന്റിൽ വെറും സ്ട്രിംഗ് വായിക്കില്ല.

എഫർട്ടുകൾ സ്വന്തം പേജിൽ വിവരിച്ചിട്ടുണ്ട്. റീസണിംഗ് എഫർട്ട്

ഔട്ട്പുട്ട് പരിധി

അയയ്ക്കാത്തപ്പോൾ 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-ഉം ഉണ്ടാകും. ഈ എൻഡ്‌പോയിന്റ് ഏറ്റവും കൂടുതൽ തിരികെ നൽകുന്നത് പട്ടിക കാണിക്കുന്നു. എന്ത് വീണ്ടും ശ്രമിക്കണം എന്നതുൾപ്പെടെയുള്ള പൂർണ്ണ ലിസ്റ്റിന് സ്വന്തം പേജ് ഉണ്ട്. എറർ ഹാൻഡ്ലിംഗ്