POST /v1/responses serves the OpenAI Responses API. Clients that speak only that API, such as Codex CLI and the OpenAI Agents SDK, work with PrivateMind once you change their base URL and key. It runs on the same models, keys, budgets and rate limits as chat completions. PrivateMind stores no responses, so every request carries the whole conversation: see Conversations.
curl -s "https://api.privatemind.com/v1/responses" \
-H "Authorization: Bearer $PMIND_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "fast",
"instructions": "You are a concise assistant.",
"input": "Explain the CAP theorem.",
"max_output_tokens": 400,
"temperature": 0.2
}'from openai import OpenAI
client = OpenAI(
base_url="https://api.privatemind.com/v1",
api_key="PMIND...:abcdef...",
)
response = client.responses.create(
model="fast",
instructions="You are a concise assistant.",
input="Explain the CAP theorem.",
max_output_tokens=400,
temperature=0.2,
)
print(response.output_text)import OpenAI from 'openai';
const client = new OpenAI({
baseURL: 'https://api.privatemind.com/v1',
apiKey: process.env.PMIND_KEY,
});
const response = await client.responses.create({
model: 'fast',
instructions: 'You are a concise assistant.',
input: 'Explain the CAP theorem.',
max_output_tokens: 400,
temperature: 0.2,
});
console.log(response.output_text);The base URL ends in /v1, as for chat completions. The key goes in Authorization: Bearer or x-api-key (see Authentication).
On a model server registered with No translation, the request goes to your vLLM's own /v1/responses as sent, apart from the model name, and its answer comes back unchanged. What works then follows your vLLM's own Responses API support. The rest of this page describes the translated path.
Parameters
| Field | What happens |
|---|---|
model (required) |
Id or alias of a chat model from GET /v1/models |
input (required) |
One user message as a string, or an array of items. See Input |
instructions |
The system prompt, placed before any system or developer message in input |
stream |
When true, the response arrives as Responses API events. See Streaming |
max_output_tokens |
Maximum tokens to generate, reasoning included |
temperature, top_p |
Sampling controls |
tools |
Function tools, top-level or inside a namespace. Hosted tools are dropped and custom tools return 400. See Tools |
tool_choice |
auto, none, required, a named function, or allowed_tools. See Tool choice |
parallel_tool_calls |
false asks for at most one call per turn |
text.format |
text, json_object or json_schema. See Structured output |
reasoning.effort |
How much the model thinks. See Reasoning |
reasoning.summary |
Echoed in the response and otherwise unused. Reasoning text is returned whatever it says |
metadata |
Stored as usage tags and not sent to the model, with the same limits as on chat completions |
user, safety_identifier |
Passed to the model as the end-user id. When both are set, user is used |
store |
Accepted and ignored. Every response reports store: false |
previous_response_id, conversation, prompt, background: true |
400. See Conversations |
Other fields, such as include, truncation, service_tier, prompt_cache_key, max_tool_calls and text.verbosity, are accepted and ignored, so SDK upgrades do not break calls.
The whole request body, base64 images included, can be up to 32 MB. A larger body gets 413 with error.code request_too_large.
Input
input is a string or an array of items. An item with no type is a message, and a message with no role is from the user.
| Item | What happens |
|---|---|
message, role user |
content is a string or an array of parts: input_text, and input_image with image_url as a URL or a data URL plus an optional detail. input_file, input_audio, an input_image given only a file_id, and any other part return 400. See Vision for which models read images |
message, role assistant |
Its output_text parts are the model's earlier answer |
message, role system or developer |
At the start of input, joined to instructions in the system prompt. Later in the conversation, added to the user turn as text, because most chat templates refuse a second system turn |
reasoning |
The text of its content parts is passed back to the model as that turn's reasoning. summary and encrypted_content are dropped. See Reasoning items |
function_call |
A tool call the model made: call_id, name, namespace and arguments |
function_call_output |
The result for a call_id. output is a string or an array of parts: text parts are joined, images follow the results as a user turn, and other parts are dropped |
item_reference |
400: there is no stored item to point at |
| Any other item, such as a hosted tool's call record | Dropped |
Consecutive user messages are sent as one user turn, and consecutive reasoning, assistant message and function call items as one assistant turn. A function_call whose arguments is not valid JSON, such as a call cut short by max_output_tokens, reaches the model as {}. A reasoning item with nothing after it is dropped.
Tools
Function tools
Each tool has name, description and parameters at its top level:
curl -s "https://api.privatemind.com/v1/responses" \
-H "Authorization: Bearer $PMIND_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "fast",
"input": "What is the weather in Paris?",
"tools": [{
"type": "function",
"name": "get_weather",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"]
}
}]
}'A call comes back as a function_call item in output, after any reasoning:
{
"arguments": "{\"city\": \"Paris\"}",
"call_id": "chatcmpl-tool-83baf0e4cb6cf671",
"id": "fc_9be7f795ed7f4bb79a2eb3d4c8441737",
"name": "get_weather",
"status": "completed",
"type": "function_call"
}arguments is a string containing JSON. To answer, send the conversation again with every output item as it came back, followed by a function_call_output for each call_id:
{
"model": "fast",
"tools": [ ...the same tools... ],
"input": [
{ "role": "user", "content": "What is the weather in Paris?" },
{
"type": "reasoning",
"id": "rs_3b3bbd2a4a9945ad86c028dcd114d075",
"summary": [],
"content": [{ "type": "reasoning_text", "text": "User is asking for the weather in Paris. ..." }]
},
{
"type": "function_call",
"id": "fc_9be7f795ed7f4bb79a2eb3d4c8441737",
"call_id": "chatcmpl-tool-83baf0e4cb6cf671",
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}",
"status": "completed"
},
{
"type": "function_call_output",
"call_id": "chatcmpl-tool-83baf0e4cb6cf671",
"output": "{\"temp_c\": 18, \"conditions\": \"overcast\"}"
}
]
}A tool's parameters defaults to an empty object schema. Its strict flag is passed to the model server, but the model's engine decides whether calls follow the schema. Validate arguments before you act on them. See Tool use for the loop in Python.
Namespaces
A namespace groups function tools under a name. Calls to a tool inside one come back with its namespace as well as its name:
"tools": [
{
"type": "namespace",
"name": "tracker",
"description": "The issue tracker",
"tools": [{
"type": "function",
"name": "get",
"description": "Fetch an issue by key",
"parameters": { "type": "object", "properties": { "key": { "type": "string" } }, "required": ["key"] }
}]
},
{
"type": "namespace",
"name": "wiki",
"description": "The team wiki",
"tools": [{
"type": "function",
"name": "get",
"description": "Fetch a wiki page by title",
"parameters": { "type": "object", "properties": { "title": { "type": "string" } }, "required": ["title"] }
}]
}
]{
"arguments": "{\"key\": \"PM-12\"}",
"call_id": "chatcmpl-tool-a5ed80682540b678",
"id": "fc_ca25afe5bd174d2e8b2f1cfefcad4e87",
"name": "get",
"namespace": "tracker",
"status": "completed",
"type": "function_call"
}The model sees each tool under its own name. When two declared functions share a name, as the two get tools do here, each one inside a namespace is offered to the model as <namespace>__<name>. The call still comes back under the name and namespace you declared. Send function_call items back with their namespace so the history matches. A namespace's own description is echoed in the response but not sent to the model, so put what the model needs to know in each tool's description.
Limits
- At most 1024 function tools per request, counting those inside namespaces.
- Tool and namespace names are 1 to 128 characters.
- Two functions that would reach the model under the same name, such as two top-level tools called
get, return400. - Namespace descriptions are echoed up to 16 KB in total; past that, a namespace is echoed with an empty description.
Hosted and custom tools
Hosted tools are the ones OpenAI runs on its side, such as web_search, file_search, code_interpreter and mcp. PrivateMind drops them without an error, and the model answers without them.
Custom tools ("type": "custom"), which take free-form text, return 400, top-level or inside a namespace. Declare such a tool as a function with a string parameter.
Tool choice
| Value | Behaviour |
|---|---|
"auto" (default) |
The model decides whether to call a tool |
"none" |
The model does not call a tool |
"required" |
The model must call at least one tool |
{"type": "function", "name": "...", "namespace": "..."} |
The model must call this tool. namespace may be left out when no other function has the same name |
{"type": "allowed_tools", "mode": "auto", "tools": [...]} |
Only the listed functions are offered to the model, each given as {"type": "function", "name": ..., "namespace": ...}. mode is auto or required |
If tool_choice names a function that is not in tools, the request returns 400. Any other value, such as a hosted tool's choice, is treated as auto. With allowed_tools, the tools left out are not sent to the model.
Structured output
text.format asks for JSON:
{"type": "json_schema", "name": "...", "schema": {...}, "strict": true}holds the answer to the schema. Anamelonger than 64 characters is replaced byoutput.{"type": "json_object"}asks for any JSON object.{"type": "text"}, the default, is plain text.
from openai import OpenAI
from pydantic import BaseModel
client = OpenAI(base_url="https://api.privatemind.com/v1", api_key="PMIND...:abcdef...")
class Place(BaseModel):
city: str
country: str
response = client.responses.parse(
model="fast",
input="Extract the city and country: I flew into Lyon last week.",
text_format=Place,
)
print(response.output_parsed)With tools on offer
The model servers enforce a schema over a whole turn, which would leave the model no way to call a tool. So when tools are on offer, PrivateMind asks for the format in the system prompt and tool calls work as usual. It checks the final answer, the turn that ends without a tool call, against the format before returning it:
- If it matches, it is returned, with any code fence the model added taken off.
- If it does not match, PrivateMind runs the same turn again with the format enforced and tool calls off, and returns that answer. This second pass is billed as a request of its own (see Usage), and
outputkeeps the first pass's reasoning ahead of the second's. If the second pass can't run, for example because the key's budget is spent, a non-streaming request gets that error, such as402. A streaming one ends inresponse.failed. - When the service is busy, an answer can also skip the check and take the second pass.
- Some answers are never checked and always take the second pass: a very large answer, or one whose schema is very large or uses any of these:
- keywords beyond the common subset, such as
unevaluatedProperties,uniqueItems,patternPropertiesorif/then/else - a
formatother thandate-time,date,time,duration,email,hostname,ipv4,ipv6,uuidoruri - a
$refthat is recursive or points outside$defsordefinitions - a
$schemaother than draft 2020-12
- keywords beyond the common subset, such as
- Schemas that Python's
responses.parsebuilds from pydantic models stay inside the common subset, with a few exceptions. These include a field that is aset,bytesor adictkeyed by an enum orLiteral, and a pydantic model that refers to itself. - A first answer cut short by
max_output_tokensis returned asincomplete, unchecked. Ifmax_output_tokensleaves no room for a second pass, the first answer is returned asincompletetoo. - When your organization, or the whole service, already has too many large requests of this kind in flight, the request returns
429withcodetoo_many_requestsbefore anything runs. A key with too many requests in flight gets the same code, with or without tools. Retry after the 60 seconds in theretry-afterheader.
When streaming, reasoning and tool calls arrive as they are written. Text the model writes before a tool call arrives as a single delta when the call starts. The final message arrives once it has been checked, also as a single delta. If it fails the check and the turn runs again, the second pass's reasoning and message stream as they are written, after a response.in_progress event. Keepalives cover both waits.
"strict": false skips the check: the format is only asked for in the prompt. With tool_choice "required" or a named function, there is no final answer to check. When no tool is on offer, for example with tool_choice: "none" or only hosted tools declared, the schema is enforced from the start.
Reasoning
Effort
reasoning.effort maps onto the same levels as reasoning_effort on chat completions:
| You send | Effort |
|---|---|
| Nothing | The model's default |
"none" or "off" |
off |
"minimal" |
low |
"low", "medium", "high" |
That level |
"xhigh" or "max" |
max |
Any other value returns 400. A thinking-only model, such as Kimi K3.1 Pro or GLM 5.3, can't stop thinking, so it returns 400 for "none". Each model lists the levels it tells apart in capabilities.reasoning_effort_levels. On a model server you launched, the level reaches your vLLM as reasoning_effort, with off sent as none.
Reasoning items
A model that thinks returns a reasoning item before its answer, with its reasoning text in content as reasoning_text. summary is always empty.
curl -s "https://api.privatemind.com/v1/responses" \
-H "Authorization: Bearer $PMIND_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "reasoning",
"input": "What is 17 * 23?",
"reasoning": {"effort": "low"}
}'"output": [
{
"content": [{"text": "17*23 = 17*20+17*3 = 340+51 = 391.", "type": "reasoning_text"}],
"id": "rs_a541038aa64b430ca6c0f187922cd232",
"summary": [],
"type": "reasoning"
},
{
"content": [{"annotations": [], "logprobs": [], "text": "17 × 23 = **391**", "type": "output_text"}],
"id": "msg_48a8e034c0a54974aab724468489ac83",
"role": "assistant",
"status": "completed",
"type": "message"
}
]Send reasoning items back unchanged in later turns, as Codex and the SDKs do, and their content text is passed back to the model. Whether the model uses it depends on its chat template: many keep only the reasoning of the current tool loop. Reasoning is unfiltered model output: see Shared responsibility.
Response
{
"id": "resp_64a1d3adf74d4b5d9de35eec5e7f7e2e",
"object": "response",
"created_at": 1794876535,
"status": "completed",
"background": false,
"error": null,
"incomplete_details": null,
"instructions": "You are a concise assistant.",
"max_output_tokens": 400,
"metadata": {},
"model": "fast",
"parallel_tool_calls": true,
"reasoning": { "effort": null, "summary": null },
"temperature": 0.2,
"text": { "format": { "type": "text" } },
"tool_choice": "auto",
"tools": [],
"top_p": null,
"user": null,
"output": [
{
"content": [{ "text": "We need answer user: \"Explain the CAP theore ...", "type": "reasoning_text" }],
"id": "rs_e3affa4de1cc44ad8cac07979960fadc",
"summary": [],
"type": "reasoning"
},
{
"content": [{ "annotations": [], "logprobs": [], "text": "The **CAP theorem** says that a distributed data system ...", "type": "output_text" }],
"id": "msg_a8bb56ca60294ae1808b63bd4f17aab6",
"role": "assistant",
"status": "completed",
"type": "message"
}
],
"previous_response_id": null,
"store": false,
"truncation": "disabled",
"usage": {
"input_tokens": 65,
"input_tokens_details": { "cache_write_tokens": 0, "cached_tokens": 0 },
"output_tokens": 321,
"output_tokens_details": { "reasoning_tokens": 0 },
"total_tokens": 386
}
}output holds items in the order the model wrote them, usually reasoning, then the message, then any function_call items. There is no message item when the model wrote no text, or only whitespace.
The response repeats the parameters as they were applied:
model,instructions,max_output_tokens,temperature,top_pandmetadataas you sent them.toolsholds only the function tools offered to the model, in the shape you declared them. Hosted tools, and toolsallowed_toolsleft out, are not there.tool_choiceis the resolved form:"auto","none","required", a function with itsnamespace, orallowed_toolswith its mode and functions.text.formatis the format applied. Ajson_schemalarger than 64 KB is echoed with an emptyschema.reasoning.effortandreasoning.summaryas sent, when 16 characters or fewer, anduserwhen 256 characters or fewer; otherwisenull.backgroundis alwaysfalse,previous_response_idalwaysnull,storealwaysfalseandtruncationalways"disabled".
Status
status |
Meaning |
|---|---|
completed |
The turn ended normally, with an answer or with tool calls |
incomplete |
incomplete_details.reason is max_output_tokens (hit max_output_tokens or the context window) or content_filter. A message or function call cut off this way is marked incomplete. A cut-off function_call has partial arguments: don't run it. Raise max_output_tokens and retry |
failed |
Streaming only: the stream ended with response.failed, and error carries a code and message. See Streaming |
in_progress |
Only in the lifecycle events of a stream, before it ends |
Usage
input_tokens is the whole prompt, including the part read from the prompt cache, which input_tokens_details.cached_tokens reports. It matches prompt_tokens on chat completions. output_tokens includes reasoning, and output_tokens_details.reasoning_tokens is always 0. input_tokens_details.cache_write_tokens is 0 on the models PrivateMind runs.
When a final answer was generated again to match its text.format (With tools on offer), usage adds up both passes. Each pass is billed, and listed in usage, as a call of its own.
Streaming
With "stream": true the answer arrives as Responses API events, which the OpenAI SDKs and Codex parse natively.
curl -N "https://api.privatemind.com/v1/responses" \
-H "Authorization: Bearer $PMIND_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "fast", "input": "Write a haiku about TCP.", "stream": true}'Every event is a named event: line followed by its data:, and every data carries type and a sequence_number that starts at 0:
event: response.created
data: {"type":"response.created","sequence_number":0,"response":{"id":"resp_c62db3cb3a67498f9f435315c9ca8faa","object":"response","status":"in_progress",...,"output":[],"usage":null}}
event: response.in_progress
data: {"type":"response.in_progress","sequence_number":1,"response":{...}}
event: response.output_item.added
data: {"item":{"content":[],"id":"rs_45905d0065954ca6b3391cf6ac466f40","summary":[],"type":"reasoning"},"output_index":0,"sequence_number":2,"type":"response.output_item.added"}
event: response.content_part.added
data: {"content_index":0,"item_id":"rs_45905d0065954ca6b3391cf6ac466f40","output_index":0,"part":{"text":"","type":"reasoning_text"},"sequence_number":3,"type":"response.content_part.added"}
event: response.reasoning_text.delta
data: {"content_index":0,"delta":"We","item_id":"rs_45905d0065954ca6b3391cf6ac466f40","output_index":0,"sequence_number":4,"type":"response.reasoning_text.delta"}
...
event: response.output_item.added
data: {"item":{"content":[],"id":"msg_ad65c35f4eaa47a9a2432786c11e528a","role":"assistant","status":"in_progress","type":"message"},"output_index":1,"sequence_number":163,"type":"response.output_item.added"}
event: response.content_part.added
data: {"content_index":0,"item_id":"msg_ad65c35f4eaa47a9a2432786c11e528a","output_index":1,"part":{"annotations":[],"logprobs":[],"text":"","type":"output_text"},"sequence_number":164,"type":"response.content_part.added"}
event: response.output_text.delta
data: {"content_index":0,"delta":"\n\nThree-way","item_id":"msg_ad65c35f4eaa47a9a2432786c11e528a","logprobs":[],"output_index":1,"sequence_number":165,"type":"response.output_text.delta"}
...
event: response.output_text.done
data: {"content_index":0,"item_id":"msg_ad65c35f4eaa47a9a2432786c11e528a","logprobs":[],"output_index":1,"sequence_number":170,"text":"\n\nThree-way handshake forms\npackets in order arrive\nACKs confirm each byte","type":"response.output_text.done"}
event: response.content_part.done
data: {"content_index":0,"item_id":"msg_ad65c35f4eaa47a9a2432786c11e528a","output_index":1,"part":{...},"sequence_number":171,"type":"response.content_part.done"}
event: response.output_item.done
data: {"item":{...,"status":"completed","type":"message"},"output_index":1,"sequence_number":172,"type":"response.output_item.done"}
event: response.completed
data: {"type":"response.completed","sequence_number":173,"response":{"id":"resp_c62db3cb3a67498f9f435315c9ca8faa","object":"response","status":"completed",...,"usage":{"input_tokens":59,"input_tokens_details":{"cache_write_tokens":0,"cached_tokens":0},"output_tokens":442,"output_tokens_details":{"reasoning_tokens":0},"total_tokens":501}}}The events come in this order:
response.created, thenresponse.in_progress, both sent at once, before the model has produced anything.- For each output item, in the order the model writes them:
response.output_item.added.- For reasoning:
response.content_part.added,response.reasoning_text.deltaevents,response.reasoning_text.done,response.content_part.done. - For a message:
response.content_part.added,response.output_text.deltaevents,response.output_text.done,response.content_part.done. - For a tool call:
response.function_call_arguments.deltaevents, thenresponse.function_call_arguments.donewith thenameand fullarguments. response.output_item.donewith the finished item.
- One terminal event:
response.completed,response.incompleteorresponse.failed. It carries the whole response, withoutputandusage.
Items are written one at a time: one is done before the next is added.
Keepalives
While the model is silent, the stream carries : ping comments, as on chat completions. Some clients time out when no event arrives, so after 60 seconds without one, the next keepalive is a response.in_progress event carrying the response so far. : ping comments carry no data, and a repeated response.in_progress needs no handling.
They also run, at least every 15 seconds, while a final answer waits for its text.format check and before a second pass starts (see With tools on offer).
Failures
A stream that fails ends with response.failed, never with response.completed, so a cut-off answer is never presented as complete. The response in it has status: "failed" and an error with a code and a message.
- A torn stream: the model's stream breaks, or ends before the turn is finished.
error.codeisserver_error. - An interleaved tool call: the model goes back to a tool call after starting another item, which cannot be written as items.
error.codeisserver_error. - A request that does not fit the context window:
error.codeiscontext_length_exceeded, right afterresponse.in_progress, with the HTTP status still200. - A second pass that cannot run (With tools on offer): for example the key's budget runs out before it starts.
error.codeis that failure's code, such asbudget_exceeded.
event: response.failed
data: {"type":"response.failed","sequence_number":2,"response":{"id":"resp_05d3e0e0ca7f4621bc90251310cf3bad","object":"response","created_at":1794876636,"status":"failed","background":false,"error":{"code":"context_length_exceeded","message":"This model's maximum context length is 262144 tokens. However, you requested 262000 output tokens and your prompt contains at least 145 input tokens, ..."},...,"output":[],...,"usage":null}}The item being written when the stream failed is abandoned: it gets no response.output_item.done and is not in the response's output. Items finished before the failure stay in output. Don't run tool calls from a failed response. An interleaved tool call was already sent as done, with only the arguments the model wrote before it moved on. Retry the request instead. Errors before the stream starts, such as a 400, 401 or 429, come back as a normal JSON error with that status.
Errors
Errors use the OpenAI shape:
{
"error": {
"code": "invalid_request_error",
"message": "previous_response_id is not supported: responses are not stored here; send the whole conversation in input",
"type": "invalid_request_error"
}
}The status codes are those of Errors. A request this endpoint refuses returns 400 with type invalid_request_error and a message that says what to send instead. That covers stored state, custom tools, files, an unknown function in tool_choice and a bad reasoning.effort.
If the prompt and max_output_tokens together don't fit the model's context window, the request returns 400 with code context_length_exceeded. Responses clients look for this code to know when to compact a conversation:
{
"error": {
"code": "context_length_exceeded",
"message": "This model's maximum context length is 262144 tokens. However, you requested 262000 output tokens and your prompt contains at least 145 input tokens, for a total of at least 262145 tokens. Please reduce the length of the input prompt or the number of requested output tokens. (parameter=input_tokens, value=145)",
"param": null,
"type": "invalid_request_error"
}
}On a stream, the same error arrives as a response.failed event (see Failures). Other errors from the model server are relayed in the model server's shape, with code as a number. One example is a max_output_tokens that alone is above the model's context length.
Conversations
PrivateMind does not store responses, so there is nothing for an id to point at. These return 400:
previous_response_idconversationbackground: trueprompt(stored prompt templates); sendinstructionsandinputitem_referenceitems ininput
To carry a conversation, send all of it in input on every request, in this order:
- The earlier input items.
- Every item of each response's
output, as it came back. - The new items, such as
function_call_outputresults or the next user message.
Keep earlier items byte for byte the same and append new ones. The prompt cache then reads the shared start of the conversation, so a long history is not processed in full each time.
Codex, the OpenAI SDKs and the Agents SDK work this way when they are not given a previous_response_id. If your client sends item_reference items, set it to send the items themselves, which most clients do when store is off.
What is not supported
| Feature | Behaviour |
|---|---|
| Stored responses and conversations | 400. See Conversations |
Hosted tools (web_search, file_search, code_interpreter, mcp and the like) |
Not run; the model answers without them |
| Custom tools | 400; declare the tool as a function |
File and audio input (input_file, input_audio, input_image by file_id) |
400. Images work by URL or data URL |
| Vendor provider models served through another API, such as Claude through a provider card | 400 naming the dialect; use chat completions for those |
| Responses lines in a batch | Not accepted: a batch runs /v1/chat/completions or /v1/embeddings |
Only POST /v1/responses exists. These paths return 404:
GET /v1/responses/{id}andDELETE /v1/responses/{id}POST /v1/responses/{id}/cancelGET /v1/responses/{id}/input_itemsPOST /v1/responses/input_tokensPOST /v1/responses/compact
Where next
- OpenAI SDK for the Responses API from Python, TypeScript and the Agents SDK.
- Coding agents to point Codex CLI at PrivateMind.
- Tool use for a tool loop.
- Streaming for the event stream next to the other APIs.
- Errors for the error shape and status codes.