lywsvip/CLIProxyAPI
1
0
Fork 0
mirror of https://github.com/router-for-me/CLIProxyAPI.git synced 2026-09-09 17:42:08 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
35a4723872a4a04aef053ba290eb362ccdf14d07
CLIProxyAPI/internal/runtime/executor/helps/codex_tool_schema_test.go
Luis Pater bf20b999de fix(codex): simplify complex tool schema unions and detect empty incomplete responses 
- Normalize complex constant `oneOf` and `anyOf` tool parameter schemas into equivalent enums to prevent upstream aborts.
- Escape property keys containing dots and colons during schema updates to prevent invalid path splitting.
- Identify terminal `response.incomplete` events with zero output tokens and no content as upstream failures.

Closes: #5551
2026-09-07 20:09:29 +08:00

494 lines
14 KiB
Go
Raw Blame History

package helps
import (
"testing"
"github.com/tidwall/gjson"
)
func TestNormalizeCodexToolSchemas_ComplexOneOfSimplified_PreservesProperties(t *testing.T) {
// Minimal repro from issue #5551: 13-branch oneOf inside a property schema
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "t1",
"description": "test tool",
"strict": true,
"parameters": {
"type": "object",
"properties": {
"action": {
"type": "string",
"enum": ["p.list","m.list","s.list","s.create","s.send","s.fork","s.status","s.messages","sch.list","sch.create","sch.run","sch.delete","sch.toggle"],
"oneOf": [
{"const": "p.list", "description": "List projects"},
{"const": "m.list", "description": "List models"},
{"const": "s.list", "description": "List sessions"},
{"const": "s.create", "description": "Create session"},
{"const": "s.send", "description": "Send prompt"},
{"const": "s.fork", "description": "Fork session"},
{"const": "s.status", "description": "Session status"},
{"const": "s.messages", "description": "Session messages"},
{"const": "sch.list", "description": "List schedule"},
{"const": "sch.create", "description": "Create schedule"},
{"const": "sch.run", "description": "Run schedule"},
{"const": "sch.delete", "description": "Delete schedule"},
{"const": "sch.toggle", "description": "Toggle schedule"}
],
"description": "Action to perform"
},
"target": {
"type": "string",
"description": "Target ID"
}
},
"required": ["action"]
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
// Complex oneOf must be removed from action property
if tool.Get("parameters.properties.action.oneOf").Exists() {
t.Fatalf("expected oneOf to be removed from action property, got: %s", tool.Get("parameters").Raw)
}
// Action type and enum must be PRESERVED
if tool.Get("parameters.properties.action.type").String() != "string" {
t.Fatalf("expected action.type = string, got: %s", tool.Get("parameters.properties.action.type").String())
}
enumArr := tool.Get("parameters.properties.action.enum").Array()
if len(enumArr) != 13 {
t.Fatalf("expected action.enum to retain all 13 items, got %d", len(enumArr))
}
// Sibling property 'target' must be PRESERVED
if tool.Get("parameters.properties.target.type").String() != "string" {
t.Fatalf("sibling property 'target' was deleted or altered")
}
// 'required' array must be PRESERVED
if tool.Get("parameters.required.0").String() != "action" {
t.Fatalf("required list was deleted or altered")
}
// Tool name and strict mode preserved
if tool.Get("name").String() != "t1" {
t.Fatalf("name should be preserved as t1, got: %s", tool.Get("name").String())
}
if !tool.Get("strict").Bool() {
t.Fatalf("strict should remain true since schema is still strictly typed")
}
}
func TestNormalizeCodexToolSchemas_DottedPropertyName(t *testing.T) {
// A property whose key contains a dot (e.g. "my.action") must not be split into nested paths
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "dotted_tool",
"parameters": {
"type": "object",
"properties": {
"my.action": {
"type": "string",
"enum": ["1", "2", "3", "4", "5", "6", "7", "8"],
"oneOf": [
{"const": "1"}, {"const": "2"}, {"const": "3"}, {"const": "4"},
{"const": "5"}, {"const": "6"}, {"const": "7"}, {"const": "8"}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
// Ensure properties contains "my.action", NOT nested object "my": {"action": ...}
tool := gjson.GetBytes(out, "tools.0")
dottedProp := tool.Get(`parameters.properties.my\.action`)
if !dottedProp.Exists() {
t.Fatalf("expected my.action property to exist with escaped key, got parameters: %s", tool.Get("parameters").Raw)
}
if dottedProp.Get("oneOf").Exists() {
t.Fatalf("oneOf should be removed from my.action")
}
if dottedProp.Get("type").String() != "string" {
t.Fatalf("type should be string")
}
// Verify that "my" was NOT created as an object containing "action"
if tool.Get("parameters.properties.my.action").Exists() {
t.Fatalf("my.action was incorrectly split into nested path parameters.properties.my.action")
}
}
func TestNormalizeCodexToolSchemas_ColonPropertyName(t *testing.T) {
// A property whose key starts with or contains a colon (e.g. ":action") must not be interpreted as control syntax
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "colon_tool",
"parameters": {
"type": "object",
"properties": {
":action": {
"type": "string",
"enum": ["1", "2", "3", "4", "5", "6", "7", "8"],
"oneOf": [
{"const": "1"}, {"const": "2"}, {"const": "3"}, {"const": "4"},
{"const": "5"}, {"const": "6"}, {"const": "7"}, {"const": "8"}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
colonProp := tool.Get(`parameters.properties.\:action`)
if !colonProp.Exists() {
t.Fatalf("expected :action property to exist with escaped colon, got parameters: %s", tool.Get("parameters").Raw)
}
if colonProp.Get("oneOf").Exists() {
t.Fatalf("oneOf should be removed from :action")
}
if tool.Get("parameters.properties.action").Exists() {
t.Fatalf(":action was incorrectly written to action without colon")
}
}
func TestNormalizeCodexToolSchemas_NumericDuplicateConstNotTouched(t *testing.T) {
// 1 and 1.0 are mathematically equal in JSON Schema. Having both in oneOf violates exclusivity.
// Because exclusivity cannot be proven, the union must remain completely untouched.
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "num_dup_tool",
"parameters": {
"type": "object",
"properties": {
"val": {
"type": "number",
"oneOf": [
{"const": 1}, {"const": 1.0}, {"const": 2}, {"const": 3},
{"const": 4}, {"const": 5}, {"const": 6}, {"const": 7}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if !tool.Get("parameters.properties.val.oneOf").Exists() {
t.Fatalf("oneOf with numeric duplicates (1 and 1.0) must NOT be transformed to enum")
}
}
func TestNormalizeCodexToolSchemas_LargeIntegerPrecisionPreserved(t *testing.T) {
// Number larger than 2^53 (53 bits of mantissa in float64) must not lose precision
largeInt := "9007199254740993"
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "large_int_tool",
"parameters": {
"type": "object",
"properties": {
"id": {
"type": "integer",
"oneOf": [
{"const": ` + largeInt + `},
{"const": 1}, {"const": 2}, {"const": 3},
{"const": 4}, {"const": 5}, {"const": 6}, {"const": 7}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if tool.Get("parameters.properties.id.oneOf").Exists() {
t.Fatalf("oneOf should be deleted")
}
// Raw string of first enum item must preserve exact large integer digits without float rounding
firstEnumItem := tool.Get("parameters.properties.id.enum.0").Raw
if firstEnumItem != largeInt {
t.Fatalf("large integer precision was lost: got %s, want %s", firstEnumItem, largeInt)
}
}
func TestNormalizeCodexToolSchemas_UnicodeDuplicateConstNotTouched(t *testing.T) {
// Branch containing "\u0061" and branch containing "a" have the same semantic string value.
// In oneOf this violates exclusivity; because it's not pure distinct constants, keep untouched.
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "dup_tool",
"parameters": {
"type": "object",
"properties": {
"val": {
"type": "string",
"oneOf": [
{"const": "a"}, {"const": "\u0061"}, {"const": "c"}, {"const": "d"},
{"const": "e"}, {"const": "f"}, {"const": "g"}, {"const": "h"}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if !tool.Get("parameters.properties.val.oneOf").Exists() {
t.Fatalf("oneOf with duplicate semantic values must NOT be transformed to enum")
}
}
func TestNormalizeCodexToolSchemas_TypePreservingComparison(t *testing.T) {
// Existing enum contains strings ["1", ..., "8"], but oneOf contains numbers [1, ..., 8].
// Because JSON types differ, they must NOT be treated as identical and must remain untouched.
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "type_tool",
"parameters": {
"type": "object",
"properties": {
"val": {
"enum": ["1", "2", "3", "4", "5", "6", "7", "8"],
"oneOf": [
{"const": 1}, {"const": 2}, {"const": 3}, {"const": 4},
{"const": 5}, {"const": 6}, {"const": 7}, {"const": 8}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if !tool.Get("parameters.properties.val.oneOf").Exists() {
t.Fatalf("oneOf must NOT be deleted when enum strings do not match const numbers")
}
}
func TestNormalizeCodexToolSchemas_BothOneOfAndAnyOfUntouched(t *testing.T) {
// A property with BOTH oneOf and anyOf must be left completely untouched
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "compound_tool",
"parameters": {
"type": "object",
"properties": {
"val": {
"oneOf": [
{"const": "1"}, {"const": "2"}, {"const": "3"}, {"const": "4"},
{"const": "5"}, {"const": "6"}, {"const": "7"}, {"const": "8"}
],
"anyOf": [
{"const": "5"}, {"const": "6"}, {"const": "7"}, {"const": "8"},
{"const": "9"}, {"const": "10"}, {"const": "11"}, {"const": "12"}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if !tool.Get("parameters.properties.val.oneOf").Exists() || !tool.Get("parameters.properties.val.anyOf").Exists() {
t.Fatalf("compound oneOf+anyOf property must not be modified")
}
}
func TestNormalizeCodexToolSchemas_MigratesConstBranchesToEnum(t *testing.T) {
// Property has oneOf with 10 const branches, but no enum field
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "t2",
"parameters": {
"type": "object",
"properties": {
"mode": {
"type": "string",
"oneOf": [
{"const": "m1"}, {"const": "m2"}, {"const": "m3"}, {"const": "m4"},
{"const": "m5"}, {"const": "m6"}, {"const": "m7"}, {"const": "m8"},
{"const": "m9"}, {"const": "m10"}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if tool.Get("parameters.properties.mode.oneOf").Exists() {
t.Fatalf("oneOf should be deleted")
}
enumArr := tool.Get("parameters.properties.mode.enum").Array()
if len(enumArr) != 10 {
t.Fatalf("expected 10 enum items migrated from const, got %d", len(enumArr))
}
}
func TestNormalizeCodexToolSchemas_NonMatchingEnumNotTouched(t *testing.T) {
// Existing enum has 9 values, while oneOf const branches only cover 8 values.
// Because they are not proven identical, the union must remain completely untouched.
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "t3",
"parameters": {
"type": "object",
"properties": {
"status": {
"type": "string",
"enum": ["1", "2", "3", "4", "5", "6", "7", "8", "extra"],
"oneOf": [
{"const": "1"}, {"const": "2"}, {"const": "3"}, {"const": "4"},
{"const": "5"}, {"const": "6"}, {"const": "7"}, {"const": "8"}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if !tool.Get("parameters.properties.status.oneOf").Exists() {
t.Fatalf("oneOf should NOT be removed when enum set does not match const values set")
}
}
func TestNormalizeCodexToolSchemas_NonConstUnionNotTouched(t *testing.T) {
// Union branches have additional constraints (e.g. pattern, type) and are not pure consts.
// Must remain completely untouched to preserve validation semantics.
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "t4",
"parameters": {
"type": "object",
"properties": {
"data": {
"oneOf": [
{"type": "string", "pattern": "^[a-z]+$"},
{"type": "number", "minimum": 0},
{"type": "boolean"},
{"type": "null"},
{"type": "array"},
{"type": "object"},
{"type": "integer"},
{"type": "string", "pattern": "^[0-9]+$"}
]
}
}
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if !tool.Get("parameters.properties.data.oneOf").Exists() {
t.Fatalf("non-const oneOf must remain untouched")
}
}
func TestNormalizeCodexToolSchemas_SimpleToolPreserved(t *testing.T) {
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "function",
"name": "lookup",
"strict": true,
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string"}
},
"required": ["query"],
"additionalProperties": false
}
}]
}`)
out := NormalizeCodexToolSchemas(input)
tool := gjson.GetBytes(out, "tools.0")
if tool.Get("parameters.properties.query.type").String() != "string" {
t.Fatalf("simple tool should not be modified, got: %s", tool.Get("parameters").Raw)
}
if !tool.Get("strict").Bool() {
t.Fatalf("strict should remain true for simple tool")
}
}
func TestNormalizeCodexToolSchemas_NamespaceToolSimplified(t *testing.T) {
input := []byte(`{
"model": "gpt-5.5",
"tools": [{
"type": "namespace",
"name": "mcp",
"tools": [{
"type": "function",
"name": "complex_tool",
"parameters": {
"type": "object",
"properties": {
"action": {
"type": "string",
"oneOf": [
{"const": "1"}, {"const": "2"}, {"const": "3"}, {"const": "4"},
{"const": "5"}, {"const": "6"}, {"const": "7"}, {"const": "8"}
]
}
}
}
}]
}]
}`)
out := NormalizeCodexToolSchemas(input)
nestedTool := gjson.GetBytes(out, "tools.0.tools.0")
if nestedTool.Get("parameters.properties.action.oneOf").Exists() {
t.Fatalf("nested tool oneOf should be simplified")
}
if len(nestedTool.Get("parameters.properties.action.enum").Array()) != 8 {
t.Fatalf("expected action.enum with 8 items")
}
}
Reference in New Issue View Git Blame Copy Permalink