OpenAI Responses

Use Prism through the OpenAI Responses API wire format.

Prism exposes a stateless OpenAI Responses-compatible endpoint. Use it with OpenAI SDK clients that call client.responses.create().

Create a response

POST https://api.prisminference.com/v1/responses

TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.PRISM_API_KEY,
  baseURL: "https://api.prisminference.com/v1",
});

const response = await client.responses.create({
  model: "prism/deepseek-v4.1-flash",
  instructions: "You are a senior TypeScript engineer.",
  input: "Write a bounded concurrency helper.",
  store: false,
});

console.log(response.output_text);

Assistant text is available in output_text and in the output message item. Function calls are returned as function_call output items. Free-form custom tool calls are returned as custom_tool_call output items.

Body parameters

Field	Type	Required	Description
model	string	Yes	A supported Prism model ID.
input	string or item[]	Yes	Text, images, messages, and prior function or custom tool items.
instructions	string	No	System or developer instructions.
stream	boolean	No	Return Responses API Server-Sent Events.
max_output_tokens	integer	No	Maximum generated tokens, including reasoning tokens.
tools	tool[]	No	Function, custom, and namespace tools available to the model.
tool_choice	string or object	No	Control whether and which supported tool is called.
parallel_tool_calls	boolean	No	Allow independent function calls in one turn.
text.format	object	No	Request text, JSON object, or JSON Schema output.
reasoning.effort	string	No	none, low, medium, or high. On at high when unset.
temperature	number	No	Sampling temperature from 0 to 2.
top_p	number	No	Nucleus sampling probability from 0 to 1.
store	boolean	No	true is unsupported; Prism does not persist response content.

Reasoning is on by default and appears as a reasoning output item before the message. Send reasoning: { "effort": "none" } to skip it and receive answer text as the first output. See Chat Completions reasoning for the effort levels.

Image input

For prism/deepseek-v4.1-flash, include an input_image part in a user message. image_url accepts a base64 data URL:

{
  "model": "prism/deepseek-v4.1-flash",
  "input": [
    {
      "role": "user",
      "content": [
        { "type": "input_text", "text": "What is in this image?" },
        {
          "type": "input_image",
          "image_url": "data:image/png;base64,iVBORw0KGgo...",
          "detail": "auto"
        }
      ]
    }
  ]
}

JPEG, PNG, GIF, and WebP are supported. Remote URLs and OpenAI file IDs are not accepted, so send image bytes through image_url. prism/deepseek-v4-flash is text-only, and the complete request must fit within the 4 MiB request limit.

Continue a tool loop

Return prior output items explicitly in the next request:

const call = response.output.find((item) => item.type === "function_call");

if (call?.type === "function_call") {
  const result = await runFunction(call.name, JSON.parse(call.arguments));

  const final = await client.responses.create({
    model: "prism/deepseek-v4.1-flash",
    input: [
      { role: "user", content: "What is the weather in San Francisco?" },
      call,
      {
        type: "function_call_output",
        call_id: call.call_id,
        output: JSON.stringify(result),
      },
    ],
    tools,
    store: false,
  });

  console.log(final.output_text);
}

Use a custom tool

Custom tools accept free-form string input instead of JSON arguments. Prism supports unconstrained text and lark or regex grammar declarations:

{
  "type": "custom",
  "name": "apply_patch",
  "description": "Apply a patch to files.",
  "format": {
    "type": "grammar",
    "syntax": "lark",
    "definition": "start: patch"
  }
}

Prism presents the custom tool to the provider as a function with one string field named input. Provider calls are converted back to custom_tool_call items:

{
  "type": "custom_tool_call",
  "call_id": "call_123",
  "name": "apply_patch",
  "input": "*** Begin Patch\n*** End Patch"
}

Return the result in the next request as a custom_tool_call_output item with the same call_id. Keep the tool declaration in each stateless request.

Grammar definitions are included as model instructions but are not enforced during provider decoding. Validate custom-tool input before executing it.

Use namespace tools

Namespaces group related function or custom tools:

{
  "type": "namespace",
  "name": "mcp__node_repl",
  "description": "Node REPL tools.",
  "tools": [
    {
      "type": "function",
      "name": "execute",
      "description": "Execute JavaScript.",
      "parameters": {
        "type": "object",
        "properties": {
          "code": { "type": "string" }
        },
        "required": ["code"]
      }
    }
  ]
}

Prism flattens each namespace member into a provider function. Returned function_call items restore the member name and include its namespace:

{
  "type": "function_call",
  "call_id": "call_456",
  "name": "execute",
  "namespace": "mcp__node_repl",
  "arguments": "{\"code\":\"console.log('ready')\"}"
}

Round-trip the namespace field with the function call in later requests.

Stream a response

const stream = await client.responses.create({
  model: "prism/deepseek-v4.1-flash",
  input: "Explain optimistic locking.",
  stream: true,
  store: false,
});

for await (const event of stream) {
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  }
}

Streams use typed Responses events, including response.created, response.output_item.added, response.output_text.delta, response.output_item.done, and response.completed.

Stateless compatibility

Prism applies zero data retention and does not implement stored Responses resources. Keep the conversation in your application and resend the required input items on each request.

Prism accepts client_metadata, service_tier, and Codex reasoning stream options for client compatibility. These fields do not change provider routing or decoding behavior.

The following OpenAI features are not supported:

• previous_response_id
• store: true
• background: true
• other Responses tool types such as web search, file search, computer use, shell, local shell, and native apply patch
• response retrieval, cancellation, deletion, and input-item subresources

Unsupported fields return an OpenAI-compatible 400 error rather than being silently ignored.