virtualmodel

type AnthropicDoneEvent ¶ added in v0.260414.2000

type AnthropicDoneEvent struct {
	StopReason string
}

AnthropicDoneEvent signals end of stream with stop reason.

type AnthropicMockResponse ¶ added in v0.260414.2000

type AnthropicMockResponse struct {
	Content    string
	ToolCall   *ToolCallConfig
	StopReason string // defaults to "stop" (or "tool_use" if ToolCall is set)
}

AnthropicMockResponse defines the Anthropic-protocol mock response for a scenario.

type AnthropicStreamStartEvent ¶ added in v0.260414.2000

type AnthropicStreamStartEvent struct {
	MsgID string
	Model string
}

AnthropicStreamStartEvent signals the start of a message stream.

type AnthropicTextDeltaEvent ¶ added in v0.260414.2000

type AnthropicTextDeltaEvent struct {
	Index int
	Text  string
}

AnthropicTextDeltaEvent carries a text content chunk.

type AnthropicToolUseEvent ¶ added in v0.260414.2000

type AnthropicToolUseEvent struct {
	Index int
	ID    string
	Name  string
	Input json.RawMessage
}

AnthropicToolUseEvent carries a complete tool_use block.

type AnthropicVirtualModel ¶ added in v0.260414.2000

type AnthropicVirtualModel interface {
	VirtualModel
	HandleAnthropic(req *protocol.AnthropicBetaMessagesRequest) (VModelResponse, error)
	HandleAnthropicStream(req *protocol.AnthropicBetaMessagesRequest, emit func(any)) error
}

AnthropicVirtualModel handles Anthropic Beta Messages requests. Models that support the Anthropic protocol implement this in addition to VirtualModel. HandleAnthropicStream must always be implemented; models that are batch-only may delegate to DefaultAnthropicStream.

type ClaudeCodeCompactTransform ¶ added in v0.260414.2000

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

ClaudeCodeCompactTransform conditionally applies XML compression for Claude Code. Only activates when: 1. Last user message contains "compact" (case-insensitive) 2. Request has tool definitions

func (t *ClaudeCodeCompactTransform) Apply(ctx *transform.TransformContext) error

func (t *ClaudeCodeCompactTransform) Name() string

type DelayConfig ¶

type DelayConfig struct {
	// Delay before the first SSE chunk is emitted (controls TTFT).
	MinFirstTokenDelayMs int
	MaxFirstTokenDelayMs int

	// Delay between the last content chunk and [DONE] (controls stream duration / TPS).
	MinEndDelayMs int
	MaxEndDelayMs int
}

DelayConfig configures the random delay ranges for a DelayProvider.

func DefaultDelayConfig() DelayConfig

type DelayProvider ¶

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

DelayProvider is an embedded OpenAI-compatible HTTP server with configurable random delays. It accepts any chat completions request, streams the fixed response "I am testing and random sleep", and produces realistic TTFT / TPS / latency values for metrics E2E testing.

Use it as a typ.Provider in routing rules so requests flow through the full proxy pipeline (routing → OpenAI client → metrics tracking).

func NewDelayProvider() *DelayProvider

func NewDelayProviderWithConfig(cfg DelayConfig) *DelayProvider

func (dp *DelayProvider) Close()

func (dp *DelayProvider) Provider(name string) *typ.Provider

func (dp *DelayProvider) URL() string

type MockModel ¶ added in v0.260414.2000

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

MockModel implements VirtualModel, AnthropicVirtualModel, and OpenAIChatVirtualModel for static and tool-type virtual models. HandleAnthropic/HandleOpenAIChat are no-ops; ResponseAnthropic/ResponseOpenAIChat return fixed content from config.

func NewMockModel(cfg *MockModelConfig) *MockModel

func (m *MockModel) GetID() string

func (m *MockModel) HandleAnthropic(_ *protocol.AnthropicBetaMessagesRequest) (VModelResponse, error)

func (m *MockModel) HandleAnthropicStream(req *protocol.AnthropicBetaMessagesRequest, emit func(any)) error

func (m *MockModel) HandleOpenAIChat(_ *protocol.OpenAIChatCompletionRequest) (OpenAIChatVModelResponse, error)

func (m *MockModel) HandleOpenAIChatStream(req *protocol.OpenAIChatCompletionRequest, emit func(any)) error

func (m *MockModel) Protocols() []protocol.APIType

func (m *MockModel) SimulatedDelay() time.Duration

func (m *MockModel) ToModel() Model

type MockModelConfig ¶ added in v0.260414.2000

type MockModelConfig struct {
	ID           string
	Name         string
	Description  string
	Content      string        // static: fixed response text
	FinishReason string        // default: "stop"
	Delay        time.Duration // simulated latency
	StreamChunks []string      // optional custom stream chunks

	// tool-type: if set, Response returns a tool_use block
	ToolCall *ToolCallConfig
}

MockModelConfig holds configuration for a mock virtual model (static or tool).

type MockScenario ¶ added in v0.260414.2000

type MockScenario struct {
	ID           string
	Name         string
	Delay        time.Duration
	StreamChunks []string

	Anthropic  *AnthropicMockResponse  // if set → implements AnthropicVirtualModel
	OpenAIChat *OpenAIChatMockResponse // if set → implements OpenAIChatVirtualModel
}

MockScenario describes a named test scenario with per-protocol mock responses. Fields Anthropic and OpenAIChat are optional; set at least one. The resulting model implements only the sub-interfaces for which a response is provided.

type Model ¶

type Model struct {
	ID      string `json:"id"`
	Object  string `json:"object"`
	Created int64  `json:"created"`
	OwnedBy string `json:"owned_by"`
}

Model represents a virtual model in the models list (OpenAI-compatible format).

type OpenAIChatDeltaEvent ¶ added in v0.260414.2000

type OpenAIChatDeltaEvent struct {
	Index   int
	Content string
}

OpenAIChatDeltaEvent carries a text content chunk.

type OpenAIChatDoneEvent ¶ added in v0.260414.2000

type OpenAIChatDoneEvent struct {
	FinishReason string
}

OpenAIChatDoneEvent signals end of stream with finish reason.

type OpenAIChatMockResponse ¶ added in v0.260414.2000

type OpenAIChatMockResponse struct {
	Content      string
	ToolCalls    []VToolCall
	FinishReason string // defaults to "stop" (or "tool_calls" if ToolCalls non-empty)
}

OpenAIChatMockResponse defines the OpenAI Chat-protocol mock response for a scenario.

type OpenAIChatToolEvent ¶ added in v0.260414.2000

type OpenAIChatToolEvent struct {
	Index    int
	ToolCall VToolCall
}

OpenAIChatToolEvent carries a tool call.

type OpenAIChatVModelResponse ¶ added in v0.260414.2000

type OpenAIChatVModelResponse struct {
	Content      string
	ToolCalls    []VToolCall
	FinishReason string
}

OpenAIChatVModelResponse describes what the virtual model returns for OpenAI Chat.

type OpenAIChatVirtualModel ¶ added in v0.260414.2000

type OpenAIChatVirtualModel interface {
	VirtualModel
	HandleOpenAIChat(req *protocol.OpenAIChatCompletionRequest) (OpenAIChatVModelResponse, error)
	HandleOpenAIChatStream(req *protocol.OpenAIChatCompletionRequest, emit func(any)) error
}

OpenAIChatVirtualModel handles OpenAI Chat Completions requests. Models that support the OpenAI Chat protocol implement this in addition to VirtualModel. HandleOpenAIChatStream must always be implemented; models that are batch-only may delegate to DefaultOpenAIChatStream.

type Registry ¶

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

Registry manages virtual models indexed by ID and by protocol type. At Register time it reads vm.Protocols() to build a protocol index and validates that each declared APIType maps to the corresponding sub-interface.

func NewRegistry() *Registry

func (r *Registry) Clear()

func (r *Registry) Get(id string) VirtualModel

func (r *Registry) GetAnthropicVM(id string) AnthropicVirtualModel

func (r *Registry) GetOpenAIChatVM(id string) OpenAIChatVirtualModel

func (r *Registry) List() []VirtualModel

func (r *Registry) ListModels() []Model

func (r *Registry) Register(vm VirtualModel) error

func (r *Registry) RegisterDefaults()

func (r *Registry) Unregister(id string)

type ToolCallConfig ¶

type ToolCallConfig struct {
	Name      string                 `json:"name" yaml:"name"`
	Arguments map[string]interface{} `json:"arguments" yaml:"arguments"`
}

ToolCallConfig defines a tool call to be returned by the virtual model.

type TransformModel ¶ added in v0.260414.2000

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

TransformModel implements AnthropicVirtualModel for proxy/transform virtual models. HandleAnthropic applies Chain and Transformer in-place on req; ResponseAnthropic reads the result. It does NOT implement OpenAIChatVirtualModel — transform models are Anthropic-only.

func NewTransformModel(cfg *TransformModelConfig) *TransformModel

func (m *TransformModel) GetID() string

func (m *TransformModel) HandleAnthropic(req *protocol.AnthropicBetaMessagesRequest) (VModelResponse, error)

func (m *TransformModel) HandleAnthropicStream(req *protocol.AnthropicBetaMessagesRequest, emit func(any)) error

func (m *TransformModel) Protocols() []protocol.APIType

func (m *TransformModel) SimulatedDelay() time.Duration

func (m *TransformModel) ToModel() Model

type TransformModelConfig ¶ added in v0.260414.2000

type TransformModelConfig struct {
	ID          string
	Name        string
	Description string
	Transformer transform.Transform       // applied after Chain
	Chain       *transform.TransformChain // applied first
}

TransformModelConfig holds configuration for a transform virtual model (proxy).

type VModelResponse ¶ added in v0.260414.2000

type VModelResponse struct {
	Content    []anthropic.BetaContentBlockParamUnion
	StopReason anthropic.BetaStopReason
}

VModelResponse describes what the virtual model wants to respond (Anthropic protocol).

type VToolCall ¶ added in v0.260414.2000

type VToolCall struct {
	ID        string
	Name      string
	Arguments string // JSON-encoded arguments
}

VToolCall is a protocol-agnostic tool call used in OpenAI Chat responses. Using an intermediate type avoids coupling to the OpenAI SDK here.

type VirtualModel ¶

type VirtualModel interface {
	GetID() string
	SimulatedDelay() time.Duration
	ToModel() Model

	// Protocols returns the set of API types this model supports.
	// Each declared type must correspond to an implemented sub-interface.
	Protocols() []protocol.APIType
}

VirtualModel is the protocol-agnostic base interface. All virtual model types implement this.

Protocols() declares which API types this model supports. Registry uses this at registration time to build a protocol index and validate that declared protocols match the implemented sub-interfaces (AnthropicVirtualModel, OpenAIChatVirtualModel). Callers use Registry typed getters instead of performing type assertions themselves.

func NewMockModelFromScenario(s *MockScenario) VirtualModel