Calcium-Ion
86ac0f7745
* test(relayconvert): add golden snapshot matrix and relaykit boundary guard Phase 0 of the relaykit extraction plan: pin byte-level output of every registered (from,to) request/response/stream conversion route, and forbid kit-bound packages from growing host-only imports. * wip(relayconvert): drop gin.Context from converter signatures; add convmeta draft Phase 1 in progress: relayconvert now takes context.Context; host media resolver adapts gin.Context back at the service boundary. * refactor(relayconvert): decouple converters from RelayInfo, gin, and settings Phase 1 of the relaykit extraction plan: - converters now depend on convmeta.Meta (implemented by RelayInfo) instead of *relaycommon.RelayInfo; ClaudeConvertInfo and the format guesser move to convmeta with aliases left behind - host settings reach converters via a convmeta.Options snapshot built in RelayInfo.ConvOptions; no more model_setting/reasoning global reads inside the conversion layer - effort-suffix helpers move to service/relayconvert/reasoning (old package forwards); chat-to-responses upgrade policy moves to service (host routing logic, not conversion) - golden conversion matrix unchanged * test(relayconvert): tighten boundary — kit packages now free of gin/setting imports * refactor(dto): drop gin and logger dependencies Phase 2 (part 1): dto.Request.IsStream now takes *http.Request instead of *gin.Context (Gemini's impl reads query/path off the std request); dto's three logger calls become common.SysError. Boundary test allowlist is now empty — kit-bound packages import no gin/setting/logger/model. * refactor(kit): extract dependency-free kitutil; dto/types/relayconvert stop importing common Phase 2 of the relaykit extraction plan: - new service/relayconvert/kitutil holds the pure helpers the kit needs (JSON wrappers, pointer/string/uuid/timestamp utils, MaskSensitiveInfo, pluggable LogInfo/LogError hooks, Debug flag) - dto, types, and all relayconvert packages now use kitutil; their only remaining internal deps are dto/types/constant - common keeps every original symbol (MaskSensitiveInfo delegates to kitutil) so host code is untouched; main.go routes kit logging into common.SysLog/SysError and mirrors DebugEnabled - golden conversion matrix unchanged * refactor(kit): move EndpointType/FinishReason to types; OpenRouter dialect via Options Kit packages (dto/types/relayconvert/reasonmap) no longer import constant: - EndpointType and finish-reason values live in types; constant re-exports - the OpenRouter special-case in claude->openai request conversion reads Options.OpenRouterDialect, set by the host from the channel type; InitChannelMeta invalidates the cached snapshot on channel switch * refactor: extract relaykit submodule (dto/types/relayconvert/reasonmap) Phase 3 of the relaykit extraction plan: - new go module github.com/QuantumNous/new-api/relaykit containing dto (minus task family), types, relayconvert (with convmeta/kitutil/reasoning), and reasonmap; host consumes it via require + replace, go.work for dev - task-family dto (task/suno/midjourney/video) stays in the host dto package; dual-consumer host files alias it as taskdto - relaykit builds and tests standalone (GOWORK=off): no host imports, no gin, no DB, no settings - golden conversion matrix unchanged * build(docker): copy relaykit/go.mod before go mod download The local-replace submodule's go.mod must exist inside the build context for the main module graph to resolve. * fix: address relaykit extraction regressions * fix: address relaykit review regressions * docs: document Meta nil receiver contract * fix(relaykit): fail OpenAI→Claude conversion without max_tokens; reject negative default_max_tokens The Claude Messages API requires max_tokens (omitting it is a 400 "Field required"), but with a nil Options.Claude.DefaultMaxTokens hook the converters silently emitted a request the upstream is guaranteed to reject. Both OpenAI Chat and Responses → Claude conversions now return sharedclaude.ErrMissingMaxTokens when no path (client value, default hook, thinking-adapter floor) supplied one. Unreachable in the host, which always configures the hook. Host side, claude.default_max_tokens now rejects negative values at the option API before persisting — they would wrap into huge unsigned values during conversion. Zero stays allowed: the current API treats max_tokens: 0 as cache pre-warming. * fix: make Gemini safety settings read path race-free
142 lines
6.0 KiB
Go
142 lines
6.0 KiB
Go
package relayconvert
|
|
|
|
import (
|
|
"github.com/QuantumNous/new-api/relaykit/dto"
|
|
"github.com/QuantumNous/new-api/relaykit/relayconvert/convmeta"
|
|
claudemessages "github.com/QuantumNous/new-api/relaykit/relayconvert/internal/claude_messages"
|
|
geminichat "github.com/QuantumNous/new-api/relaykit/relayconvert/internal/gemini_chat"
|
|
oaichat "github.com/QuantumNous/new-api/relaykit/relayconvert/internal/oai_chat"
|
|
oairesponses "github.com/QuantumNous/new-api/relaykit/relayconvert/internal/oai_responses"
|
|
)
|
|
|
|
type ClaudeResponseInfo = claudemessages.ClaudeResponseInfo
|
|
|
|
type ChatToResponsesStreamEvent = oaichat.ChatToResponsesStreamEvent
|
|
type ChatToResponsesStreamState = oaichat.ChatToResponsesStreamState
|
|
type ResponsesToChatStreamState = oairesponses.ResponsesToChatStreamState
|
|
type ResponsesBufferedAccumulator = oairesponses.ResponsesBufferedAccumulator
|
|
|
|
func NormalizeCacheCreationSplit(totalTokens int, tokens5m int, tokens1h int) (int, int) {
|
|
return oaichat.NormalizeCacheCreationSplit(totalTokens, tokens5m, tokens1h)
|
|
}
|
|
|
|
func ResponseOpenAI2Claude(openAIResponse *dto.OpenAITextResponse, info convmeta.Meta) *dto.ClaudeResponse {
|
|
return oaichat.ResponseOpenAI2Claude(openAIResponse, info)
|
|
}
|
|
|
|
func StreamResponseOpenAI2Claude(openAIResponse *dto.ChatCompletionsStreamResponse, info convmeta.Meta) []*dto.ClaudeResponse {
|
|
return oaichat.StreamResponseOpenAI2Claude(openAIResponse, info)
|
|
}
|
|
|
|
func StopReasonClaudeToOpenAI(reason string) string {
|
|
return claudemessages.StopReasonClaudeToOpenAI(reason)
|
|
}
|
|
|
|
func StreamResponseClaude2OpenAI(claudeResponse *dto.ClaudeResponse) *dto.ChatCompletionsStreamResponse {
|
|
return claudemessages.StreamResponseClaude2OpenAI(claudeResponse)
|
|
}
|
|
|
|
func ResponseClaude2OpenAI(claudeResponse *dto.ClaudeResponse) *dto.OpenAITextResponse {
|
|
return claudemessages.ResponseClaude2OpenAI(claudeResponse)
|
|
}
|
|
|
|
func UsageFromClaudeAPIUsage(usage *dto.ClaudeUsage) *dto.Usage {
|
|
return claudemessages.UsageFromClaudeAPIUsage(usage)
|
|
}
|
|
|
|
func UsageFromClaudeUsage(usage *dto.Usage) *dto.Usage {
|
|
return claudemessages.UsageFromClaudeUsage(usage)
|
|
}
|
|
|
|
func BuildMessageDeltaPatchUsage(claudeResponse *dto.ClaudeResponse, claudeInfo *ClaudeResponseInfo) *dto.ClaudeUsage {
|
|
return claudemessages.BuildMessageDeltaPatchUsage(claudeResponse, claudeInfo)
|
|
}
|
|
|
|
func PatchClaudeMessageDeltaUsageData(data string, usage *dto.ClaudeUsage) string {
|
|
return claudemessages.PatchClaudeMessageDeltaUsageData(data, usage)
|
|
}
|
|
|
|
func FormatClaudeResponseInfo(claudeResponse *dto.ClaudeResponse, oaiResponse *dto.ChatCompletionsStreamResponse, claudeInfo *ClaudeResponseInfo) bool {
|
|
return claudemessages.FormatClaudeResponseInfo(claudeResponse, oaiResponse, claudeInfo)
|
|
}
|
|
|
|
func ResponseOpenAI2Gemini(openAIResponse *dto.OpenAITextResponse, info convmeta.Meta) *dto.GeminiChatResponse {
|
|
return oaichat.ResponseOpenAI2Gemini(openAIResponse, info)
|
|
}
|
|
|
|
func StreamResponseOpenAI2Gemini(openAIResponse *dto.ChatCompletionsStreamResponse, info convmeta.Meta) *dto.GeminiChatResponse {
|
|
return oaichat.StreamResponseOpenAI2Gemini(openAIResponse, info)
|
|
}
|
|
|
|
func UsageFromGeminiMetadata(metadata *dto.GeminiUsageMetadata, fallbackPromptTokens int) *dto.Usage {
|
|
return geminichat.UsageFromGeminiMetadata(metadata, fallbackPromptTokens)
|
|
}
|
|
|
|
func ResponseGeminiChat2OpenAI(id string, created int64, response *dto.GeminiChatResponse) *dto.OpenAITextResponse {
|
|
return geminichat.ResponseGeminiChat2OpenAI(id, created, response)
|
|
}
|
|
|
|
func StreamResponseGeminiChat2OpenAI(geminiResponse *dto.GeminiChatResponse) (*dto.ChatCompletionsStreamResponse, bool) {
|
|
return geminichat.StreamResponseGeminiChat2OpenAI(geminiResponse)
|
|
}
|
|
|
|
func ChatCompletionsResponseToResponsesResponse(resp *dto.OpenAITextResponse, id string) (*dto.OpenAIResponsesResponse, *dto.Usage, error) {
|
|
return oaichat.ChatCompletionsResponseToResponsesResponse(resp, id)
|
|
}
|
|
|
|
func ResponsesStatusFromChatFinishReason(finishReason string) (string, *dto.IncompleteDetails) {
|
|
return oaichat.ResponsesStatusFromChatFinishReason(finishReason)
|
|
}
|
|
|
|
func UsageFromChatUsage(src *dto.Usage) *dto.Usage {
|
|
return oaichat.UsageFromChatUsage(src)
|
|
}
|
|
|
|
func NewChatToResponsesStreamState(id string, model string) *ChatToResponsesStreamState {
|
|
return oaichat.NewChatToResponsesStreamState(id, model)
|
|
}
|
|
|
|
func ChatCompletionsStreamChunkToResponsesEvents(chunk *dto.ChatCompletionsStreamResponse, state *ChatToResponsesStreamState) ([]ChatToResponsesStreamEvent, error) {
|
|
return oaichat.ChatCompletionsStreamChunkToResponsesEvents(chunk, state)
|
|
}
|
|
|
|
func FinalizeChatCompletionsStreamToResponses(state *ChatToResponsesStreamState) []ChatToResponsesStreamEvent {
|
|
return oaichat.FinalizeChatCompletionsStreamToResponses(state)
|
|
}
|
|
|
|
func ResponsesFinishReasonFromStatus(resp *dto.OpenAIResponsesResponse) (string, bool) {
|
|
return oairesponses.ResponsesFinishReasonFromStatus(resp)
|
|
}
|
|
|
|
func ResponsesResponseToChatCompletionsResponse(resp *dto.OpenAIResponsesResponse, id string) (*dto.OpenAITextResponse, *dto.Usage, error) {
|
|
return oairesponses.ResponsesResponseToChatCompletionsResponse(resp, id)
|
|
}
|
|
|
|
func UsageFromResponsesUsage(src *dto.Usage) *dto.Usage {
|
|
return oairesponses.UsageFromResponsesUsage(src)
|
|
}
|
|
|
|
func ExtractOutputTextFromResponses(resp *dto.OpenAIResponsesResponse) string {
|
|
return oairesponses.ExtractOutputTextFromResponses(resp)
|
|
}
|
|
|
|
func ExtractReasoningTextFromResponses(resp *dto.OpenAIResponsesResponse) string {
|
|
return oairesponses.ExtractReasoningTextFromResponses(resp)
|
|
}
|
|
|
|
func NewResponsesToChatStreamState(model string, includeUsage bool) *ResponsesToChatStreamState {
|
|
return oairesponses.NewResponsesToChatStreamState(model, includeUsage)
|
|
}
|
|
|
|
func ResponsesStreamEventToChatChunks(event *dto.ResponsesStreamResponse, state *ResponsesToChatStreamState) ([]dto.ChatCompletionsStreamResponse, error) {
|
|
return oairesponses.ResponsesStreamEventToChatChunks(event, state)
|
|
}
|
|
|
|
func FinalizeResponsesToChatStream(state *ResponsesToChatStreamState) []dto.ChatCompletionsStreamResponse {
|
|
return oairesponses.FinalizeResponsesToChatStream(state)
|
|
}
|
|
|
|
func NewResponsesBufferedAccumulator() *ResponsesBufferedAccumulator {
|
|
return oairesponses.NewResponsesBufferedAccumulator()
|
|
}
|