transformer

package
v1.5.1 Latest Latest
Warning

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

Go to latest
Published: Nov 19, 2025 License: MIT Imports: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsRegistered

func IsRegistered(name string) bool

IsRegistered checks if a transformer is registered

func List

func List() []string

List returns all registered transformer names

func Register

func Register(t Transformer)

Register registers a transformer

Types

type ClaudeMessage

type ClaudeMessage struct {
	Role         string      `json:"role"`
	Content      interface{} `json:"content"`                 // Can be string or array of content blocks
	CacheControl interface{} `json:"cache_control,omitempty"` // Prompt caching (ignored in transformation)
}

ClaudeMessage represents a message in Claude format

type ClaudeRequest

type ClaudeRequest struct {
	Model       string          `json:"model"`
	Messages    []ClaudeMessage `json:"messages"`
	MaxTokens   int             `json:"max_tokens,omitempty"`
	Temperature float64         `json:"temperature,omitempty"`
	Stream      bool            `json:"stream,omitempty"`
	System      interface{}     `json:"system,omitempty"`   // Can be string or array of system messages
	Thinking    interface{}     `json:"thinking,omitempty"` // Claude's thinking/extended thinking parameter
	Tools       []ClaudeTool    `json:"tools,omitempty"`
	ToolChoice  interface{}     `json:"tool_choice,omitempty"`
}

ClaudeRequest represents a Claude API request

type ClaudeResponse

type ClaudeResponse struct {
	ID      string `json:"id"`
	Type    string `json:"type"`
	Role    string `json:"role"`
	Content []struct {
		Type string `json:"type"`
		Text string `json:"text"`
	} `json:"content"`
	Model        string `json:"model"`
	StopReason   string `json:"stop_reason"`
	StopSequence string `json:"stop_sequence,omitempty"`
	Usage        struct {
		InputTokens  int `json:"input_tokens"`
		OutputTokens int `json:"output_tokens"`
	} `json:"usage"`
}

ClaudeResponse represents a Claude API response

type ClaudeStreamEvent

type ClaudeStreamEvent struct {
	Type  string `json:"type"`
	Index int    `json:"index,omitempty"`
	Delta struct {
		Type string `json:"type"`
		Text string `json:"text"`
	} `json:"delta,omitempty"`
	ContentBlock struct {
		Type string `json:"type"`
		Text string `json:"text"`
	} `json:"content_block,omitempty"`
	Message struct {
		ID      string `json:"id"`
		Type    string `json:"type"`
		Role    string `json:"role"`
		Content []struct {
			Type string `json:"type"`
			Text string `json:"text"`
		} `json:"content"`
		Model      string `json:"model"`
		StopReason string `json:"stop_reason"`
		Usage      struct {
			InputTokens  int `json:"input_tokens"`
			OutputTokens int `json:"output_tokens"`
		} `json:"usage"`
	} `json:"message,omitempty"`
	Usage struct {
		OutputTokens int `json:"output_tokens"`
	} `json:"usage,omitempty"`
}

ClaudeStreamEvent represents a Claude streaming event

type ClaudeTool

type ClaudeTool struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description,omitempty"`
	InputSchema map[string]interface{} `json:"input_schema"`
}

ClaudeTool represents a tool definition in Claude format

type ClaudeTransformer

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

ClaudeTransformer handles Claude API with optional model override

func NewClaudeTransformer

func NewClaudeTransformer() *ClaudeTransformer

NewClaudeTransformer creates a new Claude transformer

func NewClaudeTransformerWithModel added in v0.5.3

func NewClaudeTransformerWithModel(model string) *ClaudeTransformer

NewClaudeTransformerWithModel creates a new Claude transformer with model override

func (*ClaudeTransformer) Name

func (t *ClaudeTransformer) Name() string

Name returns the transformer name

func (*ClaudeTransformer) TransformRequest

func (t *ClaudeTransformer) TransformRequest(claudeReq []byte) ([]byte, error)

TransformRequest handles Claude API request with optional model override

func (*ClaudeTransformer) TransformResponse

func (t *ClaudeTransformer) TransformResponse(targetResp []byte, isStreaming bool) ([]byte, error)

TransformResponse normalizes the response for compatibility

type GeminiContent

type GeminiContent struct {
	Role  string       `json:"role"`
	Parts []GeminiPart `json:"parts"`
}

GeminiContent represents content in Gemini format

type GeminiFunctionCall

type GeminiFunctionCall struct {
	Name string                 `json:"name"`
	Args map[string]interface{} `json:"args"`
}

GeminiFunctionCall represents a function call in Gemini format

type GeminiFunctionDeclaration

type GeminiFunctionDeclaration struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description,omitempty"`
	Parameters  map[string]interface{} `json:"parameters"`
}

GeminiFunctionDeclaration represents a function declaration in Gemini format

type GeminiFunctionResponse

type GeminiFunctionResponse struct {
	Name     string                 `json:"name"`
	Response map[string]interface{} `json:"response"`
}

GeminiFunctionResponse represents a function response in Gemini format

type GeminiGenerationConfig

type GeminiGenerationConfig struct {
	Temperature     *float64 `json:"temperature,omitempty"`
	MaxOutputTokens *int     `json:"maxOutputTokens,omitempty"`
	StopSequences   []string `json:"stopSequences,omitempty"`
}

GeminiGenerationConfig represents generation configuration in Gemini format

type GeminiPart

type GeminiPart struct {
	Text             string                  `json:"text,omitempty"`
	FunctionCall     *GeminiFunctionCall     `json:"functionCall,omitempty"`
	FunctionResponse *GeminiFunctionResponse `json:"functionResponse,omitempty"`
}

GeminiPart represents a part in Gemini format

type GeminiRequest

type GeminiRequest struct {
	Contents          []GeminiContent         `json:"contents"`
	SystemInstruction *GeminiContent          `json:"systemInstruction,omitempty"`
	Tools             []GeminiTool            `json:"tools,omitempty"`
	GenerationConfig  *GeminiGenerationConfig `json:"generationConfig,omitempty"`
}

GeminiRequest represents a Gemini API request

type GeminiResponse

type GeminiResponse struct {
	Candidates []struct {
		Content struct {
			Parts []GeminiPart `json:"parts"`
			Role  string       `json:"role"`
		} `json:"content"`
		FinishReason string `json:"finishReason"`
		Index        int    `json:"index"`
	} `json:"candidates"`
	UsageMetadata struct {
		PromptTokenCount     int `json:"promptTokenCount"`
		CandidatesTokenCount int `json:"candidatesTokenCount"`
		TotalTokenCount      int `json:"totalTokenCount"`
	} `json:"usageMetadata"`
}

GeminiResponse represents a Gemini API response

type GeminiStreamChunk

type GeminiStreamChunk struct {
	Candidates []struct {
		Content struct {
			Parts []GeminiPart `json:"parts"`
			Role  string       `json:"role"`
		} `json:"content"`
		FinishReason string `json:"finishReason,omitempty"`
		Index        int    `json:"index"`
	} `json:"candidates"`
	UsageMetadata *struct {
		PromptTokenCount     int `json:"promptTokenCount"`
		CandidatesTokenCount int `json:"candidatesTokenCount"`
		TotalTokenCount      int `json:"totalTokenCount"`
	} `json:"usageMetadata,omitempty"`
}

GeminiStreamChunk represents a streaming response chunk from Gemini

type GeminiTool

type GeminiTool struct {
	FunctionDeclarations []GeminiFunctionDeclaration `json:"functionDeclarations"`
}

GeminiTool represents a tool definition in Gemini format

type GeminiTransformer

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

GeminiTransformer transforms between Claude and Gemini API formats

func NewGeminiTransformer

func NewGeminiTransformer(model string) *GeminiTransformer

NewGeminiTransformer creates a new Gemini transformer

func (*GeminiTransformer) Name

func (t *GeminiTransformer) Name() string

Name returns the transformer name

func (*GeminiTransformer) TransformRequest

func (t *GeminiTransformer) TransformRequest(claudeReq []byte) ([]byte, error)

TransformRequest converts Claude format request to Gemini format

func (*GeminiTransformer) TransformResponse

func (t *GeminiTransformer) TransformResponse(targetResp []byte, isStreaming bool) ([]byte, error)

TransformResponse converts Gemini format response to Claude format

func (*GeminiTransformer) TransformResponseWithContext

func (t *GeminiTransformer) TransformResponseWithContext(targetResp []byte, isStreaming bool, ctx *StreamContext) ([]byte, error)

TransformResponseWithContext converts Gemini format response to Claude format

type OpenAIMessage

type OpenAIMessage struct {
	Role       string           `json:"role"`
	Content    string           `json:"content,omitempty"`
	ToolCalls  []OpenAIToolCall `json:"tool_calls,omitempty"`
	ToolCallID string           `json:"tool_call_id,omitempty"`
}

OpenAIMessage represents a message in OpenAI format

type OpenAIRequest

type OpenAIRequest struct {
	Model               string          `json:"model"`
	Messages            []OpenAIMessage `json:"messages"`
	MaxCompletionTokens int             `json:"max_completion_tokens,omitempty"`
	Temperature         float64         `json:"temperature,omitempty"`
	Stream              bool            `json:"stream,omitempty"`
	StreamOptions       *StreamOptions  `json:"stream_options,omitempty"`
	EnableThinking      bool            `json:"enable_thinking,omitempty"` // For models that support reasoning/thinking
	Tools               []OpenAITool    `json:"tools,omitempty"`
	ToolChoice          interface{}     `json:"tool_choice,omitempty"`
}

OpenAIRequest represents an OpenAI API request

type OpenAIResponse

type OpenAIResponse struct {
	ID      string `json:"id"`
	Object  string `json:"object"`
	Created int64  `json:"created"`
	Model   string `json:"model"`
	Choices []struct {
		Index   int `json:"index"`
		Message struct {
			Role      string           `json:"role"`
			Content   string           `json:"content"`
			ToolCalls []OpenAIToolCall `json:"tool_calls,omitempty"`
		} `json:"message"`
		FinishReason string `json:"finish_reason"`
	} `json:"choices"`
	Usage struct {
		PromptTokens     int `json:"prompt_tokens"`
		CompletionTokens int `json:"completion_tokens"`
		TotalTokens      int `json:"total_tokens"`
	} `json:"usage"`
}

OpenAIResponse represents an OpenAI API response

type OpenAIStreamChunk

type OpenAIStreamChunk struct {
	ID      string `json:"id"`
	Object  string `json:"object"`
	Created int64  `json:"created"`
	Model   string `json:"model"`
	Choices []struct {
		Index int `json:"index"`
		Delta struct {
			Role             string           `json:"role,omitempty"`
			Content          string           `json:"content,omitempty"`
			ReasoningContent string           `json:"reasoning_content,omitempty"` // For models with reasoning/thinking
			ToolCalls        []OpenAIToolCall `json:"tool_calls,omitempty"`
		} `json:"delta"`
		FinishReason *string `json:"finish_reason"`
	} `json:"choices"`
	Usage *struct {
		PromptTokens     int `json:"prompt_tokens"`
		CompletionTokens int `json:"completion_tokens"`
		TotalTokens      int `json:"total_tokens"`
	} `json:"usage,omitempty"`
}

OpenAIStreamChunk represents a streaming response chunk

type OpenAITool

type OpenAITool struct {
	Type     string `json:"type"`
	Function struct {
		Name        string                 `json:"name"`
		Description string                 `json:"description,omitempty"`
		Parameters  map[string]interface{} `json:"parameters"`
	} `json:"function"`
}

OpenAITool represents a tool definition in OpenAI format

type OpenAIToolCall

type OpenAIToolCall struct {
	Index    *int   `json:"index,omitempty"`
	ID       string `json:"id"`
	Type     string `json:"type"`
	Function struct {
		Name      string `json:"name"`
		Arguments string `json:"arguments"`
	} `json:"function"`
}

OpenAIToolCall represents a tool call in OpenAI format

type OpenAITransformer

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

OpenAITransformer transforms between Claude and OpenAI API formats This transformer is now stateless - all state is passed via StreamContext

func NewOpenAITransformer

func NewOpenAITransformer(model string) *OpenAITransformer

NewOpenAITransformer creates a new OpenAI transformer

func (*OpenAITransformer) Name

func (t *OpenAITransformer) Name() string

Name returns the transformer name

func (*OpenAITransformer) TransformRequest

func (t *OpenAITransformer) TransformRequest(claudeReq []byte) ([]byte, error)

TransformRequest converts Claude format request to OpenAI format

func (*OpenAITransformer) TransformResponse

func (t *OpenAITransformer) TransformResponse(targetResp []byte, isStreaming bool) ([]byte, error)

TransformResponse converts OpenAI format response to Claude format

func (*OpenAITransformer) TransformResponseWithContext

func (t *OpenAITransformer) TransformResponseWithContext(targetResp []byte, isStreaming bool, ctx *StreamContext) ([]byte, error)

TransformResponseWithContext converts OpenAI format response to Claude format

type StreamContext

type StreamContext struct {
	MessageStartSent     bool
	ContentBlockStarted  bool
	ThinkingBlockStarted bool // Track if thinking block has been started
	ToolBlockStarted     bool // Track if tool_use block has been started
	ToolBlockPending     bool // Track if tool_use block is pending (waiting for first arguments)
	MessageID            string
	ModelName            string
	InputTokens          int
	OutputTokens         int
	ContentIndex         int
	ThinkingIndex        int // Index for thinking content block
	ToolIndex            int // Current tool_use content block index (from OpenAI)
	LastToolIndex        int // Last assigned Anthropic tool block index (incremental counter)
	FinishReasonSent     bool
	EnableThinking       bool            // Whether thinking is enabled for this request
	CurrentToolCall      *OpenAIToolCall // Current tool call being processed
	ToolCallBuffer       string          // Buffer for accumulating tool call arguments
}

StreamContext holds the state for a single streaming response This allows multiple concurrent streams to be processed independently

func NewStreamContext

func NewStreamContext() *StreamContext

NewStreamContext creates a new stream context with default values

type StreamOptions added in v0.7.0

type StreamOptions struct {
	IncludeUsage bool `json:"include_usage"`
}

StreamOptions represents OpenAI stream options

type Transformer

type Transformer interface {
	// TransformRequest converts Claude format request to target API format
	TransformRequest(claudeReq []byte) (targetReq []byte, err error)

	// TransformResponse converts target API format response to Claude format
	TransformResponse(targetResp []byte, isStreaming bool) (claudeResp []byte, err error)

	// Name returns the transformer name
	Name() string
}

Transformer defines the interface for API format transformation

func Get

func Get(name string) (Transformer, error)

Get retrieves a transformer by name

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL