Add reverse mappings for original tool names and improve error logging

- Introduced reverse mapping logic for tool names in translators to restore original names when shortened.
- Enhanced error handling by logging API response errors consistently across handlers.
- Refactored request and response loggers to include API error details, improving debugging capabilities.
- Integrated robust tool name shortening and uniqueness mechanisms for OpenAI, Gemini, and Claude requests.
- Improved handler retry logic to properly capture and respond to errors.

internal/translator/codex/openai/chat-completions/codex_openai_request.go

@@ -9,6 +9,9 @@ package chat_completions
 import (
 	"bytes"
 
+	"strconv"
+	"strings"
+
 	"github.com/luispater/CLIProxyAPI/internal/misc"
 	"github.com/tidwall/gjson"
 	"github.com/tidwall/sjson"
@@ -67,6 +70,31 @@ func ConvertOpenAIRequestToCodex(modelName string, inputRawJSON []byte, stream b
 	// Model
 	out, _ = sjson.Set(out, "model", modelName)
 
+	// Build tool name shortening map from original tools (if any)
+	originalToolNameMap := map[string]string{}
+	{
+		tools := gjson.GetBytes(rawJSON, "tools")
+		if tools.IsArray() && len(tools.Array()) > 0 {
+			// Collect original tool names
+			var names []string
+			arr := tools.Array()
+			for i := 0; i < len(arr); i++ {
+				t := arr[i]
+				if t.Get("type").String() == "function" {
+					fn := t.Get("function")
+					if fn.Exists() {
+						if v := fn.Get("name"); v.Exists() {
+							names = append(names, v.String())
+						}
+					}
+				}
+			}
+			if len(names) > 0 {
+				originalToolNameMap = buildShortNameMap(names)
+			}
+		}
+	}
+
 	// Extract system instructions from first system message (string or text object)
 	messages := gjson.GetBytes(rawJSON, "messages")
 	instructions := misc.CodexInstructions
@@ -177,7 +205,15 @@ func ConvertOpenAIRequestToCodex(modelName string, inputRawJSON []byte, stream b
 								funcCall := `{}`
 								funcCall, _ = sjson.Set(funcCall, "type", "function_call")
 								funcCall, _ = sjson.Set(funcCall, "call_id", tc.Get("id").String())
-								funcCall, _ = sjson.Set(funcCall, "name", tc.Get("function.name").String())
+								{
+									name := tc.Get("function.name").String()
+									if short, ok := originalToolNameMap[name]; ok {
+										name = short
+									} else {
+										name = shortenNameIfNeeded(name)
+									}
+									funcCall, _ = sjson.Set(funcCall, "name", name)
+								}
 								funcCall, _ = sjson.Set(funcCall, "arguments", tc.Get("function.arguments").String())
 								out, _ = sjson.SetRaw(out, "input.-1", funcCall)
 							}
@@ -249,7 +285,13 @@ func ConvertOpenAIRequestToCodex(modelName string, inputRawJSON []byte, stream b
 				fn := t.Get("function")
 				if fn.Exists() {
 					if v := fn.Get("name"); v.Exists() {
-						item, _ = sjson.Set(item, "name", v.Value())
+						name := v.String()
+						if short, ok := originalToolNameMap[name]; ok {
+							name = short
+						} else {
+							name = shortenNameIfNeeded(name)
+						}
+						item, _ = sjson.Set(item, "name", name)
 					}
 					if v := fn.Get("description"); v.Exists() {
 						item, _ = sjson.Set(item, "description", v.Value())
@@ -273,3 +315,81 @@ func ConvertOpenAIRequestToCodex(modelName string, inputRawJSON []byte, stream b
 	out, _ = sjson.Set(out, "store", store)
 	return []byte(out)
 }
+
+// shortenNameIfNeeded applies the simple shortening rule for a single name.
+// If the name length exceeds 64, it will try to preserve the "mcp__" prefix and last segment.
+// Otherwise it truncates to 64 characters.
+func shortenNameIfNeeded(name string) string {
+	const limit = 64
+	if len(name) <= limit {
+		return name
+	}
+	if strings.HasPrefix(name, "mcp__") {
+		// Keep prefix and last segment after '__'
+		idx := strings.LastIndex(name, "__")
+		if idx > 0 {
+			candidate := "mcp__" + name[idx+2:]
+			if len(candidate) > limit {
+				return candidate[:limit]
+			}
+			return candidate
+		}
+	}
+	return name[:limit]
+}
+
+// buildShortNameMap generates unique short names (<=64) for the given list of names.
+// It preserves the "mcp__" prefix with the last segment when possible and ensures uniqueness
+// by appending suffixes like "~1", "~2" if needed.
+func buildShortNameMap(names []string) map[string]string {
+	const limit = 64
+	used := map[string]struct{}{}
+	m := map[string]string{}
+
+	baseCandidate := func(n string) string {
+		if len(n) <= limit {
+			return n
+		}
+		if strings.HasPrefix(n, "mcp__") {
+			idx := strings.LastIndex(n, "__")
+			if idx > 0 {
+				cand := "mcp__" + n[idx+2:]
+				if len(cand) > limit {
+					cand = cand[:limit]
+				}
+				return cand
+			}
+		}
+		return n[:limit]
+	}
+
+	makeUnique := func(cand string) string {
+		if _, ok := used[cand]; !ok {
+			return cand
+		}
+		base := cand
+		for i := 1; ; i++ {
+			suffix := "~" + strconv.Itoa(i)
+			allowed := limit - len(suffix)
+			if allowed < 0 {
+				allowed = 0
+			}
+			tmp := base
+			if len(tmp) > allowed {
+				tmp = tmp[:allowed]
+			}
+			tmp = tmp + suffix
+			if _, ok := used[tmp]; !ok {
+				return tmp
+			}
+		}
+	}
+
+	for _, n := range names {
+		cand := baseCandidate(n)
+		uniq := makeUnique(cand)
+		used[uniq] = struct{}{}
+		m[n] = uniq
+	}
+	return m
+}

internal/translator/codex/openai/chat-completions/codex_openai_response.go

@@ -119,7 +119,16 @@ func ConvertCodexResponseToOpenAI(_ context.Context, modelName string, originalR
 			}
 			template, _ = sjson.SetRaw(template, "choices.0.delta.tool_calls", `[]`)
 			functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "id", itemResult.Get("call_id").String())
-			functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "function.name", itemResult.Get("name").String())
+			{
+				// Restore original tool name if it was shortened
+				name := itemResult.Get("name").String()
+				// Build reverse map on demand from original request tools
+				rev := buildReverseMapFromOriginalOpenAI(originalRequestRawJSON)
+				if orig, ok := rev[name]; ok {
+					name = orig
+				}
+				functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "function.name", name)
+			}
 			functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "function.arguments", itemResult.Get("arguments").String())
 			template, _ = sjson.Set(template, "choices.0.delta.role", "assistant")
 			template, _ = sjson.SetRaw(template, "choices.0.delta.tool_calls.-1", functionCallItemTemplate)
@@ -244,7 +253,12 @@ func ConvertCodexResponseToOpenAINonStream(_ context.Context, _ string, original
 					}
 
 					if nameResult := outputItem.Get("name"); nameResult.Exists() {
-						functionCallTemplate, _ = sjson.Set(functionCallTemplate, "function.name", nameResult.String())
+						n := nameResult.String()
+						rev := buildReverseMapFromOriginalOpenAI(originalRequestRawJSON)
+						if orig, ok := rev[n]; ok {
+							n = orig
+						}
+						functionCallTemplate, _ = sjson.Set(functionCallTemplate, "function.name", n)
 					}
 
 					if argsResult := outputItem.Get("arguments"); argsResult.Exists() {
@@ -289,3 +303,34 @@ func ConvertCodexResponseToOpenAINonStream(_ context.Context, _ string, original
 	}
 	return ""
 }
+
+// buildReverseMapFromOriginalOpenAI builds a map of shortened tool name -> original tool name
+// from the original OpenAI-style request JSON using the same shortening logic.
+func buildReverseMapFromOriginalOpenAI(original []byte) map[string]string {
+	tools := gjson.GetBytes(original, "tools")
+	rev := map[string]string{}
+	if tools.IsArray() && len(tools.Array()) > 0 {
+		var names []string
+		arr := tools.Array()
+		for i := 0; i < len(arr); i++ {
+			t := arr[i]
+			if t.Get("type").String() != "function" {
+				continue
+			}
+			fn := t.Get("function")
+			if !fn.Exists() {
+				continue
+			}
+			if v := fn.Get("name"); v.Exists() {
+				names = append(names, v.String())
+			}
+		}
+		if len(names) > 0 {
+			m := buildShortNameMap(names)
+			for orig, short := range m {
+				rev[short] = orig
+			}
+		}
+	}
+	return rev
+}