148 lines
4.1 KiB
Go
148 lines
4.1 KiB
Go
// Copyright 2026 Alibaba Group
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package transport
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"strings"
|
|
|
|
apperrors "github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/errors"
|
|
)
|
|
|
|
// serverDiagFields maps the various JSON field names the server may use
|
|
// for diagnostic information. Both snake_case and camelCase are supported.
|
|
type serverDiagFields struct {
|
|
TraceID string `json:"trace_id"`
|
|
TraceIDCamel string `json:"traceId"`
|
|
Code string `json:"code"`
|
|
ErrorCode string `json:"errorCode"`
|
|
TechnicalDetail string `json:"technical_detail"`
|
|
Retryable *bool `json:"retryable"`
|
|
}
|
|
|
|
// ExtractServerDiagnostics parses server diagnostic fields from a JSON
|
|
// payload (typically from RPCError.Data). Returns an empty struct if
|
|
// the payload is empty or unparseable.
|
|
func ExtractServerDiagnostics(data json.RawMessage) apperrors.ServerDiagnostics {
|
|
if len(data) == 0 {
|
|
return apperrors.ServerDiagnostics{}
|
|
}
|
|
var content map[string]any
|
|
if json.Unmarshal(data, &content) != nil {
|
|
return apperrors.ServerDiagnostics{}
|
|
}
|
|
return ExtractServerDiagnosticsFromMap(content)
|
|
}
|
|
|
|
// ExtractServerDiagnosticsFromMap parses server diagnostic fields from a
|
|
// map[string]any (typically from ToolCallResult.Content for business errors).
|
|
func ExtractServerDiagnosticsFromMap(content map[string]any) apperrors.ServerDiagnostics {
|
|
if len(content) == 0 {
|
|
return apperrors.ServerDiagnostics{}
|
|
}
|
|
diag := apperrors.ServerDiagnostics{
|
|
TraceID: stringFromMap(content, "trace_id", "traceId"),
|
|
ServerErrorCode: serverErrorCodeFromMap(content, 0),
|
|
TechnicalDetail: stringFromMap(content, "technical_detail"),
|
|
}
|
|
if v, ok := content["retryable"].(bool); ok {
|
|
diag.ServerRetryable = &v
|
|
}
|
|
return diag
|
|
}
|
|
|
|
// ExtractTraceIDFromHeaders reads a trace ID from standard HTTP response
|
|
// headers. Returns empty string if none found.
|
|
func ExtractTraceIDFromHeaders(headers http.Header) string {
|
|
for _, key := range []string{
|
|
"X-Trace-Id",
|
|
"X-Request-Id",
|
|
"x-dingtalk-trace-id",
|
|
} {
|
|
if v := headers.Get(key); v != "" {
|
|
return v
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// coalesceStr returns the first non-empty string.
|
|
func coalesceStr(values ...string) string {
|
|
for _, v := range values {
|
|
if v != "" {
|
|
return v
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// stringFromMap returns the first non-empty string value found for any of
|
|
// the given keys in the map.
|
|
func stringFromMap(m map[string]any, keys ...string) string {
|
|
for _, key := range keys {
|
|
if v, ok := m[key].(string); ok && v != "" {
|
|
return v
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func serverErrorCodeFromMap(content map[string]any, depth int) string {
|
|
if content == nil || depth > 8 {
|
|
return ""
|
|
}
|
|
direct := stringFromMap(content, "errorCode", "code", "server_error_code")
|
|
if isWrapperServerCode(direct) {
|
|
if nested := nestedServerErrorCode(content, depth); nested != "" {
|
|
return nested
|
|
}
|
|
}
|
|
if direct != "" {
|
|
return direct
|
|
}
|
|
return nestedServerErrorCode(content, depth)
|
|
}
|
|
|
|
func nestedServerErrorCode(content map[string]any, depth int) string {
|
|
for _, key := range []string{"content", "result", "data"} {
|
|
switch child := content[key].(type) {
|
|
case map[string]any:
|
|
if code := serverErrorCodeFromMap(child, depth+1); code != "" {
|
|
return code
|
|
}
|
|
case []any:
|
|
for _, item := range child {
|
|
childMap, ok := item.(map[string]any)
|
|
if !ok {
|
|
continue
|
|
}
|
|
if code := serverErrorCodeFromMap(childMap, depth+1); code != "" {
|
|
return code
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func isWrapperServerCode(code string) bool {
|
|
switch strings.ToUpper(strings.TrimSpace(code)) {
|
|
case "ERROR", "BUSINESS_ERROR", "-1":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|