Files
CLIProxyAPI/internal/translator/codex/interactions/interactions_codex_request.go
Luis Pater 01b24f1f95 fix(codex): preserve and forward max_output_tokens across request translators
- Update Codex request translators for OpenAI, Claude, Gemini, Interactions, and OpenAI Responses to correctly extract and preserve `max_output_tokens` or equivalent token limit fields.
- Remove automatic deletion of `max_output_tokens` during request cleanup to ensure token limits are respected across execution paths.

Closes: #7230
2026-11-03 20:24:19 +08:00

876 lines
28 KiB
Go

package interactions
import (
"encoding/json"
"fmt"
"strings"
"github.com/MoeForge/moego/ojson"
"github.com/router-for-me/CLIProxyAPI/v8/internal/thinking"
translatorcommon "github.com/router-for-me/CLIProxyAPI/v8/internal/translator/common"
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
)
func ConvertInteractionsRequestToCodex(modelName string, inputRawJSON []byte, stream bool) ([]byte, error) {
return convertInteractionsRequestToCodex(modelName, inputRawJSON, stream)
}
// convertInteractionsRequestToCodex also reports a user turn that was left empty
// because its only attachment has no Codex equivalent.
func convertInteractionsRequestToCodex(modelName string, inputRawJSON []byte, stream bool) ([]byte, error) {
root := util.ParseGJSONBytesNoCopy(inputRawJSON)
outDoc := ojson.NewDocString(`{"model":"","instructions":"","store":false,"input":[]}`)
_ = outDoc.Set("model", modelName)
if stream || root.Get("stream").Bool() {
_ = outDoc.Set("stream", true)
}
copyInteractionsSystemToCodexDoc(outDoc, root)
hasToolChoice := copyInteractionsGenerationConfigToCodexDoc(outDoc, root)
signatureTargetModel := translatorcommon.ResolveCodexReplayTargetModel(modelName, inputRawJSON)
inputItems := translatorcommon.NewRawArrayItems(root.Get("input.#").Int())
errInput := appendInteractionsInputToCodex(&inputItems, root.Get("input"), signatureTargetModel)
translatorcommon.SetRawArrayItemsDoc(outDoc, "input", inputItems)
copyInteractionsToolsToCodexDoc(outDoc, root, hasToolChoice)
copyInteractionsCodexTopLevelDoc(outDoc, root)
ensureInteractionsCodexEncryptedContentIncludeDoc(outDoc, root)
return outDoc.Bytes(), errInput
}
func copyInteractionsSystemToCodexDoc(doc *ojson.Doc, root ojson.Result) {
systemInstruction := root.Get("system_instruction")
if !systemInstruction.Exists() {
systemInstruction = root.Get("systemInstruction")
}
if !systemInstruction.Exists() {
return
}
if systemInstruction.Type == ojson.String {
_ = doc.Set("instructions", systemInstruction.String())
return
}
if text := systemInstruction.Get("text"); text.Exists() && text.Type == ojson.String {
_ = doc.Set("instructions", text.String())
return
}
if parts := systemInstruction.Get("parts"); parts.Exists() && parts.IsArray() {
var builder strings.Builder
parts.ForEach(func(_, part ojson.Result) bool {
text := part.Get("text").String()
if text == "" {
return true
}
if builder.Len() > 0 {
builder.WriteByte('\n')
}
builder.WriteString(text)
return true
})
if builder.Len() > 0 {
_ = doc.Set("instructions", builder.String())
}
}
}
func copyInteractionsGenerationConfigToCodexDoc(doc *ojson.Doc, root ojson.Result) bool {
cfg := root.Get("generation_config")
if !cfg.Exists() {
cfg = root.Get("generationConfig")
}
if !cfg.Exists() {
if reasoning := root.Get("reasoning"); reasoning.Exists() {
_ = doc.SetRawBytes("reasoning", []byte(reasoning.Raw))
}
return false
}
if reasoning := cfg.Get("reasoning"); reasoning.Exists() {
_ = doc.SetRawBytes("reasoning", []byte(reasoning.Raw))
}
if effort := interactionsCodexReasoningEffort(cfg); effort != "" {
_ = doc.Set("reasoning.effort", effort)
}
if summary := interactionsCodexReasoningSummary(cfg); summary != "" {
_ = doc.Set("reasoning.summary", summary)
}
copyRawPaths := []struct {
sourcePath string
targetPath string
}{
{"max_output_tokens", "max_output_tokens"},
{"maxOutputTokens", "max_output_tokens"},
{"max_completion_tokens", "max_output_tokens"},
{"maxCompletionTokens", "max_output_tokens"},
{"max_tokens", "max_output_tokens"},
{"temperature", "temperature"},
{"top_p", "top_p"},
{"topP", "top_p"},
{"presence_penalty", "presence_penalty"},
{"presencePenalty", "presence_penalty"},
{"frequency_penalty", "frequency_penalty"},
{"frequencyPenalty", "frequency_penalty"},
{"parallel_tool_calls", "parallel_tool_calls"},
{"parallelToolCalls", "parallel_tool_calls"},
{"response_format", "response_format"},
{"responseFormat", "response_format"},
{"text", "text"},
{"verbosity", "text.verbosity"},
{"truncation", "truncation"},
{"tool_choice", "tool_choice"},
{"toolChoice", "tool_choice"},
{"service_tier", "service_tier"},
{"serviceTier", "service_tier"},
}
hasToolChoice := false
for _, paths := range copyRawPaths {
if value := cfg.Get(paths.sourcePath); value.Exists() && !doc.Get(paths.targetPath).Exists() {
_ = doc.SetRawBytes(paths.targetPath, []byte(value.Raw))
if paths.targetPath == "tool_choice" {
hasToolChoice = true
}
}
}
return hasToolChoice
}
func interactionsCodexReasoningEffort(cfg ojson.Result) string {
for _, path := range []string{
"thinking_level",
"thinkingLevel",
"thinking_config.thinking_level",
"thinking_config.thinkingLevel",
"thinkingConfig.thinking_level",
"thinkingConfig.thinkingLevel",
"reasoning.effort",
} {
if value := cfg.Get(path); value.Exists() {
effort := strings.ToLower(strings.TrimSpace(value.String()))
if effort != "" {
return effort
}
}
}
for _, path := range []string{
"thinking_budget",
"thinkingBudget",
"thinking_config.thinking_budget",
"thinking_config.thinkingBudget",
"thinkingConfig.thinking_budget",
"thinkingConfig.thinkingBudget",
} {
if value := cfg.Get(path); value.Exists() {
if effort, ok := thinking.ConvertBudgetToLevel(int(value.Int())); ok {
return effort
}
}
}
return ""
}
func interactionsCodexReasoningSummary(cfg ojson.Result) string {
for _, path := range []string{
"thinking_summaries",
"thinkingSummaries",
"reasoning.summary",
} {
if value := cfg.Get(path); value.Type == ojson.String {
summary := strings.ToLower(strings.TrimSpace(value.String()))
switch summary {
case "auto", "none":
return summary
}
}
}
for _, path := range []string{
"include_thoughts",
"includeThoughts",
"thinking_config.include_thoughts",
"thinking_config.includeThoughts",
"thinkingConfig.include_thoughts",
"thinkingConfig.includeThoughts",
} {
switch value := cfg.Get(path); value.Type {
case ojson.True:
return "auto"
case ojson.False:
return "none"
}
}
return ""
}
// appendInteractionsInputToCodex adds the input steps and reports a user turn that
// was left with nothing to send because of an attachment Codex cannot carry.
func appendInteractionsInputToCodex(items *[][]byte, input ojson.Result, modelName string) error {
if !input.Exists() {
return nil
}
if input.Type == ojson.String {
appendInteractionsTextToCodex(items, "user", input.String())
return nil
}
var run translatorcommon.UserRun
emittedSignatures := make(map[string]bool)
if input.IsArray() {
input.ForEach(func(_, step ojson.Result) bool {
appendInteractionsStepToCodex(items, step, "user", &run, modelName, emittedSignatures)
return true
})
} else if steps := input.Get("steps"); steps.Exists() && steps.IsArray() {
defaultRole := interactionsCodexStepRole(input, "user")
steps.ForEach(func(_, step ojson.Result) bool {
appendInteractionsStepToCodex(items, step, defaultRole, &run, modelName, emittedSignatures)
return true
})
} else {
appendInteractionsStepToCodex(items, input, "user", &run, modelName, emittedSignatures)
}
run.End()
return run.Err()
}
// interactionsCodexUserRun returns run for user content. Content of any other
// role closes the open user turn and has no tracker.
func interactionsCodexUserRun(run *translatorcommon.UserRun, role string) *translatorcommon.UserRun {
if role == "user" {
return run
}
run.End()
return nil
}
func appendInteractionsStepToCodex(items *[][]byte, step ojson.Result, defaultRole string, run *translatorcommon.UserRun, modelName string, emittedSignatures map[string]bool) {
if step.Type == ojson.String {
appendInteractionsRoleTextToCodex(items, defaultRole, step.String(), run)
return
}
if steps := step.Get("steps"); steps.Exists() && steps.IsArray() {
role := interactionsCodexStepRole(step, defaultRole)
steps.ForEach(func(_, nested ojson.Result) bool {
appendInteractionsStepToCodex(items, nested, role, run, modelName, emittedSignatures)
return true
})
return
}
stepType := strings.ToLower(strings.TrimSpace(step.Get("type").String()))
switch stepType {
case "function_call":
run.End()
appendInteractionsFunctionCallToCodex(items, step)
case "function_result", "function_call_output":
// A tool result is content the model reads, so it keeps the surrounding user turn.
run.Add()
appendInteractionsFunctionResultToCodex(items, step)
case "model_output", "assistant":
run.End()
appendInteractionsContentToCodexItem(items, step.Get("content"), "assistant", run)
case "thought", "reasoning":
run.End()
appendInteractionsThoughtToCodex(items, step, modelName, emittedSignatures)
case "user_input", "message", "":
role := interactionsCodexStepRole(step, defaultRole)
if content := step.Get("content"); content.Exists() {
appendInteractionsContentToCodexItem(items, content, role, run)
} else if text := step.Get("text"); text.Exists() {
appendInteractionsRoleTextToCodex(items, role, text.String(), run)
}
default:
role := interactionsCodexStepRole(step, defaultRole)
if content := step.Get("content"); content.Exists() {
appendInteractionsContentToCodexItem(items, content, role, run)
} else if text := step.Get("text"); text.Exists() {
appendInteractionsRoleTextToCodex(items, role, text.String(), run)
}
}
}
// appendInteractionsRoleTextToCodex adds a text message; blank text does not keep a user turn alive.
func appendInteractionsRoleTextToCodex(items *[][]byte, role, text string, run *translatorcommon.UserRun) {
appendInteractionsTextToCodex(items, role, text)
userRun := interactionsCodexUserRun(run, role)
if strings.TrimSpace(text) != "" {
userRun.Add()
}
}
func appendInteractionsContentToCodexItem(items *[][]byte, content ojson.Result, role string, run *translatorcommon.UserRun) {
if !content.Exists() {
return
}
if content.Type == ojson.String {
appendInteractionsRoleTextToCodex(items, role, content.String(), run)
return
}
userRun := interactionsCodexUserRun(run, role)
if content.IsArray() {
content.ForEach(func(_, part ojson.Result) bool {
appendInteractionsContentPartToCodex(items, part, role, userRun)
return true
})
return
}
if content.IsObject() {
appendInteractionsContentPartToCodex(items, content, role, userRun)
}
}
// appendInteractionsContentPartToCodex adds one content part. run is nil for
// content that is not user content; for user content it records what is sent and
// what cannot be.
func appendInteractionsContentPartToCodex(items *[][]byte, part ojson.Result, role string, run *translatorcommon.UserRun) {
item := interactionsCodexMessagePart(part, role)
if len(item) == 0 {
if droppedType := translatorcommon.InteractionsAttachmentType(part); droppedType != "" {
run.Drop(droppedType)
}
return
}
appendInteractionsMessagePartToCodex(items, role, item)
if !interactionsCodexIsBlankText(item) {
run.Add()
}
}
// interactionsCodexIsBlankText reports whether a Codex message part is a text part
// holding only whitespace.
func interactionsCodexIsBlankText(item []byte) bool {
parsed := util.ParseGJSONBytesNoCopy(item)
partType := parsed.Get("type").String()
return (partType == "input_text" || partType == "output_text") && strings.TrimSpace(parsed.Get("text").String()) == ""
}
func appendInteractionsFunctionCallToCodex(items *[][]byte, step ojson.Result) {
itemDoc := ojson.NewDocString(`{"type":"function_call"}`)
if name := step.Get("name"); name.Exists() {
_ = itemDoc.Set("name", shortenCodexToolNameIfNeeded(name.String()))
}
if callID := interactionsCodexCallID(step); callID != "" {
_ = itemDoc.Set("call_id", callID)
}
if args := step.Get("arguments"); args.Exists() {
_ = itemDoc.Set("arguments", interactionsCodexJSONString(args))
} else if args := step.Get("args"); args.Exists() {
_ = itemDoc.Set("arguments", interactionsCodexJSONString(args))
}
*items = append(*items, itemDoc.Bytes())
}
func appendInteractionsFunctionResultToCodex(items *[][]byte, step ojson.Result) {
itemDoc := ojson.NewDocString(`{"type":"function_call_output"}`)
if callID := interactionsCodexCallID(step); callID != "" {
_ = itemDoc.Set("call_id", callID)
}
if result := step.Get("result"); result.Exists() {
_ = itemDoc.Set("output", interactionsCodexOutputString(result))
} else if output := step.Get("output"); output.Exists() {
_ = itemDoc.Set("output", interactionsCodexOutputString(output))
}
*items = append(*items, itemDoc.Bytes())
}
func copyInteractionsToolsToCodexDoc(doc *ojson.Doc, root ojson.Result, hasToolChoice bool) {
tools := root.Get("tools")
if !tools.Exists() {
return
}
if !tools.IsArray() {
_ = doc.SetRawBytes("tools", []byte(tools.Raw))
return
}
normalized := make([]map[string]any, 0)
tools.ForEach(func(_, tool ojson.Result) bool {
if decls := tool.Get("function_declarations"); decls.Exists() {
appendCodexToolDeclarations(&normalized, decls)
return true
}
if decls := tool.Get("functionDeclarations"); decls.Exists() {
appendCodexToolDeclarations(&normalized, decls)
return true
}
if name := tool.Get("name"); name.Exists() {
normalized = append(normalized, codexToolFromDeclaration(tool))
}
return true
})
if len(normalized) == 0 {
_ = doc.SetRawBytes("tools", []byte(tools.Raw))
return
}
raw, errMarshal := json.Marshal(normalized)
if errMarshal != nil {
_ = doc.SetRawBytes("tools", []byte(tools.Raw))
return
}
_ = doc.SetRawBytes("tools", raw)
if !hasToolChoice {
_ = doc.Set("tool_choice", "auto")
}
}
func copyInteractionsCodexTopLevelDoc(doc *ojson.Doc, root ojson.Result) {
if !doc.Get("max_output_tokens").Exists() {
for _, path := range []string{
"max_output_tokens",
"maxOutputTokens",
"max_completion_tokens",
"maxCompletionTokens",
"max_tokens",
"agent_config.max_total_tokens",
"agentConfig.maxTotalTokens",
} {
if value := root.Get(path); value.Exists() {
_ = doc.SetRawBytes("max_output_tokens", []byte(value.Raw))
break
}
}
}
if serviceTier := normalizeInteractionsCodexServiceTier(root.Get("service_tier")); serviceTier != "" {
_ = doc.Set("service_tier", serviceTier)
}
if toolChoice := root.Get("tool_choice"); toolChoice.Exists() {
_ = doc.SetRawBytes("tool_choice", []byte(toolChoice.Raw))
}
for _, path := range []string{"parallel_tool_calls", "store", "metadata", "include", "truncation"} {
if value := root.Get(path); value.Exists() {
_ = doc.SetRawBytes(path, []byte(value.Raw))
}
}
}
func setInteractionsCodexRawIfDifferent(out []byte, path string, value ojson.Result) []byte {
current := ojson.GetBytesNoCopy(out, path)
if current.Exists() && current.Raw == value.Raw {
return out
}
updated, errSet := ojson.SetRawBytes(out, path, []byte(value.Raw))
if errSet != nil {
return out
}
return updated
}
// ensureInteractionsCodexEncryptedContentIncludeDoc makes the outbound request
// ask the upstream for encrypted reasoning content so a signature can come
// back for replay.
func ensureInteractionsCodexEncryptedContentIncludeDoc(doc *ojson.Doc, root ojson.Result) {
const reasoningEncryptedContent = "reasoning.encrypted_content"
include := root.Get("include")
if !include.Exists() {
_ = doc.SetRawBytes("include", []byte(`["reasoning.encrypted_content"]`))
return
}
if !include.IsArray() {
return
}
for _, value := range include.Array() {
if value.Type == ojson.String && value.String() == reasoningEncryptedContent {
return
}
}
_ = doc.Set("include.-1", reasoningEncryptedContent)
}
// appendInteractionsThoughtToCodex adds a thought step. A client-echoed
// signature that CodexReplaySignatureForTarget accepts for this request's
// target model is restored as Responses reasoning encrypted_content, with
// the thought text carried as a summary; identical signatures already
// emitted in this request are replayed only once. The step id is
// deliberately not copied onto replay items: replay is stateless and the
// executor strips orphan ids. Every other thought step is dropped entirely:
// a reasoning item without accepted encrypted_content carries no replayable
// state, and the legacy text fallback shape is rejected by both the native
// Meta upstream (missing summary) and routers (content expected array).
func appendInteractionsThoughtToCodex(items *[][]byte, step ojson.Result, modelName string, emittedSignatures map[string]bool) {
text := interactionsCodexContentText(step.Get("content"))
if text == "" {
text = step.Get("text").String()
}
if raw := interactionsThoughtStepSignature(step); raw != "" {
if normalized, ok := translatorcommon.CodexReplaySignatureForTarget(modelName, raw); ok && !emittedSignatures[normalized] {
emittedSignatures[normalized] = true
itemDoc := ojson.NewDocString(`{"type":"reasoning","encrypted_content":"","summary":[]}`)
_ = itemDoc.Set("encrypted_content", normalized)
if text != "" {
summaryPart := []byte(`{"type":"summary_text","text":""}`)
summaryPart, _ = ojson.SetBytes(summaryPart, "text", text)
_ = itemDoc.SetRawBytes("summary", translatorcommon.JoinRawArray([][]byte{summaryPart}))
}
*items = append(*items, itemDoc.Bytes())
}
}
}
// interactionsThoughtStepSignature extracts a thought step's signature under
// any of the field spellings seen on the wire.
func interactionsThoughtStepSignature(step ojson.Result) string {
for _, path := range []string{"signature", "thought_signature", "thoughtSignature"} {
if signature := strings.TrimSpace(step.Get(path).String()); signature != "" {
return signature
}
}
return ""
}
func appendInteractionsTextToCodex(items *[][]byte, role, text string) {
partDoc := ojson.NewDocString(`{"type":"","text":""}`)
if role == "assistant" {
_ = partDoc.Set("type", "output_text")
} else {
_ = partDoc.Set("type", "input_text")
}
_ = partDoc.Set("text", text)
appendInteractionsMessagePartToCodex(items, role, partDoc.Bytes())
}
func appendInteractionsMessagePartToCodex(items *[][]byte, role string, part []byte) {
messageDoc := ojson.NewDocString(`{"type":"message","role":"","content":[]}`)
_ = messageDoc.Set("role", role)
_ = messageDoc.SetRawBytes("content", translatorcommon.JoinRawArray([][]byte{part}))
*items = append(*items, messageDoc.Bytes())
}
func interactionsCodexMessagePart(part ojson.Result, role string) []byte {
if text := part.Get("text"); text.Exists() {
itemDoc := ojson.NewDocString(`{"type":"","text":""}`)
if role == "assistant" {
_ = itemDoc.Set("type", "output_text")
} else {
_ = itemDoc.Set("type", "input_text")
}
_ = itemDoc.Set("text", text.String())
return itemDoc.Bytes()
}
partType := strings.ToLower(strings.TrimSpace(part.Get("type").String()))
switch partType {
case "text", "":
return nil
case "image":
return interactionsCodexImagePart(part)
case "image_url":
item := []byte(`{"type":"input_image","image_url":""}`)
item, _ = ojson.SetBytes(item, "image_url", part.Get("image_url.url").String())
return item
case "audio":
return interactionsCodexAudioPart(part)
case "input_audio":
item := []byte(`{"type":"input_audio","input_audio":{}}`)
if audio := part.Get("input_audio"); audio.Exists() {
item, _ = ojson.SetRawBytes(item, "input_audio", []byte(audio.Raw))
}
return item
case "video", "document", "file":
return interactionsCodexFilePart(part)
default:
if inline := part.Get("inline_data"); inline.Exists() {
return interactionsCodexInlinePart(inline)
}
if inline := part.Get("inlineData"); inline.Exists() {
return interactionsCodexInlinePart(inline)
}
if file := part.Get("file_data"); file.Exists() {
return interactionsCodexFileDataPart(file)
}
if file := part.Get("fileData"); file.Exists() {
return interactionsCodexFileDataPart(file)
}
}
return nil
}
func interactionsCodexImagePart(part ojson.Result) []byte {
// uri is the Interactions spelling of file_uri.
if imageURL := firstNonBlankString(part, "url", "file_uri", "fileUri", "uri"); imageURL != "" {
item := []byte(`{"type":"input_image","image_url":""}`)
item, _ = ojson.SetBytes(item, "image_url", imageURL)
return item
}
mimeType := firstString(part, "mime_type", "mimeType")
data := part.Get("data").String()
if mimeType == "" || data == "" {
return nil
}
item := []byte(`{"type":"input_image","image_url":""}`)
item, _ = ojson.SetBytes(item, "image_url", fmt.Sprintf("data:%s;base64,%s", mimeType, data))
return item
}
func interactionsCodexAudioPart(part ojson.Result) []byte {
mimeType := firstString(part, "mime_type", "mimeType")
data := part.Get("data").String()
if mimeType == "" || data == "" {
return nil
}
itemDoc := ojson.NewDocString(`{"type":"input_audio","input_audio":{"data":"","format":""}}`)
_ = itemDoc.Set("input_audio.data", data)
_ = itemDoc.Set("input_audio.format", codexInputAudioFormatFromMIME(mimeType))
return itemDoc.Bytes()
}
func interactionsCodexFilePart(part ojson.Result) []byte {
if fileData := part.Get("file.file_data").String(); fileData != "" {
itemDoc := ojson.NewDocString(`{"type":"input_file","file_data":"","filename":""}`)
_ = itemDoc.Set("file_data", fileData)
_ = itemDoc.Set("filename", part.Get("file.filename").String())
return itemDoc.Bytes()
}
mimeType := firstString(part, "mime_type", "mimeType")
// uri is the Interactions spelling of file_uri.
if fileURI := firstNonBlankString(part, "file_uri", "fileUri", "uri", "url"); fileURI != "" {
itemDoc := ojson.NewDocString(`{"type":"input_file","file_url":"","filename":""}`)
_ = itemDoc.Set("file_url", fileURI)
_ = itemDoc.Set("filename", codexFileNameFromMIME(mimeType))
return itemDoc.Bytes()
}
data := part.Get("data").String()
if mimeType == "" || data == "" {
return nil
}
itemDoc := ojson.NewDocString(`{"type":"input_file","file_data":"","filename":""}`)
_ = itemDoc.Set("file_data", data)
_ = itemDoc.Set("filename", codexFileNameFromMIME(mimeType))
return itemDoc.Bytes()
}
func interactionsCodexInlinePart(inline ojson.Result) []byte {
mimeType := firstString(inline, "mime_type", "mimeType")
data := inline.Get("data").String()
if mimeType == "" || data == "" {
return nil
}
switch {
case strings.HasPrefix(strings.ToLower(mimeType), "image/"):
return interactionsCodexImagePart(ojson.Parse(fmt.Sprintf(`{"mime_type":%q,"data":%q}`, mimeType, data)))
case strings.HasPrefix(strings.ToLower(mimeType), "audio/"):
return interactionsCodexAudioPart(ojson.Parse(fmt.Sprintf(`{"mime_type":%q,"data":%q}`, mimeType, data)))
default:
return interactionsCodexFilePart(ojson.Parse(fmt.Sprintf(`{"mime_type":%q,"data":%q}`, mimeType, data)))
}
}
func interactionsCodexFileDataPart(fileData ojson.Result) []byte {
mimeType := firstString(fileData, "mime_type", "mimeType")
fileURI := firstString(fileData, "file_uri", "fileUri")
if fileURI == "" {
return nil
}
if strings.HasPrefix(strings.ToLower(mimeType), "image/") {
item := []byte(`{"type":"input_image","image_url":""}`)
item, _ = ojson.SetBytes(item, "image_url", fileURI)
return item
}
itemDoc := ojson.NewDocString(`{"type":"input_file","file_url":"","filename":""}`)
_ = itemDoc.Set("file_url", fileURI)
_ = itemDoc.Set("filename", codexFileNameFromMIME(mimeType))
return itemDoc.Bytes()
}
func appendCodexToolDeclarations(normalized *[]map[string]any, declarations ojson.Result) {
if !declarations.IsArray() {
return
}
declarations.ForEach(func(_, declaration ojson.Result) bool {
if declaration.Get("name").Exists() {
*normalized = append(*normalized, codexToolFromDeclaration(declaration))
}
return true
})
}
func codexToolFromDeclaration(declaration ojson.Result) map[string]any {
tool := map[string]any{
"type": "function",
"name": shortenCodexToolNameIfNeeded(declaration.Get("name").String()),
"strict": false,
}
if desc := declaration.Get("description"); desc.Exists() {
tool["description"] = desc.String()
}
if params := declaration.Get("parameters"); params.Exists() {
tool["parameters"] = cleanedCodexToolParameters(params)
} else if params := declaration.Get("parametersJsonSchema"); params.Exists() {
tool["parameters"] = cleanedCodexToolParameters(params)
} else if params := declaration.Get("parameters_json_schema"); params.Exists() {
tool["parameters"] = cleanedCodexToolParameters(params)
}
return tool
}
func cleanedCodexToolParameters(params ojson.Result) json.RawMessage {
hasSchema := params.Get("$schema").Exists()
needsAdditionalProps := params.Get("additionalProperties").Type != ojson.False
if !hasSchema && !needsAdditionalProps {
return json.RawMessage(params.Raw)
}
doc := ojson.NewDocString(params.Raw)
if hasSchema {
_ = doc.Delete("$schema")
}
if needsAdditionalProps {
_ = doc.Set("additionalProperties", false)
}
return json.RawMessage(doc.Bytes())
}
func interactionsCodexContentText(content ojson.Result) string {
if !content.Exists() {
return ""
}
if content.Type == ojson.String {
return content.String()
}
if content.IsObject() {
return content.Get("text").String()
}
if content.IsArray() {
var builder strings.Builder
content.ForEach(func(_, part ojson.Result) bool {
text := part.Get("text").String()
if text == "" {
return true
}
if builder.Len() > 0 {
builder.WriteByte('\n')
}
builder.WriteString(text)
return true
})
return builder.String()
}
return ""
}
func interactionsCodexCallID(step ojson.Result) string {
if callID := strings.TrimSpace(step.Get("call_id").String()); callID != "" {
return callID
}
return strings.TrimSpace(step.Get("id").String())
}
func interactionsCodexJSONString(value ojson.Result) string {
if value.Type == ojson.String {
return value.String()
}
if value.Exists() {
return value.Raw
}
return "{}"
}
func interactionsCodexOutputString(value ojson.Result) string {
if value.Type == ojson.String {
return value.String()
}
if value.Exists() {
return value.Raw
}
return ""
}
// interactionsCodexStepRole resolves the Codex role of a step. A step that
// carries system or developer content, named by its role or by its type, is
// developer content: it closes the open user turn and never keeps an emptied one
// alive. Any other step uses its own role, then the role it inherits.
func interactionsCodexStepRole(step ojson.Result, inherited string) string {
if translatorcommon.IsInteractionsInstructionStep(step, inherited == "developer") {
return "developer"
}
return interactionsCodexDefaultRole(step.Get("role").String(), inherited)
}
func interactionsCodexDefaultRole(role, fallback string) string {
switch strings.ToLower(strings.TrimSpace(role)) {
case "model", "assistant":
return "assistant"
case "developer", "system":
return "developer"
case "user":
return "user"
}
if fallback == "assistant" || fallback == "developer" {
return fallback
}
return "user"
}
func normalizeInteractionsCodexServiceTier(serviceTier ojson.Result) string {
if !serviceTier.Exists() || serviceTier.Type != ojson.String {
return ""
}
switch strings.ToLower(strings.TrimSpace(serviceTier.String())) {
case "priority", "fast":
return "priority"
}
return ""
}
func codexInputAudioFormatFromMIME(mimeType string) string {
switch strings.ToLower(strings.TrimSpace(mimeType)) {
case "audio/wav", "audio/wave", "audio/x-wav":
return "wav"
case "audio/flac":
return "flac"
case "audio/opus", "audio/ogg":
return "opus"
case "audio/pcm", "audio/l16":
return "pcm16"
default:
return "mp3"
}
}
func codexFileNameFromMIME(mimeType string) string {
switch strings.ToLower(strings.TrimSpace(mimeType)) {
case "application/pdf":
return "document.pdf"
case "text/plain":
return "document.txt"
case "text/csv":
return "document.csv"
case "application/json":
return "document.json"
case "application/xml", "text/xml":
return "document.xml"
default:
if strings.HasPrefix(strings.ToLower(strings.TrimSpace(mimeType)), "video/") {
return "video"
}
return "document"
}
}
func shortenCodexToolNameIfNeeded(name string) string {
const limit = 64
if len(name) <= limit {
return name
}
if strings.HasPrefix(name, "mcp__") {
idx := strings.LastIndex(name, "__")
if idx > 0 {
candidate := "mcp__" + name[idx+2:]
if len(candidate) > limit {
return candidate[:limit]
}
return candidate
}
}
return name[:limit]
}
// firstNonBlankString returns the first non-blank string found at paths.
func firstNonBlankString(root ojson.Result, paths ...string) string {
for _, path := range paths {
if value := strings.TrimSpace(root.Get(path).String()); value != "" {
return value
}
}
return ""
}
func firstString(root ojson.Result, paths ...string) string {
for _, path := range paths {
if value := root.Get(path); value.Exists() {
return value.String()
}
}
return ""
}