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

relaykit/relayconvert/convmeta/format.go

@@ -0,0 +1,31 @@
+package convmeta
+
+import (
+	"github.com/QuantumNous/new-api/relaykit/dto"
+	"github.com/QuantumNous/new-api/relaykit/types"
+)
+
+// GuessRelayFormatFromRequest infers the relay format from a request DTO's
+// concrete type. Moved from relay/common (which keeps a delegating alias).
+func GuessRelayFormatFromRequest(req any) (types.RelayFormat, bool) {
+	switch req.(type) {
+	case *dto.GeneralOpenAIRequest, dto.GeneralOpenAIRequest:
+		return types.RelayFormatOpenAI, true
+	case *dto.OpenAIResponsesRequest, dto.OpenAIResponsesRequest:
+		return types.RelayFormatOpenAIResponses, true
+	case *dto.ClaudeRequest, dto.ClaudeRequest:
+		return types.RelayFormatClaude, true
+	case *dto.GeminiChatRequest, dto.GeminiChatRequest:
+		return types.RelayFormatGemini, true
+	case *dto.EmbeddingRequest, dto.EmbeddingRequest:
+		return types.RelayFormatEmbedding, true
+	case *dto.RerankRequest, dto.RerankRequest:
+		return types.RelayFormatRerank, true
+	case *dto.ImageRequest, dto.ImageRequest:
+		return types.RelayFormatOpenAIImage, true
+	case *dto.AudioRequest, dto.AudioRequest:
+		return types.RelayFormatOpenAIAudio, true
+	default:
+		return "", false
+	}
+}

relaykit/relayconvert/convmeta/meta.go

@@ -0,0 +1,249 @@
+// Package convmeta defines the conversion-context contract between format
+// converters (future relaykit) and the hosting application. Converters read
+// protocol state and per-request options exclusively through the Meta
+// interface; the host's RelayInfo implements it.
+package convmeta
+
+import (
+	"github.com/QuantumNous/new-api/relaykit/dto"
+	"github.com/QuantumNous/new-api/relaykit/types"
+)
+
+// Meta is the only view of the relay session that format converters may use.
+// It is satisfied by *relaycommon.RelayInfo on the host side; other embedders
+// (tests, external relaykit users) can use *Values.
+// Implementations backed by pointer types must make every method safe on a nil
+// receiver: a typed-nil pointer stored in Meta is still a non-nil interface,
+// and relaykit deliberately does not use reflection to detect that case.
+type Meta interface {
+	GetOriginModelName() string
+	GetUpstreamModelName() string
+	// HasChannelMeta reports whether upstream channel information is attached;
+	// converters use it to decide if GetUpstreamModelName is meaningful.
+	HasChannelMeta() bool
+	GetChannelID() int
+	GetChannelType() int
+	GetIsStream() bool
+	GetReasoningEffort() string
+	// SetReasoningEffort records the effort level a converter derived from a
+	// model-name suffix so downstream billing/logging can see it.
+	SetReasoningEffort(effort string)
+	// ReasoningState returns the suffix-derived reasoning intent attached at
+	// the host entry layer. Standalone callers that do not set it receive nil;
+	// converters then use only explicit request fields.
+	ReasoningState() *dto.ReasoningConversionState
+	GetEstimatePromptTokens() int
+
+	// EnsureClaudeConvertInfo lazily creates and returns the mutable
+	// OpenAI→Claude stream conversion state. For non-nil receivers, the same
+	// instance must be returned for the lifetime of one streaming session; a
+	// nil receiver may return a temporary initialized state.
+	EnsureClaudeConvertInfo() *ClaudeConvertInfo
+
+	// GetSendResponseCount / IncrSendResponseCount expose the shared
+	// downstream-chunk counter (the host may also increment it).
+	GetSendResponseCount() int
+	IncrSendResponseCount()
+
+	// AppendRequestConversion records a hop in the request format chain.
+	AppendRequestConversion(format types.RelayFormat)
+
+	// ConvOptions returns the request-scoped conversion options snapshot.
+	// Must never return nil.
+	ConvOptions() *Options
+}
+
+// ClaudeConvertInfo carries mutable state for OpenAI chat → Claude Messages
+// stream conversion. Moved here from relay/common (which keeps an alias).
+type ClaudeConvertInfo struct {
+	LastMessagesType string
+	Index            int
+	Usage            *dto.Usage
+	FinishReason     string
+	Done             bool
+
+	ToolCallBaseIndex      int
+	ToolCallMaxIndexOffset int
+	ToolCalls              []*ClaudeStreamToolCall
+	ToolCallByIndex        map[int]*ClaudeStreamToolCall
+	ToolCallByID           map[string]*ClaudeStreamToolCall
+}
+
+// ClaudeStreamToolCall tracks one OpenAI tool_calls entry while it is encoded
+// as a Claude tool_use content block. Chat tool indexes and Claude content
+// block indexes are separate domains, so the mapping must remain explicit.
+type ClaudeStreamToolCall struct {
+	BlockIndex       int
+	ID               string
+	Name             string
+	PendingArguments string
+	Started          bool
+}
+
+const (
+	LastMessageTypeNone     = "none"
+	LastMessageTypeText     = "text"
+	LastMessageTypeTools    = "tools"
+	LastMessageTypeThinking = "thinking"
+)
+
+// Values is a plain-struct Meta implementation for tests and non-RelayInfo
+// hosts (the relaykit-native entry point).
+type Values struct {
+	OriginModelName      string
+	UpstreamModelName    string
+	ChannelMetaAttached  bool
+	ChannelID            int
+	ChannelType          int
+	IsStream             bool
+	ReasoningEffort      string
+	ReasoningConversion  *dto.ReasoningConversionState
+	EstimatePromptTokens int
+
+	ClaudeConvertInfo *ClaudeConvertInfo
+	SendResponseCount int
+	ConversionChain   []types.RelayFormat
+
+	Options *Options
+}
+
+var _ Meta = (*Values)(nil)
+
+func (v *Values) GetOriginModelName() string {
+	if v == nil {
+		return ""
+	}
+	return v.OriginModelName
+}
+
+func (v *Values) GetUpstreamModelName() string {
+	if v == nil {
+		return ""
+	}
+	return v.UpstreamModelName
+}
+
+func (v *Values) HasChannelMeta() bool {
+	return v != nil && v.ChannelMetaAttached
+}
+
+func (v *Values) GetChannelID() int {
+	if v == nil {
+		return 0
+	}
+	return v.ChannelID
+}
+
+func (v *Values) GetChannelType() int {
+	if v == nil {
+		return 0
+	}
+	return v.ChannelType
+}
+
+func (v *Values) GetIsStream() bool {
+	return v != nil && v.IsStream
+}
+
+func (v *Values) GetReasoningEffort() string {
+	if v == nil {
+		return ""
+	}
+	return v.ReasoningEffort
+}
+
+func (v *Values) SetReasoningEffort(effort string) {
+	if v != nil {
+		v.ReasoningEffort = effort
+	}
+}
+
+func (v *Values) ReasoningState() *dto.ReasoningConversionState {
+	if v == nil {
+		return nil
+	}
+	return v.ReasoningConversion
+}
+
+func (v *Values) GetEstimatePromptTokens() int {
+	if v == nil {
+		return 0
+	}
+	return v.EstimatePromptTokens
+}
+
+func (v *Values) EnsureClaudeConvertInfo() *ClaudeConvertInfo {
+	if v == nil {
+		return &ClaudeConvertInfo{LastMessagesType: LastMessageTypeNone}
+	}
+	if v.ClaudeConvertInfo == nil {
+		v.ClaudeConvertInfo = &ClaudeConvertInfo{LastMessagesType: LastMessageTypeNone}
+	}
+	return v.ClaudeConvertInfo
+}
+
+func (v *Values) GetSendResponseCount() int {
+	if v == nil {
+		return 0
+	}
+	return v.SendResponseCount
+}
+
+func (v *Values) IncrSendResponseCount() {
+	if v != nil {
+		v.SendResponseCount++
+	}
+}
+
+func (v *Values) AppendRequestConversion(format types.RelayFormat) {
+	if v == nil || format == "" {
+		return
+	}
+	if n := len(v.ConversionChain); n > 0 && v.ConversionChain[n-1] == format {
+		return
+	}
+	v.ConversionChain = append(v.ConversionChain, format)
+}
+
+func (v *Values) ConvOptions() *Options {
+	if v == nil {
+		return &Options{}
+	}
+	if v.Options == nil {
+		v.Options = &Options{}
+	}
+	return v.Options
+}
+
+// UpstreamModelName / ChannelTypeOf are nil-safe accessors for optional Meta
+// values (converters are often called with a nil Meta in tests and compat
+// shims).
+func UpstreamModelName(m Meta) string {
+	if m == nil || !m.HasChannelMeta() {
+		return ""
+	}
+	return m.GetUpstreamModelName()
+}
+
+func ChannelTypeOf(m Meta) int {
+	if m == nil || !m.HasChannelMeta() {
+		return 0
+	}
+	return m.GetChannelType()
+}
+
+// OptionsOf returns m's conversion options, or empty defaults when m is nil.
+func OptionsOf(m Meta) *Options {
+	if m == nil {
+		return &Options{}
+	}
+	return m.ConvOptions()
+}
+
+// ReasoningStateOf is a nil-safe reader for Meta.ReasoningState.
+func ReasoningStateOf(m Meta) *dto.ReasoningConversionState {
+	if m == nil {
+		return nil
+	}
+	return m.ReasoningState()
+}

relaykit/relayconvert/convmeta/meta_test.go

@@ -0,0 +1,39 @@
+package convmeta
+
+import (
+	"testing"
+
+	"github.com/QuantumNous/new-api/relaykit/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestValuesTypedNilMetaIsSafe(t *testing.T) {
+	var values *Values
+	var meta Meta = values
+
+	assert.Empty(t, meta.GetOriginModelName())
+	assert.Empty(t, meta.GetUpstreamModelName())
+	assert.False(t, meta.HasChannelMeta())
+	assert.Zero(t, meta.GetChannelID())
+	assert.Zero(t, meta.GetChannelType())
+	assert.False(t, meta.GetIsStream())
+	assert.Empty(t, meta.GetReasoningEffort())
+	assert.Nil(t, meta.ReasoningState())
+	assert.Zero(t, meta.GetEstimatePromptTokens())
+	assert.Zero(t, meta.GetSendResponseCount())
+
+	require.NotPanics(t, func() {
+		meta.SetReasoningEffort("high")
+		meta.IncrSendResponseCount()
+		meta.AppendRequestConversion(types.RelayFormatClaude)
+	})
+
+	convertInfo := meta.EnsureClaudeConvertInfo()
+	require.NotNil(t, convertInfo)
+	assert.Equal(t, LastMessageTypeNone, convertInfo.LastMessagesType)
+	require.NotNil(t, meta.ConvOptions())
+	require.NotNil(t, OptionsOf(meta))
+	assert.Empty(t, UpstreamModelName(meta))
+	assert.Zero(t, ChannelTypeOf(meta))
+}

relaykit/relayconvert/convmeta/options.go

@@ -0,0 +1,109 @@
+package convmeta
+
+import "github.com/QuantumNous/new-api/relaykit/types"
+
+// Options is the per-request snapshot of host configuration that converters
+// consult. The host fills it from its settings system when constructing the
+// Meta (see relaycommon.RelayInfo.ConvOptions); relaykit users fill it
+// directly. Zero value = every adaptation disabled, no defaults applied.
+type Options struct {
+	Claude ClaudeOptions
+	Gemini GeminiOptions
+
+	// ToolLossPolicy controls whether a cross-protocol conversion may omit or
+	// approximate built-in-tool semantics. The zero value uses the allow
+	// policy: conversion succeeds and every loss is returned as a diagnostic.
+	// safe/strict rejection is request-phase opt-in only; response and stream
+	// conversion never reject regardless of this field.
+	ToolLossPolicy types.ConversionLossPolicy
+
+	// OpenRouterDialect marks the upstream as OpenRouter's OpenAI-compatible
+	// surface, which accepts extra fields (reasoning config, cache_control on
+	// system parts) that converters emit only for that dialect. The host sets
+	// it from the channel type.
+	OpenRouterDialect bool
+
+	// PreserveThinkingSuffix reports models whose -thinking/-nothinking/effort
+	// suffix must be kept on the outgoing model name (host blacklist lookup).
+	// Nil means "never preserve".
+	PreserveThinkingSuffix func(modelName string) bool
+
+	// PreserveEffortTail reports real model IDs whose names already end in an
+	// effort-like token (for example qwen-max). Nil means "never preserve".
+	PreserveEffortTail func(modelName string) bool
+}
+
+type ClaudeOptions struct {
+	// ThinkingAdapterEnabled controls whether suffix-derived reasoning intent
+	// is rendered onto Claude thinking / output_config. Suffix parsing itself
+	// is the host entry layer's job (standalone users call Parse* themselves).
+	ThinkingAdapterEnabled bool
+	// ThinkingAdapterBudgetTokensPercentage sizes thinking budget_tokens as a
+	// fraction of max_tokens when the adapter fires.
+	ThinkingAdapterBudgetTokensPercentage float64
+	// DefaultMaxTokens returns the max_tokens to inject when the source
+	// request carries none. The Claude Messages API requires max_tokens
+	// (omitting it is a 400), so when this hook is nil and no other path
+	// supplies a value, OpenAI→Claude request conversion fails with an
+	// explicit error instead of emitting a request the upstream is
+	// guaranteed to reject. The new-api host always provides this hook;
+	// standalone relaykit users must supply one or guarantee max_tokens on
+	// every request.
+	DefaultMaxTokens func(modelName string) int
+	// WebSearchToolVersion selects the Claude hosted web-search tool version
+	// emitted by cross-protocol conversion. Empty keeps the compatibility
+	// baseline web_search_20250305.
+	WebSearchToolVersion string
+}
+
+type GeminiOptions struct {
+	// ThinkingAdapterEnabled controls whether suffix-derived reasoning intent
+	// is rendered onto Gemini thinkingConfig. Suffix parsing itself is the
+	// host entry layer's job (standalone users call Parse* themselves).
+	ThinkingAdapterEnabled bool
+	// ThinkingAdapterBudgetTokensPercentage sizes thinkingBudget as a fraction
+	// of maxOutputTokens when the adapter fires.
+	ThinkingAdapterBudgetTokensPercentage float64
+	// FunctionCallThoughtSignatureEnabled attaches thoughtSignature bypass
+	// values to function-call parts.
+	FunctionCallThoughtSignatureEnabled bool
+	// SupportsImagine reports whether the model supports image generation
+	// (switches response modalities). Nil means "never".
+	SupportsImagine func(modelName string) bool
+	// SafetySetting returns the harm threshold for a category. Nil or empty
+	// return means no safetySettings are attached.
+	SafetySetting func(category string) string
+}
+
+func (o *ClaudeOptions) DefaultMaxTokensFor(modelName string) (int, bool) {
+	if o == nil || o.DefaultMaxTokens == nil {
+		return 0, false
+	}
+	return o.DefaultMaxTokens(modelName), true
+}
+
+func (o *GeminiOptions) SupportsImagineModel(modelName string) bool {
+	return o != nil && o.SupportsImagine != nil && o.SupportsImagine(modelName)
+}
+
+func (o *GeminiOptions) SafetySettingFor(category string) string {
+	if o == nil || o.SafetySetting == nil {
+		return ""
+	}
+	return o.SafetySetting(category)
+}
+
+func (o *Options) ShouldPreserveThinkingSuffix(modelName string) bool {
+	return o != nil && o.PreserveThinkingSuffix != nil && o.PreserveThinkingSuffix(modelName)
+}
+
+func (o *Options) ShouldPreserveEffortTail(modelName string) bool {
+	return o != nil && o.PreserveEffortTail != nil && o.PreserveEffortTail(modelName)
+}
+
+func (o *Options) EffectiveToolLossPolicy() types.ConversionLossPolicy {
+	if o == nil || o.ToolLossPolicy == "" {
+		return types.ConversionLossPolicyAllow
+	}
+	return o.ToolLossPolicy
+}