feat: publish v1.0.0-rc.36-custom.1

relaykit/relayconvert/internal/shared/claude/cache.go

@@ -0,0 +1,9 @@
+package claude
+
+func NormalizeCacheCreationSplit(totalTokens int, tokens5m int, tokens1h int) (int, int) {
+	remainder := totalTokens - tokens5m - tokens1h
+	if remainder < 0 {
+		remainder = 0
+	}
+	return tokens5m + remainder, tokens1h
+}

relaykit/relayconvert/internal/shared/claude/errors.go

@@ -0,0 +1,10 @@
+package claude
+
+import "errors"
+
+// ErrMissingMaxTokens is returned when an OpenAI-format request carries no
+// usable max_tokens and no Options.Claude.DefaultMaxTokens hook is
+// configured. The Claude Messages API rejects requests without max_tokens
+// (400 "max_tokens: Field required"), so conversion fails loudly instead of
+// emitting a request the upstream is guaranteed to refuse.
+var ErrMissingMaxTokens = errors.New("claude messages request requires max_tokens: set max_tokens on the request or configure Options.Claude.DefaultMaxTokens")

relaykit/relayconvert/internal/shared/claude/reasoning.go

@@ -0,0 +1,168 @@
+package claude
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"github.com/QuantumNous/new-api/relaykit/dto"
+	"github.com/QuantumNous/new-api/relaykit/relayconvert/convmeta"
+	"github.com/QuantumNous/new-api/relaykit/relayconvert/internal/convdiag"
+	kitutil "github.com/QuantumNous/new-api/relaykit/relayconvert/kitutil"
+	"github.com/QuantumNous/new-api/relaykit/relayconvert/reasoning"
+	"github.com/QuantumNous/new-api/relaykit/types"
+)
+
+func ApplyReasoning(ctx context.Context, req *dto.ClaudeRequest, info convmeta.Meta, source reasoning.Intent, crossProtocol bool) error {
+	if req == nil {
+		return nil
+	}
+
+	opts := convmeta.OptionsOf(info)
+	baseModel := req.Model
+	capabilityModel := baseModel
+	suffix := reasoning.IntentFromState(convmeta.ReasoningStateOf(info))
+	preserveSuffix := opts.ShouldPreserveThinkingSuffix(req.Model)
+	if info != nil && opts.ShouldPreserveThinkingSuffix(info.GetOriginModelName()) {
+		preserveSuffix = true
+	}
+	if preserveSuffix {
+		suffix = reasoning.Intent{}
+	}
+	// A native Claude request without a host modifier is already in the target
+	// protocol, including Claude-compatible proxies that keep native controls
+	// instead of applying Anthropic model rules. Read portable effort for
+	// accounting metadata, but do not run the capability renderer or rewrite
+	// provider-native controls.
+	if !crossProtocol && source.IsEmpty() && suffix.IsEmpty() {
+		if info != nil {
+			effort := req.GetEfforts()
+			if effort == "" && req.Thinking != nil {
+				switch {
+				case req.Thinking.Type == "disabled":
+					effort = string(reasoning.EffortNone)
+				case req.Thinking.BudgetTokens != nil:
+					effort = string(reasoning.EffortFromBudget(*req.Thinking.BudgetTokens))
+				case req.Thinking.Type == "enabled" || req.Thinking.Type == "adaptive":
+					effort = string(reasoning.EffortHigh)
+				}
+			}
+			info.SetReasoningEffort(effort)
+		}
+		return nil
+	}
+
+	native, err := reasoning.FromClaude(req)
+	if err != nil {
+		return err
+	}
+	explicit, err := reasoning.MergeExplicit(native, source, req.Model)
+	if err != nil {
+		return err
+	}
+	if info != nil && !reasoning.IsKnownClaudeModel(capabilityModel) && reasoning.IsKnownClaudeModel(info.GetOriginModelName()) {
+		capabilityModel = info.GetOriginModelName()
+	}
+	intent, err := reasoning.MergeExplicitAndSuffix(explicit, suffix, req.Model)
+	if err != nil {
+		return err
+	}
+	knownClaudeModel := reasoning.IsKnownClaudeModel(capabilityModel)
+	if !knownClaudeModel && intent.Mode == reasoning.ModeAdaptive {
+		// Cross-protocol pivots cannot safely assume that an unknown
+		// Claude-compatible model implements Anthropic's adaptive mode. Render
+		// the broadly supported manual form while retaining the requested
+		// strength. Native Claude requests took the passthrough path above.
+		intent.Mode = reasoning.ModeEnabled
+		if intent.Effort == "" {
+			intent.Effort = reasoning.EffortHigh
+		}
+	}
+	if req.MaxTokens == nil && intent.HasStrength() {
+		// Adapter-provided defaults may be raised to accommodate an exact
+		// cross-protocol budget. Explicit client max_tokens values are never
+		// expanded and remain subject to the renderer's strict validation.
+		minimum := uint(1280)
+		if configuredDefault, configured := opts.Claude.DefaultMaxTokensFor(capabilityModel); configured && configuredDefault > 0 {
+			minimum = uint(configuredDefault)
+		}
+		if reasoning.ClaudeUsesManualThinking(capabilityModel, intent) && *intent.BudgetTokens >= 0 {
+			if *intent.BudgetTokens == math.MaxInt {
+				return fmt.Errorf("thinking budget is too large to derive max_tokens")
+			}
+			required := uint(*intent.BudgetTokens) + 1
+			const maxDerivedTokens = uint(math.MaxInt32 / 2)
+			if required > maxDerivedTokens {
+				return fmt.Errorf("thinking budget %d exceeds the supported conversion limit", *intent.BudgetTokens)
+			}
+			if minimum < required {
+				minimum = required
+			}
+		}
+		req.MaxTokens = &minimum
+	}
+
+	rendered, err := reasoning.RenderClaude(capabilityModel, intent, req.MaxTokens, opts.Claude.ThinkingAdapterBudgetTokensPercentage)
+	if err != nil {
+		return err
+	}
+	convdiag.Add(ctx, rendered.Diagnostics...)
+	req.Model = baseModel
+	if rendered.Thinking != nil {
+		req.Thinking = rendered.Thinking
+	}
+	if rendered.OutputEffort != "" {
+		outputConfig := make(map[string]any)
+		if len(req.OutputConfig) > 0 {
+			if kitutil.GetJsonType(req.OutputConfig) != "object" {
+				return fmt.Errorf("Claude output_config must be a JSON object")
+			}
+			if err := kitutil.Unmarshal(req.OutputConfig, &outputConfig); err != nil {
+				return fmt.Errorf("invalid Claude output_config: %w", err)
+			}
+			if outputConfig == nil {
+				outputConfig = make(map[string]any)
+			}
+		}
+		outputConfig["effort"] = string(rendered.OutputEffort)
+		encoded, err := kitutil.Marshal(outputConfig)
+		if err != nil {
+			return fmt.Errorf("failed to marshal Claude output_config: %w", err)
+		}
+		req.OutputConfig = encoded
+	}
+	if rendered.ClearSampling {
+		if req.Temperature != nil || req.TopP != nil || req.TopK != nil {
+			convdiag.Add(ctx, types.ConversionDiagnostic{
+				Code:     "claude_sampling_removed",
+				Path:     "temperature/top_p/top_k",
+				Message:  fmt.Sprintf("model %q does not accept sampling controls with the selected thinking mode", capabilityModel),
+				Severity: types.ConversionDiagnosticWarning,
+				To:       types.RelayFormatClaude,
+			})
+		}
+		req.Temperature = nil
+		req.TopP = nil
+		req.TopK = nil
+	} else if rendered.ConstrainThinkingSampling {
+		removedSampling := req.Temperature != nil || req.TopK != nil || req.TopP != nil && (*req.TopP < 0.95 || *req.TopP > 1)
+		req.Temperature = nil
+		req.TopK = nil
+		if req.TopP != nil && (*req.TopP < 0.95 || *req.TopP > 1) {
+			req.TopP = nil
+		}
+		if removedSampling {
+			convdiag.Add(ctx, types.ConversionDiagnostic{
+				Code:     "claude_sampling_constrained",
+				Path:     "temperature/top_p/top_k",
+				Message:  fmt.Sprintf("model %q accepts only top_p between 0.95 and 1 with manual thinking", capabilityModel),
+				Severity: types.ConversionDiagnosticWarning,
+				To:       types.RelayFormatClaude,
+			})
+		}
+	}
+	if info != nil && rendered.EffectiveEffort != "" {
+		info.SetReasoningEffort(string(rendered.EffectiveEffort))
+	}
+	return nil
+}

relaykit/relayconvert/internal/shared/claude/schema.go

@@ -0,0 +1,16 @@
+package claude
+
+func FunctionParametersToInputSchema(parameters any) map[string]any {
+	params, _ := parameters.(map[string]any)
+	schema := make(map[string]any, len(params)+2)
+	for key, value := range params {
+		schema[key] = value
+	}
+	if schema["type"] == nil {
+		schema["type"] = "object"
+	}
+	if schema["properties"] == nil {
+		schema["properties"] = map[string]any{}
+	}
+	return schema
+}

relaykit/relayconvert/internal/shared/claude/tool_choice.go

@@ -0,0 +1,46 @@
+package claude
+
+import "github.com/QuantumNous/new-api/relaykit/dto"
+
+func MapOpenAIToolChoice(toolChoice any, parallelToolCalls *bool) *dto.ClaudeToolChoice {
+	var claudeToolChoice *dto.ClaudeToolChoice
+
+	if toolChoiceStr, ok := toolChoice.(string); ok {
+		switch toolChoiceStr {
+		case "auto":
+			claudeToolChoice = &dto.ClaudeToolChoice{
+				Type: "auto",
+			}
+		case "required":
+			claudeToolChoice = &dto.ClaudeToolChoice{
+				Type: "any",
+			}
+		case "none":
+			claudeToolChoice = &dto.ClaudeToolChoice{
+				Type: "none",
+			}
+		}
+	} else if toolChoiceMap, ok := toolChoice.(map[string]interface{}); ok {
+		if function, ok := toolChoiceMap["function"].(map[string]interface{}); ok {
+			if toolName, ok := function["name"].(string); ok {
+				claudeToolChoice = &dto.ClaudeToolChoice{
+					Type: "tool",
+					Name: toolName,
+				}
+			}
+		}
+	}
+
+	if parallelToolCalls != nil {
+		if claudeToolChoice == nil {
+			claudeToolChoice = &dto.ClaudeToolChoice{
+				Type: "auto",
+			}
+		}
+		if claudeToolChoice.Type != "none" {
+			claudeToolChoice.DisableParallelToolUse = !*parallelToolCalls
+		}
+	}
+
+	return claudeToolChoice
+}

relaykit/relayconvert/internal/shared/claude/usage.go

@@ -0,0 +1,52 @@
+package claude
+
+import "github.com/QuantumNous/new-api/relaykit/dto"
+
+func UsageFromOpenAI(usage *dto.Usage) *dto.ClaudeUsage {
+	if usage == nil {
+		return nil
+	}
+	// An existing sidecar snapshots the original provider usage; carry it
+	// across this bridge unchanged regardless of its dialect. Only synthesize
+	// an OpenAI snapshot when no sidecar exists yet.
+	existingBillingUsage := dto.CloneBillingUsage(usage.BillingUsage)
+	if existingBillingUsage != nil && existingBillingUsage.ClaudeUsage != nil &&
+		(existingBillingUsage.Source == dto.BillingUsageSourceClaudeMessages || existingBillingUsage.Semantic == dto.BillingUsageSemanticAnthropic) {
+		result := existingBillingUsage.ClaudeUsage
+		result.BillingUsage = dto.CloneBillingUsage(usage.BillingUsage)
+		return result
+	}
+	billingUsage := existingBillingUsage
+	if billingUsage == nil {
+		billingUsage = dto.NewOpenAIChatBillingUsage(usage)
+	}
+	cacheCreation5m, cacheCreation1h := NormalizeCacheCreationSplit(
+		usage.PromptTokensDetails.CachedCreationTokens,
+		usage.ClaudeCacheCreation5mTokens,
+		usage.ClaudeCacheCreation1hTokens,
+	)
+	cacheCreationTokens := usage.PromptTokensDetails.CacheCreationTokensTotal()
+	inputTokens := usage.PromptTokens
+	if usage.UsageSemantic != dto.BillingUsageSemanticAnthropic {
+		// OpenAI-style prompt/input totals include cache reads and writes, while
+		// Claude reports both separately from input_tokens.
+		inputTokens = usage.PromptTokens - usage.PromptTokensDetails.CachedTokens - cacheCreationTokens
+		if inputTokens < 0 {
+			inputTokens = 0
+		}
+	}
+	result := &dto.ClaudeUsage{
+		InputTokens:              inputTokens,
+		OutputTokens:             usage.CompletionTokens,
+		CacheCreationInputTokens: cacheCreationTokens,
+		CacheReadInputTokens:     usage.PromptTokensDetails.CachedTokens,
+		BillingUsage:             billingUsage,
+	}
+	if cacheCreation5m > 0 || cacheCreation1h > 0 {
+		result.CacheCreation = &dto.ClaudeCacheCreationUsage{
+			Ephemeral5mInputTokens: cacheCreation5m,
+			Ephemeral1hInputTokens: cacheCreation1h,
+		}
+	}
+	return result
+}