translator

type Format ¶

type Format string

Format identifies a request/response schema used inside the proxy.

const (
	FormatOpenAI         Format = "openai"
	FormatOpenAIResponse Format = "openai-response"
	FormatClaude         Format = "claude"
	FormatGemini         Format = "gemini"
	FormatGeminiCLI      Format = "gemini-cli"
	FormatCodex          Format = "codex"
	FormatAntigravity    Format = "antigravity"
)

func FromString(v string) Format

func (f Format) String() string

type Pipeline ¶

type Pipeline struct {
	// contains filtered or unexported fields
}

Pipeline orchestrates request/response transformation with middleware support.

func NewPipeline(registry *Registry) *Pipeline

func (p *Pipeline) TranslateRequest(ctx context.Context, from, to Format, req RequestEnvelope) (RequestEnvelope, error)

func (p *Pipeline) TranslateResponse(ctx context.Context, from, to Format, resp ResponseEnvelope, originalReq, translatedReq []byte, param *any) (ResponseEnvelope, error)

func (p *Pipeline) UseRequest(mw RequestMiddleware)

func (p *Pipeline) UseResponse(mw ResponseMiddleware)

type PluginHooks ¶

type PluginHooks interface {
	NormalizeRequest(ctx context.Context, from, to Format, model string, body []byte, stream bool) []byte
	TranslateRequest(ctx context.Context, from, to Format, model string, body []byte, stream bool) ([]byte, bool)
	NormalizeResponseBefore(ctx context.Context, from, to Format, model string, originalRequestRawJSON, requestRawJSON, body []byte, stream bool) []byte
	TranslateResponse(ctx context.Context, from, to Format, model string, originalRequestRawJSON, requestRawJSON, body []byte, stream bool) ([]byte, bool)
	NormalizeResponseAfter(ctx context.Context, from, to Format, model string, originalRequestRawJSON, requestRawJSON, body []byte, stream bool) []byte
}

PluginHooks defines optional translator extension hooks provided by plugins. The plugin host implements this interface and installs it via Registry.SetPluginHooks so that plugin-supplied translators participate in the regular translation pipeline.

Normalize* methods always run and may rewrite the body in place. The Translate* methods are fallbacks consulted only when no native translator is registered for the (from, to) format pair; the bool result reports whether the plugin supplied a translation. This split keeps plugin translators from overriding native behaviour while still allowing plugins to introduce new format pairs.

type Registry ¶

type Registry struct {
	// contains filtered or unexported fields
}

Registry manages translation functions across schemas.

func Default() *Registry

func NewRegistry() *Registry

func (r *Registry) HasNonStreamResponseTransformer(from, to Format) bool

func (r *Registry) HasRequestTransformer(from, to Format) bool

func (r *Registry) HasResponseTransformer(from, to Format) bool

func (r *Registry) HasStreamResponseTransformer(from, to Format) bool

func (r *Registry) Register(from, to Format, request RequestTransform, response ResponseTransform)

func (r *Registry) SetPluginHooks(hooks PluginHooks)

func (r *Registry) TranslateNonStream(ctx context.Context, from, to Format, model string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, param *any) []byte

func (r *Registry) TranslateRequest(from, to Format, model string, rawJSON []byte, stream bool) []byte

func (r *Registry) TranslateStream(ctx context.Context, from, to Format, model string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, param *any) [][]byte

func (r *Registry) TranslateTokenCount(ctx context.Context, from, to Format, count int64, rawJSON []byte) []byte

type RequestEnvelope ¶

type RequestEnvelope struct {
	Format Format
	Model  string
	Stream bool
	Body   []byte
}

RequestEnvelope represents a request in the translation pipeline.

type RequestHandler ¶

type RequestHandler func(ctx context.Context, req RequestEnvelope) (RequestEnvelope, error)

RequestHandler performs request translation between formats.

type RequestMiddleware ¶

type RequestMiddleware func(ctx context.Context, req RequestEnvelope, next RequestHandler) (RequestEnvelope, error)

RequestMiddleware decorates request translation.

type RequestTransform ¶

type RequestTransform func(model string, rawJSON []byte, stream bool) []byte

RequestTransform is a function type that converts a request payload from a source schema to a target schema. It takes the model name, the raw JSON payload of the request, and a boolean indicating if the request is for a streaming response. It returns the converted request payload as a byte slice.

type ResponseEnvelope ¶

type ResponseEnvelope struct {
	Format Format
	Model  string
	Stream bool
	Body   []byte
	Chunks [][]byte
}

ResponseEnvelope represents a response in the translation pipeline.

type ResponseHandler ¶

type ResponseHandler func(ctx context.Context, resp ResponseEnvelope) (ResponseEnvelope, error)

ResponseHandler performs response translation between formats.

type ResponseMiddleware ¶

type ResponseMiddleware func(ctx context.Context, resp ResponseEnvelope, next ResponseHandler) (ResponseEnvelope, error)

ResponseMiddleware decorates response translation.

type ResponseNonStreamTransform ¶

type ResponseNonStreamTransform func(ctx context.Context, model string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, param *any) []byte

ResponseNonStreamTransform is a function type that converts a non-streaming response from a source schema to a target schema. It takes a context, the model name, the raw JSON of the original and converted requests, the raw JSON of the response, and an optional parameter. It returns the converted response as a single byte slice.

type ResponseStreamTransform ¶

type ResponseStreamTransform func(ctx context.Context, model string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, param *any) [][]byte

ResponseStreamTransform is a function type that converts a streaming response from a source schema to a target schema. It takes a context, the model name, the raw JSON of the original and converted requests, the raw JSON of the current response chunk, and an optional parameter. It returns a slice of byte chunks containing the converted streaming response.

type ResponseTokenCountTransform ¶

type ResponseTokenCountTransform func(ctx context.Context, count int64) []byte

ResponseTokenCountTransform is a function type that transforms a token count from a source format to a target format. It takes a context and the token count as an int64, and returns the transformed token count as bytes.

type ResponseTransform ¶

type ResponseTransform struct {
	// Stream is the function for transforming streaming responses.
	Stream ResponseStreamTransform
	// NonStream is the function for transforming non-streaming responses.
	NonStream ResponseNonStreamTransform
	// TokenCount is the function for transforming token counts.
	TokenCount ResponseTokenCountTransform
}

ResponseTransform is a struct that groups together the functions for transforming streaming and non-streaming responses, as well as token counts.