transformer

package
v1.8.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 25, 2025 License: MIT Imports: 15 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ParseTransformerConfig 

func ParseTransformerConfig(input interface{}) ([]config.TransformerConfig, error)

ParseTransformerConfig parses transformer configuration from various formats

func RegisterBuiltinTransformers 

func RegisterBuiltinTransformers(service *Service) error

RegisterBuiltinTransformers registers all built-in transformers

func StreamPipe 

func StreamPipe(reader StreamReader, writer StreamWriter, transform func(*SSEEvent) (*SSEEvent, error)) error

StreamPipe pipes data from reader to writer with optional transformation

Types

type AnthropicTransformer 

type AnthropicTransformer struct {
	BaseTransformer
}

AnthropicTransformer converts between OpenAI and Anthropic message formats

func NewAnthropicTransformer 

func NewAnthropicTransformer() *AnthropicTransformer

NewAnthropicTransformer creates a new Anthropic transformer

func (*AnthropicTransformer) TransformRequestIn 

func (t *AnthropicTransformer) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

TransformRequestIn transforms OpenAI format to Anthropic format

func (*AnthropicTransformer) TransformResponseOut 

func (t *AnthropicTransformer) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

TransformResponseOut transforms Anthropic streaming response to OpenAI format

type BaseTransformer 

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

BaseTransformer provides default implementations

func NewBaseTransformer 

func NewBaseTransformer(name string, endpoint string) *BaseTransformer

NewBaseTransformer creates a new base transformer

func (*BaseTransformer) GetEndpoint 

func (t *BaseTransformer) GetEndpoint() string

func (*BaseTransformer) GetName 

func (t *BaseTransformer) GetName() string

func (*BaseTransformer) TransformRequestIn 

func (t *BaseTransformer) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

func (*BaseTransformer) TransformRequestOut 

func (t *BaseTransformer) TransformRequestOut(ctx context.Context, request interface{}) (interface{}, error)

func (*BaseTransformer) TransformResponseIn 

func (t *BaseTransformer) TransformResponseIn(ctx context.Context, response *http.Response) (*http.Response, error)

func (*BaseTransformer) TransformResponseOut 

func (t *BaseTransformer) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

type DeepSeekTransformer 

type DeepSeekTransformer struct {
	BaseTransformer
}

DeepSeekTransformer handles DeepSeek-specific transformations

func NewDeepSeekTransformer 

func NewDeepSeekTransformer() *DeepSeekTransformer

NewDeepSeekTransformer creates a new DeepSeek transformer

func (*DeepSeekTransformer) TransformRequestIn 

func (t *DeepSeekTransformer) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

TransformRequestIn transforms the request for DeepSeek

func (*DeepSeekTransformer) TransformResponseOut 

func (t *DeepSeekTransformer) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

TransformResponseOut transforms DeepSeek streaming response

type GeminiTransformer 

type GeminiTransformer struct {
	BaseTransformer
}

GeminiTransformer handles Google Gemini-specific transformations

func NewGeminiTransformer 

func NewGeminiTransformer() *GeminiTransformer

NewGeminiTransformer creates a new Gemini transformer

func (*GeminiTransformer) TransformRequestIn 

func (t *GeminiTransformer) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

TransformRequestIn transforms OpenAI format to Gemini format

func (*GeminiTransformer) TransformRequestOut 

func (t *GeminiTransformer) TransformRequestOut(ctx context.Context, request interface{}) (interface{}, error)

TransformRequestOut modifies the outgoing HTTP request

func (*GeminiTransformer) TransformResponseOut 

func (t *GeminiTransformer) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

TransformResponseOut transforms Gemini response to OpenAI format

type MaxTokenTransformer 

type MaxTokenTransformer struct {
	*BaseTransformer
	// contains filtered or unexported fields
}

MaxTokenTransformer handles max_tokens parameter across different providers

func NewMaxTokenTransformer 

func NewMaxTokenTransformer() *MaxTokenTransformer

NewMaxTokenTransformer creates a new MaxToken transformer

func (*MaxTokenTransformer) GetProviderLimit 

func (t *MaxTokenTransformer) GetProviderLimit(provider string) int

GetProviderLimit returns the token limit for a provider

func (*MaxTokenTransformer) SetProviderLimit 

func (t *MaxTokenTransformer) SetProviderLimit(provider string, limit int)

SetProviderLimit sets the token limit for a provider

func (*MaxTokenTransformer) TransformRequestIn 

func (t *MaxTokenTransformer) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

TransformRequestIn ensures max_tokens is within provider limits

func (*MaxTokenTransformer) TransformResponseOut 

func (t *MaxTokenTransformer) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

TransformResponseOut adds token usage information if available

type OpenAITransformer 

type OpenAITransformer struct {
	BaseTransformer
}

OpenAITransformer is a minimal transformer for OpenAI API It primarily serves to define the endpoint, as OpenAI's format is already the standard that other transformers convert to/from

func NewOpenAITransformer 

func NewOpenAITransformer() *OpenAITransformer

NewOpenAITransformer creates a new OpenAI transformer

type OpenRouterTransformer 

type OpenRouterTransformer struct {
	BaseTransformer
}

OpenRouterTransformer handles OpenRouter-specific transformations

func NewOpenRouterTransformer 

func NewOpenRouterTransformer() *OpenRouterTransformer

NewOpenRouterTransformer creates a new OpenRouter transformer

func (*OpenRouterTransformer) TransformResponseOut 

func (t *OpenRouterTransformer) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

TransformResponseOut transforms OpenRouter streaming response

type ParametersTransformer 

type ParametersTransformer struct {
	*BaseTransformer
	// contains filtered or unexported fields
}

ParametersTransformer handles common parameters across different providers

func NewParametersTransformer 

func NewParametersTransformer() *ParametersTransformer

NewParametersTransformer creates a new Parameters transformer

func (*ParametersTransformer) SetParameterLimit 

func (t *ParametersTransformer) SetParameterLimit(provider, parameter string, min, max float64)

SetParameterLimit sets a parameter limit for a provider

func (*ParametersTransformer) SetParameterMapping 

func (t *ParametersTransformer) SetParameterMapping(provider, original, mapped string)

SetParameterMapping sets a custom parameter mapping for a provider

func (*ParametersTransformer) TransformRequestIn 

func (t *ParametersTransformer) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

TransformRequestIn validates and maps parameters for the provider

type Range 

type Range struct {
	Min float64
	Max float64
}

Range defines min and max values for a parameter

type RequestConfig 

type RequestConfig struct {
	Body    interface{}       `json:"body"`
	URL     string            `json:"url,omitempty"`
	Headers map[string]string `json:"headers,omitempty"`
	Method  string            `json:"method,omitempty"`
	Timeout int               `json:"timeout,omitempty"`
}

RequestConfig allows transformers to modify HTTP request configuration

type Response 

type Response struct {
	Response *http.Response
}

Response wraps http.Response for type safety

type SSEEvent 

type SSEEvent struct {
	Event string `json:"event,omitempty"`
	Data  string `json:"data"`
	ID    string `json:"id,omitempty"`
	Retry int    `json:"retry,omitempty"`
}

SSEEvent represents a Server-Sent Event

type SSEReader 

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

SSEReader implements StreamReader for Server-Sent Events

func NewSSEReader 

func NewSSEReader(r io.ReadCloser) *SSEReader

NewSSEReader creates a new SSE reader

func (*SSEReader) Close 

func (r *SSEReader) Close() error

Close closes the reader

func (*SSEReader) ReadEvent 

func (r *SSEReader) ReadEvent() (*SSEEvent, error)

ReadEvent reads the next SSE event

type SSEWriter 

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

SSEWriter implements StreamWriter for Server-Sent Events

func NewSSEWriter 

func NewSSEWriter(w io.Writer) *SSEWriter

NewSSEWriter creates a new SSE writer

func (*SSEWriter) Close 

func (w *SSEWriter) Close() error

Close closes the writer

func (*SSEWriter) Flush 

func (w *SSEWriter) Flush() error

Flush flushes any buffered data

func (*SSEWriter) WriteEvent 

func (w *SSEWriter) WriteEvent(event *SSEEvent) error

WriteEvent writes an SSE event

type Service 

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

Service manages transformers and their lifecycle

func GetRegistry 

func GetRegistry() *Service

GetRegistry returns the global transformer registry

func NewService 

func NewService() *Service

NewService creates a new transformer service

func (*Service) ApplyRequestTransformation 

func (s *Service) ApplyRequestTransformation(ctx context.Context, provider *config.Provider, request interface{}) (interface{}, error)

ApplyRequestTransformation applies request transformations for a provider

func (*Service) ApplyResponseTransformation 

func (s *Service) ApplyResponseTransformation(ctx context.Context, provider *config.Provider, response interface{}) (interface{}, error)

ApplyResponseTransformation applies response transformations for a provider

func (*Service) CreateChain 

func (s *Service) CreateChain(configs []config.TransformerConfig) (*TransformerChain, error)

CreateChain creates a transformer chain from configuration

func (*Service) CreateChainFromNames 

func (s *Service) CreateChainFromNames(names []string) (*TransformerChain, error)

CreateChainFromNames creates a transformer chain from transformer names

func (*Service) Get 

func (s *Service) Get(name string) (Transformer, error)

Get retrieves a transformer by name

func (*Service) GetByEndpoint 

func (s *Service) GetByEndpoint(endpoint string) []Transformer

GetByEndpoint retrieves transformers that handle a specific endpoint

func (*Service) GetChainForProvider 

func (s *Service) GetChainForProvider(providerName string) *TransformerChain

GetChainForProvider gets the transformer chain for a provider by name

func (*Service) GetOrCreateChain 

func (s *Service) GetOrCreateChain(provider *config.Provider) (*TransformerChain, error)

GetOrCreateChain gets or creates a transformer chain for a provider

func (*Service) Register 

func (s *Service) Register(transformer Transformer) error

Register registers a transformer

func (*Service) TransformRequest 

func (s *Service) TransformRequest(ctx context.Context, transformerName string, req *http.Request, body []byte) ([]byte, map[string]string, error)

TransformRequest applies transformations using a named transformer

type StreamReader 

type StreamReader interface {
	// ReadEvent reads the next SSE event from the stream
	ReadEvent() (*SSEEvent, error)

	// Close closes the stream reader
	Close() error
}

StreamReader provides methods to read from a stream

type StreamTransformer 

type StreamTransformer interface {
	Transformer

	// TransformStream handles streaming response transformation
	TransformStream(ctx context.Context, reader StreamReader, writer StreamWriter) error
}

StreamTransformer defines additional methods for streaming transformers

type StreamWriter 

type StreamWriter interface {
	// WriteEvent writes an SSE event to the stream
	WriteEvent(event *SSEEvent) error

	// Flush flushes any buffered data
	Flush() error

	// Close closes the stream writer
	Close() error
}

StreamWriter provides methods to write to a stream

type ToolTransformer 

type ToolTransformer struct {
	BaseTransformer
	// contains filtered or unexported fields
}

ToolTransformer handles tool-related transformations

func NewToolTransformer 

func NewToolTransformer() *ToolTransformer

NewToolTransformer creates a new tool transformer

func (*ToolTransformer) CreateToolResultMessage 

func (t *ToolTransformer) CreateToolResultMessage(results []tools.ToolResult) interface{}

CreateToolResultMessage creates a tool result message

func (*ToolTransformer) ExtractToolCalls 

func (t *ToolTransformer) ExtractToolCalls(message interface{}) ([]tools.ToolUse, error)

ExtractToolCalls extracts tool calls from a response message

func (*ToolTransformer) TransformRequest 

func (t *ToolTransformer) TransformRequest(ctx context.Context, provider *config.Provider, request interface{}) (interface{}, error)

TransformRequest transforms tool definitions in the request

func (*ToolTransformer) TransformResponse 

func (t *ToolTransformer) TransformResponse(ctx context.Context, provider *config.Provider, response interface{}) (interface{}, error)

TransformResponse processes tool use in responses

func (*ToolTransformer) TransformSSEEvent 

func (t *ToolTransformer) TransformSSEEvent(ctx context.Context, provider *config.Provider, event string) (string, error)

TransformSSEEvent transforms tool use in SSE events

type ToolUseTransformer 

type ToolUseTransformer struct {
	BaseTransformer
}

ToolUseTransformer handles tool mode transformations

func NewToolUseTransformer 

func NewToolUseTransformer() *ToolUseTransformer

NewToolUseTransformer creates a new ToolUse transformer

func (*ToolUseTransformer) TransformRequestIn 

func (t *ToolUseTransformer) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

TransformRequestIn adds ExitTool and enforces tool usage

func (*ToolUseTransformer) TransformResponseOut 

func (t *ToolUseTransformer) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

TransformResponseOut intercepts ExitTool calls and converts to content

type Transformer 

type Transformer interface {
	// GetName returns the transformer name
	GetName() string

	// GetEndpoint returns the endpoint this transformer handles (optional)
	GetEndpoint() string

	// TransformRequestIn transforms an incoming unified request to provider-specific format
	// Can return just the body, or RequestConfig with additional HTTP configuration
	TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

	// TransformRequestOut transforms a provider-specific request to unified format
	TransformRequestOut(ctx context.Context, request interface{}) (interface{}, error)

	// TransformResponseIn transforms a provider response to internal format
	TransformResponseIn(ctx context.Context, response *http.Response) (*http.Response, error)

	// TransformResponseOut transforms an internal response to client format
	TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)
}

Transformer defines the interface for request/response transformations

type TransformerChain 

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

TransformerChain represents a chain of transformers

func NewTransformerChain 

func NewTransformerChain(transformers ...Transformer) *TransformerChain

NewTransformerChain creates a new transformer chain

func (*TransformerChain) Add 

func (c *TransformerChain) Add(transformer Transformer)

Add adds a transformer to the chain

func (*TransformerChain) TransformRequestIn 

func (c *TransformerChain) TransformRequestIn(ctx context.Context, request interface{}, provider string) (interface{}, error)

TransformRequestIn applies all transformers' TransformRequestIn in order

func (*TransformerChain) TransformResponseOut 

func (c *TransformerChain) TransformResponseOut(ctx context.Context, response *http.Response) (*http.Response, error)

TransformResponseOut applies all transformers' TransformResponseOut in reverse order

func (*TransformerChain) TransformSSEEvent 

func (c *TransformerChain) TransformSSEEvent(ctx context.Context, event *SSEEvent, provider string) (*SSEEvent, error)

TransformSSEEvent transforms an SSE event through the chain

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.