Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package gateway
import (
"bytes"
"cmp"
"encoding/json"
"fmt"
"net/http"
"slices"
"strings"
"time"
"github.com/tidwall/gjson"
"github.com/yetone/magpie/internal/claudeseal"
"github.com/yetone/magpie/internal/provider"
)
// ---- OpenAI Responses -------------------------------------------------------
type rItem struct {
Type string `json:"type,omitempty"`
Role string `json:"role,omitempty"`
Content json.RawMessage `json:"content,omitempty"`
// function_call / function_call_output
ID string `json:"id,omitempty"`
CallID string `json:"call_id,omitempty"`
Name string `json:"name,omitempty"`
Namespace string `json:"namespace,omitempty"`
Arguments rArgs `json:"arguments,omitempty"`
Input string `json:"input,omitempty"` // custom_tool_call's
Output json.RawMessage `json:"output,omitempty"`
Status string `json:"status,omitempty"`
// tool_search_output: the tools Codex's search found, which the model
// may call from then on
Tools []rTool `json:"tools,omitempty"`
// configuration_update's: an effort changed mid-thread
Reasoning *struct {
Effort string `json:"effort"`
} `json:"reasoning,omitempty"`
// reasoning
Summary []rText `json:"summary,omitempty"`
EncryptedContent string `json:"encrypted_content,omitempty"`
// web_search_call
Action *struct {
Query string `json:"query"`
Sources []struct {
URL string `json:"url"`
} `json:"sources"`
} `json:"action,omitempty"`
}
// rArgs is a call's arguments: a JSON string on a function_call, an object
// on Codex's tool_search_call.
type rArgs string
func (a *rArgs) UnmarshalJSON(b []byte) error {
var s string
if decodeJSON(b, &s) == nil {
*a = rArgs(s)
} else if string(b) != "null" {
*a = rArgs(b)
}
return nil
}
type rText struct {
Type string `json:"type"`
Text string `json:"text"`
}
type rTool struct {
Type string `json:"type"`
Name string `json:"name"`
Description string `json:"description,omitempty"`
Parameters json.RawMessage `json:"parameters,omitempty"`
Strict *bool `json:"strict,omitempty"`
Tools []rTool `json:"tools,omitempty"` // a namespace's
Execution string `json:"execution,omitempty"`
Format *rFormat `json:"format,omitempty"` // a custom tool's
}
// rFormat is what a custom (freeform) tool's input is: "text", or a
// "grammar" in a syntax ("lark", "regex") with its definition.
type rFormat struct {
Type string `json:"type"`
Syntax string `json:"syntax,omitempty"`
Definition string `json:"definition,omitempty"`
}
// A custom tool takes free text, not JSON: Codex's apply_patch and, for
// the models its catalog puts in code mode (gpt-6.1-sol, gpt-6-luna…),
// exec, through which every other tool of Codex's is called (#534: offered
// none, the model said it had only the collaboration and wait tools). A
// model magpie translates for is offered it as a function taking the text
// as its one argument, and its call goes back to Codex as the
// custom_tool_call Codex runs, the text as its input.
// customSchema is the arguments a custom tool is offered as taking.
var customSchema = json.RawMessage(`{"type":"object","properties":{"input":{"type":"string","description":"The tool's free-form input, the whole of it, exactly as it is to be run."}},"required":["input"],"additionalProperties":false}`)
// customDescription is a custom tool's description as a function's: its
// own, what its input is, and the grammar the input follows.
func customDescription(t rTool) string {
d := strings.TrimSpace(t.Description)
if d != "" {
d += "\n\n"
}
d += "Put the tool's whole free-form input, as it is to be run, in the `input` string; it is passed on as written, so it is not itself JSON."
if f := t.Format; f != nil && f.Type == "grammar" && strings.TrimSpace(f.Definition) != "" {
syntax := f.Syntax
if syntax == "" {
syntax = "the"
}
d += "\n\nThe input follows this " + syntax + " grammar:\n" + strings.TrimSpace(f.Definition)
}
return d
}
// customInput is the free-form input of a call the model made to a custom
// tool offered as a function: its input argument, else what it gave.
func customInput(args string) string {
var a struct {
Input *string `json:"input"`
}
if decodeJSON([]byte(args), &a) == nil && a.Input != nil {
return *a.Input
}
var str string
if decodeJSON([]byte(args), &str) == nil {
return str
}
return args
}
// toolSearch is Codex's tool search. With it Codex names its MCP tools (the
// ChatGPT apps' among them) and its sub-agent tools only in the search's
// description, and hands the model the ones it searched for in a
// tool_search_output, instead of every schema on every request (#258).
// Codex runs the search itself ("execution": "client"): a model magpie
// translates for is offered it as the function it is, and its call goes
// back to Codex as the tool_search_call Codex runs.
const toolSearch = "tool_search"
// searchFound is what a model reads of a tool search's result: the tools it
// may call now, by the names it is offered them under.
func searchFound(tools []rTool) string {
var names []string
for _, t := range tools {
switch t.Type {
case "function":
names = append(names, t.Name)
case "namespace":
for _, nt := range t.Tools {
if nt.Type == "function" {
names = append(names, flatName(t.Name, nt.Name))
}
}
}
}
if len(names) == 0 {
return "No tools matched the search."
}
return "These tools are now available to call: " + strings.Join(names, ", ")
}
// flatName is the name a namespaced tool is offered to a model under,
// namespace__name, the same a Grok subscription is offered it under.
// unsealed is a tool's parameters without the "encrypted" marks Codex puts
// on some (spawn_agent's message): a translated request's calls go back to
// Codex as unsealed (callTo's encrypted_function_args), so an upstream that
// honours the mark must not seal them (#613).
func unsealed(schema json.RawMessage) json.RawMessage {
if !bytes.Contains(schema, []byte(`"encrypted"`)) {
return schema
}
var v any
if decodeJSON(schema, &v) != nil {
return schema
}
var strip func(any)
strip = func(v any) {
switch x := v.(type) {
case map[string]any:
if _, ok := x["encrypted"].(bool); ok {
delete(x, "encrypted")
}
for _, c := range x {
strip(c)
}
case []any:
for _, c := range x {
strip(c)
}
}
}
strip(v)
out, err := marshalPlain(v)
if err != nil {
return schema
}
return out
}
// asksSealing is a Responses request whose tools mark a parameter
// "encrypted" (MultiAgentV2's spawn_agent message): an upstream that
// honours the mark answers the call with that argument sealed.
func asksSealing(body []byte) bool {
if !bytes.Contains(body, []byte(`"encrypted"`)) {
return false
}
var q struct {
Tools []struct {
Parameters json.RawMessage `json:"parameters"`
Tools []struct {
Parameters json.RawMessage `json:"parameters"`
} `json:"tools"`
} `json:"tools"`
}
if decodeJSON(body, &q) != nil {
return false
}
var mark func(any) bool
mark = func(v any) bool {
switch x := v.(type) {
case map[string]any:
if b, ok := x["encrypted"].(bool); ok && b {
return true
}
for _, c := range x {
if mark(c) {
return true
}
}
case []any:
for _, c := range x {
if mark(c) {
return true
}
}
}
return false
}
marked := func(schema json.RawMessage) bool {
var v any
return bytes.Contains(schema, []byte(`"encrypted"`)) && decodeJSON(schema, &v) == nil && mark(v)
}
for _, t := range q.Tools {
if marked(t.Parameters) {
return true
}
for _, nt := range t.Tools {
if marked(nt.Parameters) {
return true
}
}
}
return false
}
func flatName(namespace, name string) string {
return provider.FlatName(namespace, name)
}
type rRequest struct {
Model string `json:"model"`
Instructions string `json:"instructions,omitempty"`
Input json.RawMessage `json:"input"`
Tools []rTool `json:"tools,omitempty"`
ToolChoice json.RawMessage `json:"tool_choice,omitempty"`
MaxOutputTokens int `json:"max_output_tokens,omitempty"`
Temperature *float64 `json:"temperature,omitempty"`
TopP *float64 `json:"top_p,omitempty"`
Stream bool `json:"stream,omitempty"`
ParallelToolCalls *bool `json:"parallel_tool_calls,omitempty"`
ServiceTier string `json:"service_tier,omitempty"`
PromptCacheKey string `json:"prompt_cache_key,omitempty"`
// PromptCacheRetention is OpenAI's "in_memory" or "24h": the client's
// own say over how long its prompt stays cached (hourMarks)
PromptCacheRetention string `json:"prompt_cache_retention,omitempty"`
Include []string `json:"include,omitempty"`
ClientMetadata json.RawMessage `json:"client_metadata,omitempty"`
AccessPrograms json.RawMessage `json:"access_programs,omitempty"`
Text json.RawMessage `json:"text,omitempty"`
Reasoning *struct {
Effort string `json:"effort,omitempty"`
Summary string `json:"summary,omitempty"`
} `json:"reasoning,omitempty"`
}
// textFormat splits a Responses client's text into the rest of it and
// the format it asks the answer in (text.format), which is asked for again
// in each upstream's own words. A format of plain text stays where it was.
func textFormat(text json.RawMessage) (json.RawMessage, *Format) {
var fields map[string]json.RawMessage
if decodeJSON(text, &fields) != nil {
return text, nil
}
f := openAIFormat(fields["format"])
if f == nil {
return text, nil
}
delete(fields, "format")
if len(fields) == 0 {
return nil, f
}
rest, _ := json.Marshal(fields)
return rest, f
}
// sentRaw is a raw field the client sent, unless it sent null.
func sentRaw(v json.RawMessage) json.RawMessage {
if t := strings.TrimSpace(string(v)); t == "" || t == "null" {
return nil
}
return v
}
func parseResponses(body []byte) (*Request, error) { return readResponses(body, false) }
// readResponses is parseResponses; for facts (readFacts) it leaves out what
// they never read: the assistant's words, its calls' arguments and the
// tools' outputs, each decoded into strings of their own, and the copies
// of raw values a parse kept would need. Run on every request, a long
// Codex conversation's tool outputs were most of the parse (#3394).
func readResponses(body []byte, facts bool) (*Request, error) {
decode := decodeJSON
if facts {
decode = decodeJSONView
}
// Responses Lite's tools, sent as the first input item (#350)
body = liftAdditionalTools(body)
var q rRequest
if err := decode(body, &q); err != nil {
return nil, fmt.Errorf("invalid request: %v", err)
}
r := &Request{Model: q.Model, System: q.Instructions, MaxTokens: q.MaxOutputTokens, Temp: q.Temperature,
TopP: q.TopP, Stream: q.Stream, Parallel: q.ParallelToolCalls, Fast: q.ServiceTier == "priority" || q.ServiceTier == "ultrafast", Ultrafast: q.ServiceTier == "ultrafast", Tier: q.ServiceTier, CacheKey: q.PromptCacheKey, Include: q.Include,
ClientMetadata: sentRaw(q.ClientMetadata), AccessPrograms: q.AccessPrograms}
r.Text, r.Format = textFormat(sentRaw(q.Text))
// a Responses client's turns go to Claude with hour-long cache marks,
// unless it asked for its prompt to be kept in memory only
r.hourMarks = q.PromptCacheRetention != "in_memory"
if q.Reasoning != nil {
r.Effort = effortOf(q.Reasoning.Effort)
r.Thinking = true
r.ThinkOff = strings.EqualFold(strings.TrimSpace(q.Reasoning.Effort), "none")
}
var found []rTool // what Codex's tool searches found
var s string
if decodeJSON(q.Input, &s) == nil {
r.Messages = append(r.Messages, Message{Role: "user", Parts: []Part{{Kind: Text, Text: s}}})
} else {
var items []rItem
if err := decode(q.Input, &items); err != nil {
return nil, fmt.Errorf("invalid input: %v", err)
}
// replied: the conversation has had a turn answered. Codex adds a
// developer message where its context changed (world state, settings,
// a model switch) and keeps it there; lifted into the system prompt it
// changed the prompt's very start, so the whole conversation was
// written to the vendor's cache again (Anthropic's system comes
// first; a Claude subscription's waiting run is found by it) (#502)
replied := false
var rawItems []json.RawMessage // decoded only for native standalone outputs and sealed reasoning
for i, it := range items {
if it.Role == "assistant" || strings.HasPrefix(it.Type, "function_call") || strings.HasPrefix(it.Type, "custom_tool_call") || strings.HasPrefix(it.Type, "tool_search") || it.Type == "reasoning" {
replied = true
}
switch {
case it.Type == "message" || (it.Type == "" && it.Role != ""):
role := "user"
if it.Role == "assistant" {
role = "assistant"
}
var parts []Part
if !facts || role != "assistant" {
parts = responsesParts(it.Content)
}
if (it.Role == "system" || it.Role == "developer") && replied {
// in place, told as the system's, not the user's words
if t := text(parts); t != "" {
r.Messages = append(r.Messages, Message{Role: "user", Parts: []Part{{Kind: Text, Text: "<system-reminder>\n" + t + "\n</system-reminder>"}}})
}
continue
}
if it.Role == "system" || it.Role == "developer" {
if t := text(parts); t != "" {
if r.System != "" {
r.System += "\n\n"
}
r.System += t
}
continue
}
r.Messages = append(r.Messages, Message{Role: role, Parts: parts})
case it.Type == "configuration_update":
// the agent changed its effort mid-thread: the last
// change is the one the turn is asked at (effortUpdated)
if q.Reasoning != nil && it.Reasoning != nil && it.Reasoning.Effort != "" {
r.Effort = effortOf(it.Reasoning.Effort)
r.ThinkOff = strings.EqualFold(strings.TrimSpace(it.Reasoning.Effort), "none")
}
case it.Type == "agent_message":
// MultiAgentV2 hands a subagent its task, and agents their
// messages to each other, as this item: what it says is the
// user's turn for the agent that receives it.
if parts := responsesParts(it.Content); len(parts) > 0 {
r.Messages = append(r.Messages, Message{Role: "user", Parts: parts})
}
case it.Type == "function_call":
name := it.Name
if it.Namespace != "" {
name = flatName(it.Namespace, it.Name)
}
r.Messages = append(r.Messages, Message{Role: "assistant", Parts: []Part{{Kind: ToolCall, ID: it.CallID, Name: name, Args: parseArgs(string(it.Arguments))}}})
case it.Type == "custom_tool_call":
name := it.Name
if it.Namespace != "" {
name = flatName(it.Namespace, it.Name)
}
args, _ := json.Marshal(map[string]string{"input": it.Input})
r.Messages = append(r.Messages, Message{Role: "assistant", Parts: []Part{{Kind: ToolCall, ID: it.CallID, Name: name, Args: args}}})
case it.Type == "tool_search_call":
r.Messages = append(r.Messages, Message{Role: "assistant", Parts: []Part{{Kind: ToolCall, ID: it.CallID, Name: toolSearch, Args: parseArgs(string(it.Arguments))}}})
case it.Type == "tool_search_output":
found = append(found, it.Tools...)
r.Messages = append(r.Messages, Message{Role: "user", Parts: []Part{{Kind: ToolResult, CallID: it.CallID, Text: searchFound(it.Tools)}}})
case (it.Type == "function_call_output" || it.Type == "custom_tool_call_output") && facts:
r.Messages = append(r.Messages, Message{Role: "user", Parts: []Part{{Kind: ToolResult, CallID: it.CallID}}})
case it.Type == "function_call_output" || it.Type == "custom_tool_call_output":
out, images := toolOutput(it.Output)
part := Part{Kind: ToolResult, CallID: it.CallID, Text: out, Images: images}
if it.CallID == "" {
// Native account requests may still need translation to
// collect a streamed response for a non-streaming client.
// Retain the original notification, including absent IDs.
if rawItems == nil {
_ = decodeJSON(q.Input, &rawItems)
}
_ = decodeJSON(rawItems[i], &part.Standalone)
}
r.Messages = append(r.Messages, Message{Role: "user", Parts: []Part{part}})
case it.Type == "reasoning":
// the reasoning itself when the item carries it, else its
// summary (all magpie gives a client of a translated reply)
var b strings.Builder
var content []rText
_ = decodeJSON(it.Content, &content)
for _, c := range content {
if c.Type == "reasoning_text" {
b.WriteString(c.Text)
}
}
if b.Len() == 0 {
for _, s := range it.Summary {
b.WriteString(s.Text)
}
}
part := Part{Kind: Thinking, Text: b.String()}
if block, ours := claudeseal.Open(it.EncryptedContent); ours {
// Claude's block, which magpie gave the client to carry
// back: as Claude wrote it, and never to a Responses API
// (withoutClaudeSeals). One that can't be read is its
// summary, as before.
part = claudePart(block, part)
} else if it.EncryptedContent != "" {
// sealed: the item goes back to a Responses API as it
// came, id, summary and all (#1445)
if rawItems == nil {
_ = decodeJSON(q.Input, &rawItems)
}
if i < len(rawItems) {
part.Sealed, part.SealedBy = rawItems[i], sealResponses
}
}
if part.Text != "" || part.Sealed != nil || part.Signature != "" {
r.Messages = append(r.Messages, Message{Role: "assistant", Parts: []Part{part}})
}
}
}
}
r.Messages = mergeTurns(r.Messages)
sent := len(q.Tools)
offer := func(i int, t Tool, ns nsTool) {
// a tool searched for twice, or sent as well, is offered once
if i >= sent && slices.ContainsFunc(r.Tools, func(o Tool) bool { return o.Name == t.Name }) {
return
}
if ns != (nsTool{}) {
if r.Namespaced == nil {
r.Namespaced = map[string]nsTool{}
}
r.Namespaced[t.Name] = ns
}
r.Tools = append(r.Tools, t)
}
// the tools Codex's searches found are offered after those it sent, as
// Codex does not send them again
for i, t := range append(q.Tools, found...) {
if strings.HasPrefix(t.Type, "web_search") {
r.WebSearch = true
}
switch t.Type {
case "function":
offer(i, Tool{Name: t.Name, Description: t.Description, Schema: unsealed(t.Parameters), Strict: t.Strict != nil && *t.Strict}, nsTool{})
case "custom":
offer(i, Tool{Name: t.Name, Description: customDescription(t), Schema: customSchema}, nsTool{Name: t.Name, Custom: true})
case "namespace":
// offered flat, as few models know namespaces; a call is given
// its namespace back on the way out
for _, nt := range t.Tools {
flat := flatName(t.Name, nt.Name)
switch nt.Type {
case "function":
offer(i, Tool{Name: flat, Description: nt.Description, Schema: unsealed(nt.Parameters), Strict: nt.Strict != nil && *nt.Strict}, nsTool{Namespace: t.Name, Name: nt.Name})
case "custom":
offer(i, Tool{Name: flat, Description: customDescription(nt), Schema: customSchema}, nsTool{Namespace: t.Name, Name: nt.Name, Custom: true})
}
}
case toolSearch:
if t.Execution == "client" {
offer(i, Tool{Name: toolSearch, Description: t.Description, Schema: t.Parameters}, nsTool{Search: true})
}
}
}
var tc string
if decodeJSON(q.ToolChoice, &tc) == nil {
r.ToolChoice = tc
} else {
var o struct {
Type string `json:"type"`
Name string `json:"name"`
Mode string `json:"mode"`
Tools []struct {
Type string `json:"type"`
Name string `json:"name"`
Namespace string `json:"namespace"`
} `json:"tools"`
}
if decodeJSON(q.ToolChoice, &o) == nil {
switch o.Type {
case "allowed_tools":
if o.Mode != "auto" && o.Mode != "required" {
return nil, fmt.Errorf("invalid allowed_tools mode %q", o.Mode)
}
r.ToolChoice = o.Mode
allowed := make(map[string]bool, len(o.Tools))
webSearch := false
for _, tool := range o.Tools {
switch {
case (tool.Type == "function" || tool.Type == "custom") && tool.Name != "":
if tool.Namespace != "" {
allowed[flatName(tool.Namespace, tool.Name)] = true
} else {
allowed[tool.Name] = true
}
case strings.HasPrefix(tool.Type, "web_search"):
webSearch = true
}
}
r.WebSearch = r.WebSearch && webSearch
var tools []Tool
for _, tool := range r.Tools {
if allowed[tool.Name] {
tools = append(tools, tool)
}
}
r.Tools = tools
for name := range r.Namespaced {
if !allowed[name] {
delete(r.Namespaced, name)
}
}
case "function":
if o.Name != "" {
r.ToolChoice = "name:" + o.Name
}
}
}
}
return r, nil
}
// toolCallItem is a Responses input item that makes a tool call, and
// toolResultItem one that answers a call.
func toolCallItem(t string) bool {
switch t {
case "function_call", "custom_tool_call", "tool_search_call":
return true
}
return false
}
func toolResultItem(t string) bool {
switch t {
case "function_call_output", "custom_tool_call_output", "tool_search_output":
return true
}
return false
}
// joinToolRuns moves an item that sits inside a run of tool calls and
// results — after a result of the run and before the last result that
// answers one of its calls — to the end of that run. An upstream that
// checks the exchange, on the chat form it turns a relayed request into or
// on the Responses input itself, reads the run as ended there and refuses
// it: Volcengine's coding plan answers 400 "An assistant message with
// 'tool_calls' must be followed by tool messages responding to each
// 'tool_call_id'", the same refusal pairToolItems mends a missing result
// for (#1341), and OpenCode Zen/Go answers "No tool output found for tool
// call <id>". An agent writes an item between one batch's results itself:
// Codex writes its <image_resize_notice> right after each result that held
// an image it resized (image_preparation.rs, prepare_response_items), so a
// batch of two calls has it between their results (#1752, #1822).
//
// An item that carries a call_id is part of an exchange and never moves,
// whatever its type. Before the run's first result, what the model wrote
// between its own calls is its step: reasoning and a hosted tool's call
// stay, and its text (an assistant message) goes ahead of the run's first
// call, with the reasoning right before it, so the step's calls stand
// together. OpenCode Go turns a relayed request into chat with each
// assistant message after a call opening a new assistant message, so
// [text, call_a, text, call_b, out_a, out_b], what Codex keeps when the
// model wrote a line before each call of a batch, reached it as two
// messages with tool_calls and the first answered by nothing: "No tool
// output found for tool call call_a" (#2100). Anything else there (a
// subagent's agent_message, a note) moves as it would between the results. A call opens the run only when a
// result after it answers it: a call nothing answers is pairToolItems'
// (#1341), and one answered before it is not waited on. An item between two
// whole exchanges stays where it is, and a request with nothing inside a
// run comes back byte for byte.
func joinToolRuns(body []byte) []byte {
if !bytes.Contains(body, []byte(`_call"`)) {
return body
}
var q map[string]json.RawMessage
if decodeJSONView(body, &q) != nil {
return body
}
input, isList := inputList(q["input"])
if !isList {
return body
}
type item struct {
Type string `json:"type"`
Role string `json:"role"`
CallID string `json:"call_id"`
}
items := make([]item, len(input))
for i, raw := range input {
if decodeJSONView(raw, &items[i]) != nil {
items[i] = item{}
}
}
result := func(it item) bool { return it.CallID != "" && strings.HasSuffix(it.Type, "_output") }
// answeredLater[i]: the call at i has a result after it
answeredLater := make([]bool, len(input))
ahead := map[string]bool{}
for i := len(items) - 1; i >= 0; i-- {
switch it := items[i]; {
case result(it):
ahead[it.CallID] = true
case it.CallID != "":
answeredLater[i] = ahead[it.CallID]
}
}
modelsOwn := func(it item) bool {
return it.Type == "reasoning" || it.Type == "message" && it.Role == "assistant" ||
strings.HasSuffix(it.Type, "_call")
}
out := make([]json.RawMessage, 0, len(input))
kinds := make([]item, 0, len(input)) // what each item of out is
var held []json.RawMessage
moved := false
// open: calls of the run in progress whose result is still ahead;
// answering: a result of the run has come; first: where in out the
// run's first call is
open := map[string]bool{}
answering := false
first := 0
for i, raw := range input {
it := items[i]
switch {
case result(it):
if open[it.CallID] {
delete(open, it.CallID)
answering = true
}
case it.CallID != "":
if answeredLater[i] {
if len(open) == 0 {
first = len(out)
}
open[it.CallID] = true
}
case len(open) > 0 && (answering || !modelsOwn(it)):
held, moved = append(held, raw), true
continue
case len(open) > 0 && it.Type == "message":
// the model's text between its calls goes ahead of the
// first, the reasoning it follows with it
from := len(out)
for from > first && kinds[from-1].Type == "reasoning" {
from--
}
seg := append(append([]json.RawMessage(nil), out[from:]...), raw)
segKinds := append(append([]item(nil), kinds[from:]...), it)
out = slices.Insert(out[:from], first, seg...)
kinds = slices.Insert(kinds[:from], first, segKinds...)
first += len(seg)
moved = true
continue
}
out = append(out, raw)
kinds = append(kinds, it)
if len(open) == 0 {
out = append(out, held...)
kinds = append(kinds, make([]item, len(held))...)
held, answering = nil, false
}
}
out = append(out, held...)
if !moved {
return body
}
q["input"], _ = marshalPlain(out)
encoded, err := marshalPlain(q)
if err != nil {
return body
}
return encoded
}
// orphanedToolOutputs turns a tool result with no call ID into a user message.
// Codex uses standalone outputs for cross-thread notifications. Backends
// requiring paired outputs still need the delivered text, without a fake call ID.
func orphanedToolOutputs(body []byte) []byte {
var q map[string]json.RawMessage
if decodeJSONView(body, &q) != nil {
return body
}
input, isList := inputList(q["input"])
if !isList {
return body
}
changed := false
out := make([]json.RawMessage, 0, len(input))
var pending []json.RawMessage
inCalls, hadResults := false, false
flush := func() {
out = append(out, pending...)
pending = nil
}
for _, raw := range input {
var item struct {
Type string `json:"type"`
CallID string `json:"call_id"`
Output json.RawMessage `json:"output"`
}
if decodeJSONView(raw, &item) != nil {
flush()
inCalls = false
out = append(out, raw)
continue
}
isOutput := item.Type == "function_call_output" || item.Type == "custom_tool_call_output"
if !isOutput || item.CallID != "" {
switch item.Type {
case "function_call", "custom_tool_call", "tool_search_call":
if hadResults {
flush()
}
inCalls, hadResults = true, false
case "function_call_output", "custom_tool_call_output", "tool_search_output":
// Keep a run of tool results directly after its calls.
hadResults = true
default:
flush()
inCalls = false
}
out = append(out, raw)
continue
}
text, images := toolOutput(item.Output)
content := []map[string]any{}
if text != "" {
content = append(content, map[string]any{"type": "input_text", "text": text})
}
for _, image := range images {
content = append(content, map[string]any{"type": "input_image", "detail": responsesDetail(image.Detail), "image_url": dataURL(image)})
}
if len(content) == 0 {
content = append(content, map[string]any{"type": "input_text", "text": "Tool result received."})
}
message, _ := marshalPlain(map[string]any{"type": "message", "role": "user", "content": content})
if inCalls {
// Chat rejects a user message between tool_calls and results,
// including between the results of parallel calls.
pending = append(pending, message)
} else {
out = append(out, message)
}
changed = true
}
flush()
if !changed {
return body
}
q["input"], _ = marshalPlain(out)
encoded, err := marshalPlain(q)
if err != nil {
return body
}
return encoded
}
// pairToolItems gives a Responses request's tool call that no result in
// the request answers a synthetic one, as pairToolMessages does for a Chat
// request: an upstream that checks the exchange on the chat form it turns
// the request into refuses a lone call — Volcengine's coding plan answers
// 400 "An assistant message with 'tool_calls' must be followed by tool
// messages responding to each 'tool_call_id'" (#1341), and OpenAI's own
// Responses API "No tool output found for function call". The result goes
// at the end of the run of calls and results the call is in, where a chat
// form has its tool messages. A result with no call is left to
// orphanedToolOutputs, and one naming a call another request carried
// (previous_response_id) stays as it is.
func pairToolItems(body []byte) []byte {
if !bytes.Contains(body, []byte(`_call"`)) {
return body
}
var q map[string]json.RawMessage
if decodeJSONView(body, &q) != nil {
return body
}
input, isList := inputList(q["input"])
if !isList {
return body
}
type item struct {
Type string `json:"type"`
CallID string `json:"call_id"`
}
items := make([]item, len(input))
answered := map[string]bool{}
for i, raw := range input {
if decodeJSONView(raw, &items[i]) != nil {
items[i] = item{}
}
if t := items[i].Type; (t == "function_call_output" || t == "custom_tool_call_output") && items[i].CallID != "" {
answered[items[i].CallID] = true
}
}
exchange := func(t string) bool {
return toolCallItem(t) || toolResultItem(t)
}
out := make([]json.RawMessage, 0, len(input)+1)
var synthetic []json.RawMessage // results owed by the run in progress
for i, raw := range input {
out = append(out, raw)
it := items[i]
if (it.Type == "function_call" || it.Type == "custom_tool_call") && it.CallID != "" && !answered[it.CallID] {
kind := "function_call_output"
if it.Type == "custom_tool_call" {
kind = "custom_tool_call_output"
}
result, _ := marshalPlain(map[string]any{"type": kind, "call_id": it.CallID,
"output": "[The result of this tool call is unavailable: the turn was interrupted.]"})
synthetic = append(synthetic, result)
answered[it.CallID] = true
}
if len(synthetic) > 0 && exchange(it.Type) && (i+1 == len(input) || !exchange(items[i+1].Type)) {
out = append(out, synthetic...)
synthetic = nil
}
}
if len(out) == len(input) {
return body
}
q["input"], _ = marshalPlain(out)
encoded, err := marshalPlain(q)
if err != nil {
return body
}
return encoded
}
// mergeTurns joins consecutive messages of the same role, since the
// Responses API splits an assistant turn into one item per part.
func mergeTurns(msgs []Message) []Message {
var out []Message
for _, m := range msgs {
if n := len(out); n > 0 && out[n-1].Role == m.Role {
out[n-1].Parts = append(out[n-1].Parts, m.Parts...)
continue
}
out = append(out, m)
}
return out
}
func responsesParts(raw json.RawMessage) []Part {
var s string
if decodeJSON(raw, &s) == nil {
if s == "" {
return nil
}
return []Part{{Kind: Text, Text: s}}
}
var items []struct {
Type string `json:"type"`
Text string `json:"text"`
ImageURL string `json:"image_url"`
Detail string `json:"detail"`
}
decodeJSON(raw, &items)
var out []Part
for _, it := range items {
switch it.Type {
case "input_text", "output_text", "text":
out = append(out, Part{Kind: Text, Text: it.Text})
case "input_image":
if it.ImageURL != "" {
im := imagePart(it.ImageURL)
im.Detail = it.Detail
out = append(out, im)
}
}
}
return out
}
// replaysReasoning is whether model, served by host's Responses API, wants
// a turn's reasoning text back between tool calls (DeepSeek: "The
// reasoning_text in the thinking mode must be passed back", #388). OpenAI's,
// xAI's, Copilot's and Azure's read only their own sealed reasoning.
func replaysReasoning(model, host string) bool {
return strings.Contains(strings.ToLower(model), "deepseek") &&
!slices.Contains([]string{"chatgpt.com", "api.openai.com", "api.x.ai", "api.githubcopilot.com"}, host) &&
!strings.HasSuffix(host, ".openai.azure.com")
}
// withReasoningText gives each reasoning item in a Responses request that
// carries no reasoning_text its summary as one, else noReasoning, and has
// each step that needs one lead with a reasoning item (reasonFirst), for an
// upstream that wants the reasoning back (replaysReasoning). Codex sends an
// item back as it got it: one from a turn magpie translated has only a
// summary, one the ChatGPT backend sealed has only encrypted_content, and a
// turn another model in a mixed group served may have no reasoning item at
// all. DeepSeek refuses the whole request over any of them, and over an
// empty reasoning_text, with "The `reasoning_text` in the thinking mode must
// be passed back to the API" (#1104, #1592, #1822). A body with nothing to
// give comes back byte for byte.
func withReasoningText(body []byte) []byte {
if !bytes.Contains(body, []byte(`"reasoning"`)) && !bytes.Contains(body, []byte(`_call"`)) &&
!bytes.Contains(body, []byte(`_output"`)) {
return body
}
var q map[string]json.RawMessage
if decodeJSONView(body, &q) != nil {
return body
}
items, isList := inputList(q["input"])
if !isList {
return body
}
changed := false
kinds := make([]stepKind, len(items))
for i, raw := range items {
var it struct {
Type string `json:"type"`
Role string `json:"role"`
Summary []rText `json:"summary"`
Content []rText `json:"content"`
}
if decodeJSONView(raw, &it) != nil {
continue
}
kinds[i] = stepKindOf(it.Type, it.Role)
if it.Type != "reasoning" ||
slices.ContainsFunc(it.Content, func(c rText) bool { return c.Type == "reasoning_text" && c.Text != "" }) {
continue
}
var b strings.Builder
for _, s := range it.Summary {
b.WriteString(s.Text)
}
if b.Len() == 0 {
b.WriteString(noReasoning)
}
var m map[string]json.RawMessage
if decodeJSONView(raw, &m) != nil {
continue
}
m["content"], _ = json.Marshal([]map[string]string{{"type": "reasoning_text", "text": b.String()}})
if nb, err := marshalJSON(m); err == nil {
items[i], changed = nb, true
}
}
none, _ := json.Marshal(noReasoningItem())
if led, ok := reasonFirst(items, kinds, json.RawMessage(none)); ok {
items, changed = led, true
}
if !changed {
return body
}
q["input"], _ = marshalJSON(items)
nb, err := marshalJSON(q)
if err != nil {
return body
}
return nb
}
// stepKind is what a Responses input item is to a step of the model's: its
// reasoning, something it said or a call it made, what answered a call, or
// a message of the user's (or the system's) that starts a turn.
type stepKind int
const (
stepOther stepKind = iota
stepReasoning
stepSaid
stepCall
stepOutput
stepTurn
)
func stepKindOf(typ, role string) stepKind {
switch {
case typ == "reasoning":
return stepReasoning
case strings.HasSuffix(typ, "_output"):
return stepOutput
case strings.HasSuffix(typ, "_call"):
return stepCall
case (typ == "message" || typ == "") && role == "assistant":
return stepSaid
case typ == "message" || typ == "" && role != "":
return stepTurn
}
return stepOther
}
// noReasoningItem is the reasoning item a step leads with when it has none
// of its own (reasonFirst).
func noReasoningItem() map[string]any {
return map[string]any{"type": "reasoning", "summary": []any{},
"content": []map[string]any{{"type": "reasoning_text", "text": noReasoning}}}
}
// reasonFirst has each step of the model's (a run of its reasoning, what it
// said and the calls it made, between a user message or a tool output and
// the next) that makes a call, or that follows a tool output, lead with a
// reasoning item: the step's first one moved ahead of the rest, else none.
// DeepSeek's /v1/responses reads a step as one assistant message whose
// thinking is the reasoning item it starts with, and turns the whole
// request away ("The `reasoning_text` in the thinking mode must be passed
// back to the API") when a step of the turn being continued starts with
// anything else: a call (#1592), or what the model said, as Codex sends a
// step that said something before its call with its reasoning between them,
// or with none, which magpie put between them (#1822). Checked against
// api.deepseek.com on 2026-10-12: [text, reasoning, call] and [output,
// text] are refused, [reasoning, text, call] and [output, reasoning, text]
// are taken. ok is false, and items comes back as it is, when every such
// step leads with one already.
func reasonFirst[T any](items []T, kinds []stepKind, none T) (led []T, ok bool) {
step := func(k stepKind) bool { return k == stepReasoning || k == stepSaid || k == stepCall }
afterOutput := false
for i := 0; i < len(items); {
if !step(kinds[i]) {
switch kinds[i] {
case stepOutput:
afterOutput = true
case stepTurn:
afterOutput = false
}
if ok {
led = append(led, items[i])
}
i++
continue
}
j, calls, first := i, false, -1
for ; j < len(items) && step(kinds[j]); j++ {
calls = calls || kinds[j] == stepCall
if kinds[j] == stepReasoning && first < 0 {
first = j
}
}
if (calls || afterOutput) && first != i {
if !ok {
led, ok = append(make([]T, 0, len(items)+1), items[:i]...), true
}
if first < 0 {
led = append(led, none)
} else {
led = append(led, items[first])
}
for x := i; x < j; x++ {
if x != first {
led = append(led, items[x])
}
}
} else if ok {
led = append(led, items[i:j]...)
}
i = j
}
if !ok {
return items, false
}
return led, true
}
// sealedReasoning is a reasoning item a Responses API sealed, fit to go
// back to one as it came: encrypted_content in it, and no reasoning text
// (which OpenAI and the ChatGPT backend refuse in input, #1411; one with
// text goes as before).
func sealedReasoning(p Part) bool {
if !p.sealedBy(sealResponses) {
return false
}
var it struct {
Enc string `json:"encrypted_content"`
Content []json.RawMessage `json:"content"`
}
return decodeJSON(p.Sealed, &it) == nil && it.Enc != "" && len(it.Content) == 0
}
// buildResponses renders a request for a Responses upstream.
func buildResponses(r *Request, model, host string, rejectTemp bool) []byte {
// A turn's reasoning goes back as a reasoning item, as a model that
// thinks between tool calls wants it (DeepSeek: "The reasoning_text in
// the thinking mode must be passed back", #388). Only a DeepSeek model
// gets it: OpenAI's and those in front of it read only their own
// sealed reasoning, and may refuse an item without it.
replay := replaysReasoning(model, host)
var input []any
// a deferred tool a result loaded goes in an additional_tools item
// after that result and the results beside it, once, where the
// upstream takes one (Request.LoadedInPlace, #2660)
deferred := map[string]Tool{}
placed := map[string]bool{}
if r.LoadedInPlace {
for _, t := range r.Tools {
if t.Deferred {
deferred[t.Name] = t
}
}
}
var loaded []any
flushLoaded := func() {
if len(loaded) > 0 {
input = append(input, map[string]any{"type": "additional_tools", "role": "developer", "tools": loaded})
loaded = nil
}
}
// a second answer to one call is left out, as the Chat and Messages
// builds leave it (dropSecondAnswers)
for _, m := range dropSecondAnswers(r.Messages) {
var content []map[string]any
flushMsg := func() {
if len(content) == 0 {
return
}
flushLoaded()
input = append(input, map[string]any{"type": "message", "role": m.Role, "content": content})
content = nil
}
for _, p := range m.Parts {
switch p.Kind {
case Text:
if p.Text == "" && p.Signature != "" {
continue // only Gemini's signature, which is Gemini's
}
t := "input_text"
if m.Role == "assistant" {
t = "output_text"
}
content = append(content, map[string]any{"type": t, "text": p.Text})
case File:
t := "input_text"
if m.Role == "assistant" {
t = "output_text"
}
content = append(content, map[string]any{"type": t, "text": attachmentText(p)})
case Image:
if m.Role != "assistant" {
content = append(content, map[string]any{"type": "input_image", "detail": responsesDetail(p.Detail), "image_url": dataURL(p)})
}
case Thinking:
if !replay && sealedReasoning(p) {
// a Responses API's own sealed reasoning goes back as
// it came: id, summary and encrypted_content (#1445)
flushMsg()
flushLoaded()
input = append(input, p.Sealed)
} else if replay && p.Text != "" {
flushMsg()
flushLoaded()
input = append(input, map[string]any{"type": "reasoning", "summary": []any{},
"content": []map[string]any{{"type": "reasoning_text", "text": p.Text}}})
}
case ToolCall:
flushMsg()
flushLoaded()
id := p.ID
if id == "" {
id = "call_" + newID()
}
input = append(input, map[string]any{"type": "function_call", "call_id": id, "name": p.Name, "arguments": argsString(p)})
case ToolResult:
flushMsg()
if p.Standalone != nil {
input = append(input, p.Standalone)
continue
}
var output any = p.Text
if len(p.Images) > 0 {
// an output can be a list of text and images
var items []map[string]any
if strings.TrimSpace(p.Text) != "" {
items = append(items, map[string]any{"type": "input_text", "text": p.Text})
}
for _, im := range p.Images {
items = append(items, map[string]any{"type": "input_image", "detail": responsesDetail(im.Detail), "image_url": dataURL(im)})
}
output = items
}
input = append(input, map[string]any{"type": "function_call_output", "call_id": p.CallID, "output": output})
for _, name := range p.Loads {
if t, ok := deferred[name]; ok && !placed[name] {
placed[name] = true
loaded = append(loaded, responsesTool(t))
}
}
}
}
flushMsg()
}
flushLoaded()
if replay {
// each step that makes a call, or follows a tool output, leads with
// its reasoning, or with a space's (#1592, #1822)
kinds := make([]stepKind, len(input))
for i, it := range input {
var k struct {
Type string `json:"type"`
Role string `json:"role"`
}
switch v := it.(type) {
case map[string]any:
k.Type, _ = v["type"].(string)
k.Role, _ = v["role"].(string)
case json.RawMessage:
decodeJSON(v, &k)
}
kinds[i] = stepKindOf(k.Type, k.Role)
}
input, _ = reasonFirst(input, kinds, any(noReasoningItem()))
}
if input == nil {
input = []any{}
}
out := map[string]any{"model": model, "input": input, "stream": r.Stream, "store": false}
if len(r.ClientMetadata) > 0 {
out["client_metadata"] = r.ClientMetadata
}
if len(r.AccessPrograms) > 0 {
out["access_programs"] = r.AccessPrograms
}
if len(r.Text) > 0 || r.Format != nil {
text := map[string]any{}
decodeJSON(r.Text, &text)
if r.Format != nil {
text["format"] = r.Format.responses()
}
out["text"] = text
}
if r.CacheKey != "" {
out["prompt_cache_key"] = r.CacheKey
}
if r.System != "" {
out["instructions"] = r.System
}
if r.MaxTokens > 0 {
out["max_output_tokens"] = r.MaxTokens
}
if !rejectTemp {
if r.Temp != nil {
out["temperature"] = *r.Temp
}
if r.TopP != nil {
out["top_p"] = *r.TopP
}
}
// Fast goes to OpenAI's own backends; another's may not know the tier
if r.Fast && (host == "chatgpt.com" || host == "api.openai.com") {
out["service_tier"] = "priority"
}
// Ultrafast only the ChatGPT backend offers
if r.Ultrafast && host == "chatgpt.com" {
out["service_tier"] = "ultrafast"
}
if r.OwnTier && r.Tier != "" {
out["service_tier"] = r.Tier
}
if r.Effort != "" {
out["reasoning"] = map[string]any{"effort": r.Effort, "summary": "auto"}
} else if r.Thinking {
out["reasoning"] = map[string]any{"summary": "auto"}
}
// the client's include goes on as the request would have without
// magpie. Sealed reasoning is asked for only with reasoning, as Codex
// asks for it: OpenAI refuses it of a model that doesn't reason. What
// comes back sealed goes to a Responses client as it came, and the
// input's goes back to a Responses upstream, as it would without magpie
// (#1445); an account or vendor that can't read another's turns it away,
// and is asked again without it (foreignReasoning, withoutRefused).
// Output token replay's include is OpenAI's alone, as Codex sends it
// (forVendor): Copilot refuses it (echo_ts).
var include []string
for _, v := range r.Include {
if v == "" || slices.Contains(include, v) || (v == "reasoning.encrypted_content" && out["reasoning"] == nil) ||
v == outputReplay && host != "chatgpt.com" && host != "api.openai.com" {
continue
}
include = append(include, v)
}
if len(r.Tools) > 0 || r.WebSearch {
var tools []map[string]any
for _, t := range r.Tools {
if placed[t.Name] {
continue // offered where it was loaded
}
tools = append(tools, responsesTool(t))
}
if r.WebSearch {
tools = append(tools, map[string]any{"type": "web_search"})
// the pages it found, which a client of another protocol is
// told of (OpenAI's option; xAI's API isn't known to take it)
if host != "api.x.ai" && !slices.Contains(include, "web_search_call.action.sources") {
include = append(include, "web_search_call.action.sources")
}
}
if len(tools) > 0 {
out["tools"] = tools
}
switch {
case r.ToolChoice == "auto" || r.ToolChoice == "none" || r.ToolChoice == "required":
out["tool_choice"] = r.ToolChoice
case strings.HasPrefix(r.ToolChoice, "name:"):
out["tool_choice"] = map[string]any{"type": "function", "name": strings.TrimPrefix(r.ToolChoice, "name:")}
}
if r.Parallel != nil {
out["parallel_tool_calls"] = *r.Parallel
}
} else if r.ToolChoice == "none" {
// tools turned off with none declared (Chat's "none", Anthropic's
// {"type":"none"}, Gemini's NONE) still says so here, as a
// Responses client's own request would, for a provider plugin that
// adds a server-side tool (Grok's x_search) to tell it from no
// choice (#3110). Only a plugin is sent it (the gateway leaves it
// out for a vendor, which has no use for it: xAI turns it away).
out["tool_choice"] = "none"
}
if len(include) > 0 {
out["include"] = include
}
b, _ := marshalBody(out, "input")
// a call the client left unanswered (a turn it interrupted) gets its
// synthetic result, as buildChat's pairToolMessages and
// buildAnthropic's pairToolBlocks give one: the Responses API refuses
// the lone call, "No tool output found for function call <id>", on
// every turn after it too (#2222)
return pairToolItems(b)
}
// responsesTool is t as a Responses function tool. strict is said, as
// Codex says it: left out, the ChatGPT backend holds the schema to strict
// mode's rules and refuses a pattern with a lookaround (MiniMax Code's
// path, #383).
func responsesTool(t Tool) map[string]any {
tool := map[string]any{"type": "function", "name": t.Name, "description": t.Description, "strict": t.Strict}
if len(t.Schema) > 0 {
tool["parameters"] = t.Schema
}
return tool
}
type rUsage struct {
InputTokens int `json:"input_tokens"`
OutputTokens int `json:"output_tokens"`
TotalTokens int `json:"total_tokens"`
InputTokensDetails struct {
CachedTokens int `json:"cached_tokens"`
// what was written to the cache, which Codex reads too (#589)
CacheWriteTokens int `json:"cache_write_tokens"`
} `json:"input_tokens_details"`
OutputTokensDetails struct {
ReasoningTokens int `json:"reasoning_tokens"`
} `json:"output_tokens_details"`
}
// usage: input_tokens is the whole prompt, what was read from the cache and
// what was written to it among it.
func (u rUsage) usage() Usage {
d := u.InputTokensDetails
return Usage{Input: max(u.InputTokens-d.CachedTokens-d.CacheWriteTokens, 0), Output: u.OutputTokens,
CacheRead: d.CachedTokens, CacheWrite: d.CacheWriteTokens, Reasoning: u.OutputTokensDetails.ReasoningTokens}
}
func (u Usage) responses() map[string]any {
in := u.prompt()
return map[string]any{"input_tokens": in, "output_tokens": u.Output, "total_tokens": in + u.Output,
"input_tokens_details": map[string]any{"cached_tokens": u.CacheRead, "cache_write_tokens": u.CacheWrite},
"output_tokens_details": map[string]any{"reasoning_tokens": u.Reasoning}}
}
// responsesDecoder turns a Responses stream into events.
//
// A function call's arguments are given as their deltas come: a model
// writing a patch or a command for minutes is seen writing it (echo_ts on
// Discord: Codex on Copilot, translated for its web_search, saw nothing
// until the call was done). The deltas can leave out what the finished
// call holds (#613: Codex's spawn_agent came back with arguments {} where
// the request was translated, though the upstream's finished call had
// them), and what was sent of a call's arguments can't be taken back. So
// the deltas that would make the arguments whole JSON wait for the call's
// done events (jsonWhole), and the call is given what they add to it.
type responsesDecoder struct {
started bool
called bool // a function call was streamed
calling bool // a function call is open
sent strings.Builder // the open call's argument deltas given so far
held string // its deltas since they made whole JSON, not given yet
whole jsonWhole // where its deltas stand in their JSON
full string // the open call's arguments as its done events give them
}
// argsDelta gives an open call's argument delta, or holds it when with
// it the deltas are whole JSON, which the done events may yet replace.
func (d *responsesDecoder) argsDelta(delta string, emit func(Event)) {
if d.whole.feed(delta) {
d.held += delta
return
}
text := d.held + delta
d.held = ""
d.sent.WriteString(text)
if text != "" {
emit(Event{Kind: KToolArgs, Text: text})
}
}
// endCall gives the rest of the open call's arguments: what was held, or
// what its done events give past what was sent where they hold more.
func (d *responsesDecoder) endCall(emit func(Event)) {
if !d.calling {
return
}
d.calling = false
sent := d.sent.String()
rest := d.held
if args := pickArgs(sent+d.held, d.full); strings.HasPrefix(args, sent) {
rest = args[len(sent):]
}
d.sent.Reset()
d.held, d.full, d.whole = "", "", jsonWhole{}
if rest != "" {
emit(Event{Kind: KToolArgs, Text: rest})
}
}
// jsonWhole follows a stream of JSON text, a piece at a time, for whether
// what came so far is a whole object or array.
type jsonWhole struct {
depth int
str, esc bool
began bool
}
// feed reads the next piece and says whether the text is whole after it.
func (j *jsonWhole) feed(s string) bool {
for i := 0; i < len(s); i++ {
c := s[i]
switch {
case j.esc:
j.esc = false
case j.str:
if c == '\\' {
j.esc = true
} else if c == '"' {
j.str = false
}
case c == '"':
j.str = true
if j.depth == 0 {
j.began = false
}
case c == '{' || c == '[':
j.depth++
j.began = true
case c == '}' || c == ']':
j.depth--
case c != ' ' && c != '\t' && c != '\n' && c != '\r' && j.depth == 0:
j.began = false // a value that isn't one, or after one
}
}
return j.began && j.depth == 0 && !j.str
}
// pickArgs is the fuller of a call's arguments as streamed and as its done
// events give them, JSON first.
func pickArgs(streamed, done string) string {
s, f := strings.TrimSpace(streamed), strings.TrimSpace(done)
switch sv, fv := json.Valid([]byte(s)), json.Valid([]byte(f)); {
case fv && (!sv || len(f) > len(s)):
return done
case sv || f == "":
return streamed
default:
return done
}
}
func (d *responsesDecoder) decode(data string, emit func(Event)) error {
var ev struct {
Type string `json:"type"`
Delta string `json:"delta"`
Item rItem `json:"item"`
// function_call_arguments.done's
Arguments string `json:"arguments"`
Response struct {
ID string `json:"id"`
Model string `json:"model"`
Status string `json:"status"`
Usage rUsage `json:"usage"`
IncompleteDetails *struct {
Reason string `json:"reason"`
} `json:"incomplete_details"`
Error *struct {
Message string `json:"message"`
} `json:"error"`
Output []rItem `json:"output"`
} `json:"response"`
Error *struct {
Message string `json:"message"`
} `json:"error"`
Message string `json:"message"`
}
if err := decodeJSON([]byte(data), &ev); err != nil {
// an error in a shape of its own is still the reply's end (#1933)
if e, ok := carriedError(data); ok {
d.endCall(emit)
emit(e)
}
return nil
}
switch ev.Type {
case "response.created":
if !d.started {
d.started = true
emit(Event{Kind: KStart, MsgID: ev.Response.ID, Model: ev.Response.Model})
}
case "response.output_item.added":
d.endCall(emit)
if ev.Item.Type == "function_call" {
d.called, d.calling = true, true
emit(Event{Kind: KToolStart, ID: ev.Item.CallID, Name: ev.Item.Name})
}
if ev.Item.Type == "reasoning" {
// an item of its own, by the id the upstream gave it (#1445)
emit(Event{Kind: KThinkStart, ID: ev.Item.ID})
}
case "response.output_text.delta":
d.endCall(emit)
emit(Event{Kind: KText, Text: ev.Delta})
case "response.reasoning_summary_text.delta", "response.reasoning_text.delta":
d.endCall(emit)
emit(Event{Kind: KThink, Text: ev.Delta})
case "response.function_call_arguments.delta":
if d.calling {
d.argsDelta(ev.Delta, emit)
} else {
emit(Event{Kind: KToolArgs, Text: ev.Delta})
}
case "response.function_call_arguments.done":
if d.calling && ev.Arguments != "" {
d.full = ev.Arguments
}
case "response.output_item.done":
if ev.Item.Type == "function_call" {
if ev.Item.Arguments != "" {
d.full = string(ev.Item.Arguments)
}
d.endCall(emit)
}
if ev.Item.Type == "reasoning" && ev.Item.EncryptedContent != "" {
// sealed: the item as the upstream wrote it, for a Responses
// client and for its next request (#1445)
var whole struct {
Item json.RawMessage `json:"item"`
}
if decodeJSON([]byte(data), &whole) == nil && len(whole.Item) > 0 {
emit(Event{Kind: KSealed, Name: sealResponses, ID: ev.Item.ID, Text: string(whole.Item)})
}
}
if a := ev.Item.Action; ev.Item.Type == "web_search_call" && a != nil && a.Query != "" {
var hits []Hit
for _, src := range a.Sources {
if src.URL != "" {
hits = append(hits, Hit{Title: src.URL, URL: src.URL})
}
}
emit(Event{Kind: KSearch, Text: a.Query, Hits: hits})
}
case "response.completed", "response.incomplete", "response.failed":
d.endCall(emit)
if ev.Response.Error != nil || ev.Type == "response.failed" || ev.Response.Status == "failed" {
// a failed response is an error with or without the words
// for it, never a whole reply (#1933)
msg := ""
if ev.Response.Error != nil {
msg = ev.Response.Error.Message
}
status, said := requestRefused(data)
code, fs, fsaid := filterRefused(data)
if status == 0 {
status, said = fs, fsaid
}
emit(Event{Kind: KError, Text: cmp.Or(msg, streamErrorText(data)), Code: code, Status: status, Said: said})
return nil
}
stop := "stop"
if ev.Response.Status == "incomplete" {
stop = "length"
if ev.Response.IncompleteDetails != nil && ev.Response.IncompleteDetails.Reason == "content_filter" {
stop = "filter"
}
} else if d.called {
// the ChatGPT backend's completed response lists no output
stop = "tool"
} else {
for _, it := range ev.Response.Output {
if it.Type == "function_call" {
stop = "tool"
}
}
}
emit(Event{Kind: KStop, Stop: stop})
emit(Event{Kind: KUsage, Usage: ev.Response.Usage.usage()})
case "error":
d.endCall(emit)
msg := ev.Message
if ev.Error != nil {
msg = cmp.Or(ev.Error.Message, msg)
}
status, said := requestRefused(data)
code, fs, fsaid := filterRefused(data)
if status == 0 {
status, said = fs, fsaid
}
emit(Event{Kind: KError, Text: cmp.Or(msg, streamErrorText(data)), Code: code, Status: status, Said: said})
}
return nil
}
// requestRefused is 400 and the vendor's error, as {"error":{…}}, when a
// Responses stream's error event or failed response says the request
// itself is at fault (type invalid_request_error): the ChatGPT backend
// answers an access program the workspace doesn't have with a 200 stream
// whose error event is access_program_not_enabled (magpie-releases#18).
// Asked again, on this account or another, it is refused the same way, so
// it is neither retried nor resumed, and a client answered whole gets its
// code and param. Read by the error object's type, never by its words.
func requestRefused(data string) (int, json.RawMessage) {
for _, path := range []string{"error", "response.error"} {
e := gjson.Get(data, path)
if e.IsObject() && e.Get("type").String() == "invalid_request_error" {
return http.StatusBadRequest, json.RawMessage(`{"error":` + e.Raw + `}`)
}
}
return 0, nil
}
// saidError puts the type, code and param of the vendor's own error (an
// Event's Said) on the error a stream encoder writes, so a request the
// vendor refused reads as refused (invalid_request_error) to the agent and
// to the hold that decides whether to ask again, not as magpie's api_error
// (magpie-releases#18). Without Said it is left as it was.
func saidError(failed map[string]any, said json.RawMessage) {
e := gjson.GetBytes(said, "error")
for _, k := range []string{"type", "code", "param"} {
if v := e.Get(k); v.Type == gjson.String && v.String() != "" {
failed[k] = v.String()
}
}
}
// responsesEncoder writes events as a Responses stream. Codex reads the
// full item from output_item.done and usage from response.completed.
type responsesEncoder struct {
w *sseWriter
model string
id string
created int64
seq int
started bool
item int // index of the open output item
open Kind // kind of the open item
itemID string // id of the open item
text strings.Builder // text of the open message / reasoning
// a reasoning item began upstream (KThinkStart): the next thinking
// opens an item of its own, by thinkID when the upstream named it
thinkNew bool
thinkID string
// sig is Claude's signature of the open reasoning item's block, which
// its encrypted_content carries back (claudeseal); bare is an item of
// a block signed with no text, opened with no summary part
sig strings.Builder
bare bool
output []any
col collector
named map[string]nsTool // the request's namespaced tools
// call is the open function_call item's id and name, kept here: the
// collector's last part isn't it once a hidden thinking block (signed
// with no text, or redacted) has come after the call (#1786)
call Part
// input reads a custom tool's input out of its call's arguments as
// they come
input customStream
// a message's output_item.done, and the events after it, wait here
// until its phase is known (phase.go, #2437)
heldMsg map[string]any
held []heldEvent
}
type heldEvent struct {
typ string
fields map[string]any
}
// callTo names the tool a function_call item is to as the client knows it:
// a namespaced tool by its name and namespace, not the flat name the model
// used.
func callTo(item map[string]any, name string, named map[string]nsTool) map[string]any {
if q := named[name]; q.Search {
// Codex runs its tool search itself, from the item it knows it by
args, _ := item["arguments"].(string)
delete(item, "name")
item["type"], item["execution"], item["arguments"] = "tool_search_call", "client", parseArgs(args)
} else if q.Custom {
// a custom tool's call carries its free-form input, not arguments
args, _ := item["arguments"].(string)
delete(item, "arguments")
item["type"], item["name"], item["input"] = "custom_tool_call", q.Name, ""
if args != "" {
item["input"] = customInput(args)
}
if q.Namespace != "" {
item["namespace"] = q.Namespace
}
} else if q, ok := named[name]; ok {
item["name"], item["namespace"] = q.Name, q.Namespace
// Nothing magpie serves seals arguments. Codex reads a namespaced call
// without this list as sealed: spawn_agent's message in MultiAgentV2
// would reach the subagent as ciphertext, which is really plain text.
item["encrypted_function_args"] = []any{}
} else {
item["name"] = name
}
return item
}
// itemPrefix is the prefix of a call item's id, by its type: OpenAI turns
// away a tool_search_call or custom_tool_call whose id isn't its own kind
// ("Invalid 'input[98].id': 'fc_…'. Expected an ID that begins with
// 'tsc'", openaiItemPrefix), and Codex hands the item back to it when the
// conversation goes there.
func itemPrefix(item map[string]any) string {
if t, _ := item["type"].(string); openaiItemPrefix[t] != "" {
return openaiItemPrefix[t]
}
return "fc_"
}
func (e *responsesEncoder) send(typ string, fields map[string]any) {
if e.heldMsg != nil {
e.held = append(e.held, heldEvent{typ, fields})
if len(e.held) > heldMost {
e.release("")
}
return
}
e.write(typ, fields)
}
func (e *responsesEncoder) write(typ string, fields map[string]any) {
fields["type"] = typ
fields["sequence_number"] = e.seq
e.seq++
e.w.event(typ, fields)
}
// release sends the waiting message's events, the message given phase
// (or none, for "").
func (e *responsesEncoder) release(phase string) {
if e.heldMsg == nil {
return
}
if phase != "" {
e.heldMsg["phase"] = phase
}
held := e.held
e.heldMsg, e.held = nil, nil
for _, h := range held {
e.write(h.typ, h.fields)
}
}
func (e *responsesEncoder) response(status string, extra map[string]any) map[string]any {
// a list, never null, before any item: Muse Code refuses a stream whose
// response.created has output null (its nil slice in an any isn't nil)
output := e.output
if output == nil {
output = []any{}
}
out := map[string]any{"id": e.id, "object": "response", "created_at": e.created, "status": status,
"model": e.model, "output": output, "parallel_tool_calls": true, "tool_choice": "auto", "tools": []any{}}
for k, v := range extra {
out[k] = v
}
return out
}
func (e *responsesEncoder) start(ev Event) {
if e.started {
return
}
e.started, e.item = true, -1
e.id, e.created = ev.MsgID, time.Now().Unix()
if e.id == "" {
e.id = newID()
}
if !strings.HasPrefix(e.id, "resp_") {
e.id = "resp_" + e.id
}
if ev.Model != "" {
e.model = ev.Model
}
e.send("response.created", map[string]any{"response": e.response("in_progress", nil)})
e.send("response.in_progress", map[string]any{"response": e.response("in_progress", nil)})
}
func (e *responsesEncoder) closeItem() {
e.closeAs(nil)
}
// closeAs closes the open item, as sealed when the upstream wrote it
// whole (a reasoning item it sealed).
func (e *responsesEncoder) closeAs(sealed json.RawMessage) {
if e.open == "" {
return
}
var item any
switch e.open {
case Text:
t := e.text.String()
e.send("response.output_text.done", map[string]any{"item_id": e.itemID, "output_index": e.item, "content_index": 0, "text": t, "logprobs": []any{}})
part := map[string]any{"type": "output_text", "text": t, "annotations": []any{}, "logprobs": []any{}}
e.send("response.content_part.done", map[string]any{"item_id": e.itemID, "output_index": e.item, "content_index": 0, "part": part})
m := map[string]any{"id": e.itemID, "type": "message", "role": "assistant", "status": "completed", "content": []map[string]any{part}}
// its done waits for what comes next to say its phase
e.release(phaseCommentary)
item, e.heldMsg = m, m
case Thinking:
t := e.text.String()
summary := []map[string]any{}
if !e.bare {
e.send("response.reasoning_summary_text.done", map[string]any{"item_id": e.itemID, "output_index": e.item, "summary_index": 0, "text": t})
part := map[string]any{"type": "summary_text", "text": t}
e.send("response.reasoning_summary_part.done", map[string]any{"item_id": e.itemID, "output_index": e.item, "summary_index": 0, "part": part})
summary = append(summary, part)
}
m := map[string]any{"id": e.itemID, "type": "reasoning", "status": "completed", "summary": summary}
if e.sig.Len() > 0 {
// Claude's block, signed, for the next request to give back
m["encrypted_content"] = claudeThinking(t, e.sig.String())
}
item = m
if sealed != nil {
item = sealed
}
case ToolCall:
args := strings.TrimSpace(e.text.String())
if args == "" {
args = "{}"
}
p := e.call
item = callTo(map[string]any{"id": e.itemID, "type": "function_call", "status": "completed", "call_id": p.ID, "arguments": args}, p.Name, e.named)
switch q := e.named[p.Name]; {
case q.Custom:
// as OpenAI ends a custom tool's input deltas
input, _ := item.(map[string]any)["input"].(string)
e.send("response.custom_tool_call_input.done", map[string]any{"item_id": e.itemID, "output_index": e.item, "input": input})
case !q.Search:
e.send("response.function_call_arguments.done", callTo(map[string]any{"item_id": e.itemID, "output_index": e.item, "call_id": p.ID, "arguments": args}, p.Name, e.named))
}
}
e.send("response.output_item.done", map[string]any{"output_index": e.item, "item": item})
e.output = append(e.output, item)
e.open, e.text = "", strings.Builder{}
e.sig, e.bare = strings.Builder{}, false
}
func (e *responsesEncoder) openItem(k Kind, prefix string, item map[string]any) {
e.closeItem()
if k != Thinking {
e.release(phaseCommentary)
}
e.item++
e.open, e.itemID = k, prefix+newID()
if k == Thinking && e.thinkID != "" {
e.itemID = e.thinkID
}
e.thinkNew, e.thinkID = false, ""
item["id"] = e.itemID
item["status"] = "in_progress"
e.send("response.output_item.added", map[string]any{"output_index": e.item, "item": item})
}
func (e *responsesEncoder) event(ev Event) {
if ev.Kind != KStart && !e.started {
e.start(Event{})
}
switch ev.Kind {
case KStart:
e.start(ev)
case KText:
if ev.Text == "" {
return
}
if e.open != Text {
e.openItem(Text, "msg_", map[string]any{"type": "message", "role": "assistant", "content": []any{}})
e.send("response.content_part.added", map[string]any{"item_id": e.itemID, "output_index": e.item, "content_index": 0,
"part": map[string]any{"type": "output_text", "text": "", "annotations": []any{}, "logprobs": []any{}}})
}
e.text.WriteString(ev.Text)
e.send("response.output_text.delta", map[string]any{"item_id": e.itemID, "output_index": e.item, "content_index": 0, "delta": ev.Text, "logprobs": []any{}})
case KThink:
if ev.Text == "" {
return
}
if e.open != Thinking || e.thinkNew || e.bare {
if e.open != Thinking || e.thinkNew {
e.openItem(Thinking, "rs_", map[string]any{"type": "reasoning", "summary": []any{}})
}
e.bare = false
e.send("response.reasoning_summary_part.added", map[string]any{"item_id": e.itemID, "output_index": e.item, "summary_index": 0,
"part": map[string]any{"type": "summary_text", "text": ""}})
}
e.text.WriteString(ev.Text)
e.send("response.reasoning_summary_text.delta", map[string]any{"item_id": e.itemID, "output_index": e.item, "summary_index": 0, "delta": ev.Text})
case KThinkStart:
e.thinkNew, e.thinkID = true, ""
if strings.HasPrefix(ev.ID, "rs_") {
e.thinkID = ev.ID
}
case KSig:
if ev.Name != sealAnthropic || ev.Text == "" {
break // Gemini's, which goes back on its own path
}
if e.open != Thinking || e.thinkNew {
// a block signed with no text in it: an item all the same,
// with no summary, for its signature to come back
e.openItem(Thinking, "rs_", map[string]any{"type": "reasoning", "summary": []any{}})
e.bare = true
}
e.sig.WriteString(ev.Text)
case KSealed:
if ev.Name == sealAnthropic {
// Claude's redacted_thinking: an item with no summary, the
// block whole in its encrypted_content
e.closeItem()
e.item++
e.thinkNew, e.thinkID = false, ""
id := "rs_" + newID()
e.send("response.output_item.added", map[string]any{"output_index": e.item,
"item": map[string]any{"id": id, "type": "reasoning", "status": "in_progress", "summary": []any{}}})
item := map[string]any{"id": id, "type": "reasoning", "status": "completed", "summary": []any{}, "encrypted_content": claudeseal.Seal([]byte(ev.Text))}
e.send("response.output_item.done", map[string]any{"output_index": e.item, "item": item})
e.output = append(e.output, item)
break
}
if ev.Name != sealResponses {
break // another API's, which a Responses client can't read
}
raw := json.RawMessage(ev.Text)
if e.open == Thinking && !e.thinkNew && (ev.ID == "" || ev.ID == e.itemID) {
// the item streamed so far, done as the upstream wrote it
e.closeAs(raw)
break
}
// none of it streamed (no summary): added and done whole
e.closeItem()
e.item++
e.thinkNew, e.thinkID = false, ""
e.send("response.output_item.added", map[string]any{"output_index": e.item, "item": raw})
e.send("response.output_item.done", map[string]any{"output_index": e.item, "item": raw})
e.output = append(e.output, raw)
case KSearch:
// A search arrives whole, after it ran. Tell the client its query
// and sources, as Anthropic's encoder does, without inventing
// earlier in-progress events or citation offsets in the answer.
e.closeItem()
e.release(phaseCommentary)
e.item++
item := responsesSearchItem(ev.Text, ev.Hits)
e.send("response.output_item.added", map[string]any{"output_index": e.item, "item": item})
e.send("response.web_search_call.completed", map[string]any{"output_index": e.item, "item_id": item["id"]})
e.send("response.output_item.done", map[string]any{"output_index": e.item, "item": item})
e.output = append(e.output, item)
case KToolStart:
if ev.ID == "" {
ev.ID = "call_" + newID()
}
// Open (and so close the previous item) before recording this call:
// closeItem reads the previous call's id and name from e.call.
item := callTo(map[string]any{"type": "function_call", "call_id": ev.ID, "arguments": ""}, ev.Name, e.named)
e.openItem(ToolCall, itemPrefix(item), item)
e.call = Part{Kind: ToolCall, ID: ev.ID, Name: ev.Name}
e.input = customStream{}
e.col.add(ev)
return
case KToolArgs:
if e.open == ToolCall && ev.Text != "" {
e.text.WriteString(ev.Text)
switch q := e.named[e.call.Name]; {
case q.Custom:
// a custom tool's input, as it is read out of the
// arguments: what the model writes of a patch is seen as
// it writes it, as from OpenAI
if in := e.input.feed(ev.Text); in != "" {
e.send("response.custom_tool_call_input.delta", map[string]any{"item_id": e.itemID, "output_index": e.item, "delta": in})
}
default:
e.send("response.function_call_arguments.delta", map[string]any{"item_id": e.itemID, "output_index": e.item, "delta": ev.Text})
}
}
case KError:
e.closeItem()
e.release("")
code := "server_error"
if ev.Code != "" {
code = ev.Code
}
failed := map[string]any{"code": code, "message": ev.Text}
saidError(failed, ev.Said)
e.send("response.failed", map[string]any{"response": e.response("failed", map[string]any{"error": failed})})
}
e.col.add(ev)
}
// keepalive is response.in_progress again: Codex's idle timeout counts
// events only, an SSE comment never reaching it, and skips this one.
func (e *responsesEncoder) keepalive() {
if !e.started {
e.start(Event{}) // response.created and response.in_progress
return
}
// past what's waiting: a keepalive held back keeps nothing alive
e.write("response.in_progress", map[string]any{"response": e.response("in_progress", nil)})
}
func (e *responsesEncoder) finish() {
if !e.started {
e.start(Event{})
}
e.closeItem()
res := e.col.finish()
status, typ := "completed", "response.completed"
extra := map[string]any{"usage": res.Usage.responses(), "incomplete_details": nil}
if res.Stop == "length" || res.Stop == "filter" {
status, typ = "incomplete", "response.incomplete"
reason := "max_output_tokens"
if res.Stop == "filter" {
reason = "content_filter"
}
extra["incomplete_details"] = map[string]any{"reason": reason}
}
if status == "completed" {
e.release(phaseFinal)
}
e.release("")
e.send(typ, map[string]any{"response": e.response(status, extra)})
}
// responsesSearchItem keeps a completed search in both Responses reply forms.
// Keep query for older clients and queries for clients using the current API.
func responsesSearchItem(query string, hits []Hit) map[string]any {
sources := make([]map[string]any, 0, len(hits))
for _, h := range hits {
if h.URL != "" {
sources = append(sources, map[string]any{"type": "url", "url": h.URL})
}
}
return map[string]any{
"id": "ws_" + newID(), "type": "web_search_call", "status": "completed",
"action": map[string]any{"type": "search", "query": query, "queries": []string{query}, "sources": sources},
}
}
// renderResponses is the non-streaming reply.
func renderResponses(res Result, model string, named map[string]nsTool) []byte {
output := []any{}
for _, p := range res.Parts {
switch p.Kind {
case Text:
if p.Text == "" && p.Signature != "" {
continue // only Gemini's signature, which is Gemini's
}
output = append(output, map[string]any{"id": "msg_" + newID(), "type": "message", "role": "assistant", "status": "completed",
"content": []map[string]any{{"type": "output_text", "text": p.Text, "annotations": []any{}}}})
case Thinking:
if p.sealedBy(sealResponses) {
// as the upstream wrote it: id, summary, encrypted_content
output = append(output, p.Sealed)
continue
}
if p.sealedBy(sealAnthropic) {
// Claude's redacted_thinking, whole, to come back (claudeseal)
output = append(output, map[string]any{"id": "rs_" + newID(), "type": "reasoning", "status": "completed",
"summary": []any{}, "encrypted_content": claudeseal.Seal(p.Sealed)})
continue
}
claude := p.SignedBy == sealAnthropic && p.Signature != ""
if p.Text == "" && !claude {
continue // another API's sealed thinking, or only its signature
}
summary := []map[string]any{}
if p.Text != "" {
summary = append(summary, map[string]any{"type": "summary_text", "text": p.Text})
}
item := map[string]any{"id": "rs_" + newID(), "type": "reasoning", "status": "completed", "summary": summary}
if claude {
item["encrypted_content"] = claudeThinking(p.Text, p.Signature)
}
output = append(output, item)
case ToolCall:
id := p.ID
if id == "" {
id = "call_" + newID()
}
item := callTo(map[string]any{"type": "function_call", "status": "completed",
"call_id": id, "arguments": argsString(p)}, p.Name, named)
item["id"] = itemPrefix(item) + newID()
output = append(output, item)
case Search:
output = append(output, responsesSearchItem(p.Text, p.Hits))
}
}
id := res.ID
if id == "" {
id = newID()
}
if !strings.HasPrefix(id, "resp_") {
id = "resp_" + id
}
if res.Model != "" {
model = res.Model
}
status := "completed"
var incomplete any
switch res.Stop {
case "length":
status, incomplete = "incomplete", map[string]any{"reason": "max_output_tokens"}
case "filter":
// as the stream says it (#248)
status, incomplete = "incomplete", map[string]any{"reason": "content_filter"}
}
phaseOutput(output, status == "completed")
b, _ := json.Marshal(map[string]any{"id": id, "object": "response", "created_at": time.Now().Unix(), "status": status,
"model": model, "output": output, "usage": res.Usage.responses(), "incomplete_details": incomplete,
"parallel_tool_calls": true, "tool_choice": "auto", "tools": []any{}, "error": nil})
return b
}