server/llm/openai/openai_test.go - staff - Gitiles

 package openai

 import (
 	"testing"
 	"time"

 	"github.com/iomodo/staff/llm"
 )

 func TestOpenAIProvider_Interface(t *testing.T) {
 	// Test that OpenAIProvider implements LLMProvider interface
 	var _ llm.LLMProvider = (*OpenAIProvider)(nil)
 }

 func TestOpenAIFactory_CreateProvider(t *testing.T) {
 	factory := &OpenAIFactory{}

 	// Test valid config
 	config := llm.Config{
 		Provider: llm.ProviderOpenAI,
 		APIKey:   "test-key",
 		BaseURL:  "https://api.openai.com/v1",
 		Timeout:  30 * time.Second,
 	}

 	provider, err := factory.CreateProvider(config)
 	if err != nil {
 		t.Fatalf("Failed to create provider: %v", err)
 	}

 	if provider == nil {
 		t.Fatal("Provider should not be nil")
 	}

 	// Test invalid provider
 	invalidConfig := llm.Config{
 		Provider: llm.ProviderClaude,
 		APIKey:   "test-key",
 	}

 	_, err = factory.CreateProvider(invalidConfig)
 	if err == nil {
 		t.Fatal("Should fail with invalid provider")
 	}

 	// Test missing API key
 	noKeyConfig := llm.Config{
 		Provider: llm.ProviderOpenAI,
 		BaseURL:  "https://api.openai.com/v1",
 	}

 	_, err = factory.CreateProvider(noKeyConfig)
 	if err == nil {
 		t.Fatal("Should fail with missing API key")
 	}
 }

 func TestOpenAIFactory_SupportsProvider(t *testing.T) {
 	factory := &OpenAIFactory{}

 	if !factory.SupportsProvider(llm.ProviderOpenAI) {
 		t.Fatal("Should support OpenAI provider")
 	}

 	if factory.SupportsProvider(llm.ProviderClaude) {
 		t.Fatal("Should not support Claude provider")
 	}
 }

 func TestOpenAIProvider_ConvertRequest(t *testing.T) {
 	provider := &OpenAIProvider{
 		config: llm.Config{
 			Provider: llm.ProviderOpenAI,
 			APIKey:   "test-key",
 			BaseURL:  "https://api.openai.com/v1",
 		},
 	}

 	// Test basic request conversion
 	req := llm.ChatCompletionRequest{
 		Model: "gpt-3.5-turbo",
 		Messages: []llm.Message{
 			{Role: llm.RoleUser, Content: "Hello"},
 		},
 		MaxTokens:   &[]int{100}[0],
 		Temperature: &[]float64{0.7}[0],
 	}

 	openAIReq := provider.convertToOpenAIRequest(req)

 	if openAIReq.Model != "gpt-3.5-turbo" {
 		t.Errorf("Expected model 'gpt-3.5-turbo', got '%s'", openAIReq.Model)
 	}

 	if len(openAIReq.Messages) != 1 {
 		t.Errorf("Expected 1 message, got %d", len(openAIReq.Messages))
 	}

 	if openAIReq.Messages[0].Role != "user" {
 		t.Errorf("Expected role 'user', got '%s'", openAIReq.Messages[0].Role)
 	}

 	if openAIReq.Messages[0].Content != "Hello" {
 		t.Errorf("Expected content 'Hello', got '%s'", openAIReq.Messages[0].Content)
 	}

 	if *openAIReq.MaxTokens != 100 {
 		t.Errorf("Expected max_tokens 100, got %d", *openAIReq.MaxTokens)
 	}

 	if *openAIReq.Temperature != 0.7 {
 		t.Errorf("Expected temperature 0.7, got %f", *openAIReq.Temperature)
 	}
 }

 func TestOpenAIProvider_ConvertResponse(t *testing.T) {
 	provider := &OpenAIProvider{
 		config: llm.Config{
 			Provider: llm.ProviderOpenAI,
 			APIKey:   "test-key",
 			BaseURL:  "https://api.openai.com/v1",
 		},
 	}

 	// Test basic response conversion
 	openAIResp := OpenAIResponse{
 		ID:      "test-id",
 		Object:  "chat.completion",
 		Created: 1234567890,
 		Model:   "gpt-3.5-turbo",
 		Choices: []OpenAIChoice{
 			{
 				Index: 0,
 				Message: OpenAIMessage{
 					Role:    "assistant",
 					Content: "Hello! How can I help you?",
 				},
 				FinishReason: "stop",
 			},
 		},
 		Usage: OpenAIUsage{
 			PromptTokens:     10,
 			CompletionTokens: 20,
 			TotalTokens:      30,
 		},
 	}

 	resp := provider.convertFromOpenAIResponse(openAIResp)

 	if resp.ID != "test-id" {
 		t.Errorf("Expected ID 'test-id', got '%s'", resp.ID)
 	}

 	if resp.Model != "gpt-3.5-turbo" {
 		t.Errorf("Expected model 'gpt-3.5-turbo', got '%s'", resp.Model)
 	}

 	if resp.Provider != llm.ProviderOpenAI {
 		t.Errorf("Expected provider OpenAI, got %s", resp.Provider)
 	}

 	if len(resp.Choices) != 1 {
 		t.Errorf("Expected 1 choice, got %d", len(resp.Choices))
 	}

 	if resp.Choices[0].Message.Role != llm.RoleAssistant {
 		t.Errorf("Expected role assistant, got %s", resp.Choices[0].Message.Role)
 	}

 	if resp.Choices[0].Message.Content != "Hello! How can I help you?" {
 		t.Errorf("Expected content 'Hello! How can I help you?', got '%s'", resp.Choices[0].Message.Content)
 	}

 	if resp.Usage.PromptTokens != 10 {
 		t.Errorf("Expected prompt tokens 10, got %d", resp.Usage.PromptTokens)
 	}

 	if resp.Usage.CompletionTokens != 20 {
 		t.Errorf("Expected completion tokens 20, got %d", resp.Usage.CompletionTokens)
 	}

 	if resp.Usage.TotalTokens != 30 {
 		t.Errorf("Expected total tokens 30, got %d", resp.Usage.TotalTokens)
 	}
 }

 func TestOpenAIProvider_ConvertRequestWithTools(t *testing.T) {
 	provider := &OpenAIProvider{
 		config: llm.Config{
 			Provider: llm.ProviderOpenAI,
 			APIKey:   "test-key",
 			BaseURL:  "https://api.openai.com/v1",
 		},
 	}

 	// Test request with tools
 	tools := []llm.Tool{
 		{
 			Type: "function",
 			Function: llm.Function{
 				Name:        "get_weather",
 				Description: "Get weather information",
 				Parameters: map[string]interface{}{
 					"type": "object",
 					"properties": map[string]interface{}{
 						"location": map[string]interface{}{
 							"type": "string",
 						},
 					},
 				},
 			},
 		},
 	}

 	req := llm.ChatCompletionRequest{
 		Model: "gpt-3.5-turbo",
 		Messages: []llm.Message{
 			{Role: llm.RoleUser, Content: "What's the weather like?"},
 		},
 		Tools: tools,
 	}

 	openAIReq := provider.convertToOpenAIRequest(req)

 	if len(openAIReq.Tools) != 1 {
 		t.Errorf("Expected 1 tool, got %d", len(openAIReq.Tools))
 	}

 	if openAIReq.Tools[0].Type != "function" {
 		t.Errorf("Expected tool type 'function', got '%s'", openAIReq.Tools[0].Type)
 	}

 	if openAIReq.Tools[0].Function.Name != "get_weather" {
 		t.Errorf("Expected function name 'get_weather', got '%s'", openAIReq.Tools[0].Function.Name)
 	}
 }

 func TestOpenAIProvider_ConvertResponseWithToolCalls(t *testing.T) {
 	provider := &OpenAIProvider{
 		config: llm.Config{
 			Provider: llm.ProviderOpenAI,
 			APIKey:   "test-key",
 			BaseURL:  "https://api.openai.com/v1",
 		},
 	}

 	// Test response with tool calls
 	openAIResp := OpenAIResponse{
 		ID:     "test-id",
 		Object: "chat.completion",
 		Model:  "gpt-3.5-turbo",
 		Choices: []OpenAIChoice{
 			{
 				Index: 0,
 				Message: OpenAIMessage{
 					Role: "assistant",
 					ToolCalls: []OpenAIToolCall{
 						{
 							ID:   "call_123",
 							Type: "function",
 							Function: OpenAIFunction{
 								Name: "get_weather",
 								Parameters: map[string]interface{}{
 									"location": "Tokyo",
 								},
 							},
 						},
 					},
 				},
 				FinishReason: "tool_calls",
 			},
 		},
 		Usage: OpenAIUsage{
 			PromptTokens:     10,
 			CompletionTokens: 20,
 			TotalTokens:      30,
 		},
 	}

 	resp := provider.convertFromOpenAIResponse(openAIResp)

 	if len(resp.Choices[0].Message.ToolCalls) != 1 {
 		t.Errorf("Expected 1 tool call, got %d", len(resp.Choices[0].Message.ToolCalls))
 	}

 	if resp.Choices[0].Message.ToolCalls[0].ID != "call_123" {
 		t.Errorf("Expected tool call ID 'call_123', got '%s'", resp.Choices[0].Message.ToolCalls[0].ID)
 	}

 	if resp.Choices[0].Message.ToolCalls[0].Function.Name != "get_weather" {
 		t.Errorf("Expected function name 'get_weather', got '%s'", resp.Choices[0].Message.ToolCalls[0].Function.Name)
 	}

 	if resp.Choices[0].FinishReason != "tool_calls" {
 		t.Errorf("Expected finish reason 'tool_calls', got '%s'", resp.Choices[0].FinishReason)
 	}
 }

 func TestOpenAIProvider_ConvertEmbeddingRequest(t *testing.T) {
 	req := llm.EmbeddingRequest{
 		Input: "Hello, world!",
 		Model: "text-embedding-ada-002",
 		User:  "test-user",
 	}

 	// The conversion is done inline in CreateEmbeddings, so we'll test the structure
 	if req.Input != "Hello, world!" {
 		t.Errorf("Expected input 'Hello, world!', got '%v'", req.Input)
 	}

 	if req.Model != "text-embedding-ada-002" {
 		t.Errorf("Expected model 'text-embedding-ada-002', got '%s'", req.Model)
 	}

 	if req.User != "test-user" {
 		t.Errorf("Expected user 'test-user', got '%s'", req.User)
 	}
 }

 func TestOpenAIProvider_ConvertEmbeddingResponse(t *testing.T) {
 	provider := &OpenAIProvider{
 		config: llm.Config{
 			Provider: llm.ProviderOpenAI,
 			APIKey:   "test-key",
 			BaseURL:  "https://api.openai.com/v1",
 		},
 	}

 	// Test embedding response conversion
 	openAIResp := OpenAIEmbeddingResponse{
 		Object: "list",
 		Model:  "text-embedding-ada-002",
 		Data: []OpenAIEmbeddingData{
 			{
 				Object:    "embedding",
 				Embedding: []float64{0.1, 0.2, 0.3},
 				Index:     0,
 			},
 		},
 		Usage: OpenAIUsage{
 			PromptTokens:     5,
 			CompletionTokens: 0,
 			TotalTokens:      5,
 		},
 	}

 	resp := provider.convertFromOpenAIEmbeddingResponse(openAIResp)

 	if resp.Object != "list" {
 		t.Errorf("Expected object 'list', got '%s'", resp.Object)
 	}

 	if resp.Model != "text-embedding-ada-002" {
 		t.Errorf("Expected model 'text-embedding-ada-002', got '%s'", resp.Model)
 	}

 	if resp.Provider != llm.ProviderOpenAI {
 		t.Errorf("Expected provider OpenAI, got %s", resp.Provider)
 	}

 	if len(resp.Data) != 1 {
 		t.Errorf("Expected 1 embedding, got %d", len(resp.Data))
 	}

 	if len(resp.Data[0].Embedding) != 3 {
 		t.Errorf("Expected embedding dimension 3, got %d", len(resp.Data[0].Embedding))
 	}

 	if resp.Data[0].Embedding[0] != 0.1 {
 		t.Errorf("Expected first embedding value 0.1, got %f", resp.Data[0].Embedding[0])
 	}
 }

 func TestOpenAIProvider_Close(t *testing.T) {
 	provider := &OpenAIProvider{
 		config: llm.Config{
 			Provider: llm.ProviderOpenAI,
 			APIKey:   "test-key",
 			BaseURL:  "https://api.openai.com/v1",
 		},
 	}

 	// Test that Close doesn't return an error
 	err := provider.Close()
 	if err != nil {
 		t.Errorf("Close should not return an error: %v", err)
 	}
 }

 func TestOpenAIProvider_Integration(t *testing.T) {
 	// This test would require a real API key and would make actual API calls
 	// It's commented out to avoid making real API calls during testing
 	/*
 		config := Config{
 			Provider: ProviderOpenAI,
 			APIKey:   "your-real-api-key",
 			BaseURL:  "https://api.openai.com/v1",
 			Timeout:  30 * time.Second,
 		}

 		provider, err := CreateProvider(config)
 		if err != nil {
 			t.Fatalf("Failed to create provider: %v", err)
 		}
 		defer provider.Close()

 		req := ChatCompletionRequest{
 			Model: "gpt-3.5-turbo",
 			Messages: []Message{
 				{Role: RoleUser, Content: "Say hello!"},
 			},
 			MaxTokens: &[]int{50}[0],
 		}

 		resp, err := provider.ChatCompletion(context.Background(), req)
 		if err != nil {
 			t.Fatalf("Chat completion failed: %v", err)
 		}

 		if len(resp.Choices) == 0 {
 			t.Fatal("Expected at least one choice")
 		}

 		if resp.Choices[0].Message.Content == "" {
 			t.Fatal("Expected non-empty response content")
 		}
 	*/
 }
	package openai

	import (
	"testing"
	"time"

	"github.com/iomodo/staff/llm"
	)

	func TestOpenAIProvider_Interface(t *testing.T) {
	// Test that OpenAIProvider implements LLMProvider interface
	var _ llm.LLMProvider = (*OpenAIProvider)(nil)
	}

	func TestOpenAIFactory_CreateProvider(t *testing.T) {
	factory := &OpenAIFactory{}

	// Test valid config
	config := llm.Config{
	Provider: llm.ProviderOpenAI,
	APIKey: "test-key",
	BaseURL: "https://api.openai.com/v1",
	Timeout: 30 * time.Second,
	}

	provider, err := factory.CreateProvider(config)
	if err != nil {
	t.Fatalf("Failed to create provider: %v", err)
	}

	if provider == nil {
	t.Fatal("Provider should not be nil")
	}

	// Test invalid provider
	invalidConfig := llm.Config{
	Provider: llm.ProviderClaude,
	APIKey: "test-key",
	}

	_, err = factory.CreateProvider(invalidConfig)
	if err == nil {
	t.Fatal("Should fail with invalid provider")
	}

	// Test missing API key
	noKeyConfig := llm.Config{
	Provider: llm.ProviderOpenAI,
	BaseURL: "https://api.openai.com/v1",
	}

	_, err = factory.CreateProvider(noKeyConfig)
	if err == nil {
	t.Fatal("Should fail with missing API key")
	}
	}

	func TestOpenAIFactory_SupportsProvider(t *testing.T) {
	factory := &OpenAIFactory{}

	if !factory.SupportsProvider(llm.ProviderOpenAI) {
	t.Fatal("Should support OpenAI provider")
	}

	if factory.SupportsProvider(llm.ProviderClaude) {
	t.Fatal("Should not support Claude provider")
	}
	}

	func TestOpenAIProvider_ConvertRequest(t *testing.T) {
	provider := &OpenAIProvider{
	config: llm.Config{
	Provider: llm.ProviderOpenAI,
	APIKey: "test-key",
	BaseURL: "https://api.openai.com/v1",
	},
	}

	// Test basic request conversion
	req := llm.ChatCompletionRequest{
	Model: "gpt-3.5-turbo",
	Messages: []llm.Message{
	{Role: llm.RoleUser, Content: "Hello"},
	},
	MaxTokens: &[]int{100}[0],
	Temperature: &[]float64{0.7}[0],
	}

	openAIReq := provider.convertToOpenAIRequest(req)

	if openAIReq.Model != "gpt-3.5-turbo" {
	t.Errorf("Expected model 'gpt-3.5-turbo', got '%s'", openAIReq.Model)
	}

	if len(openAIReq.Messages) != 1 {
	t.Errorf("Expected 1 message, got %d", len(openAIReq.Messages))
	}

	if openAIReq.Messages[0].Role != "user" {
	t.Errorf("Expected role 'user', got '%s'", openAIReq.Messages[0].Role)
	}

	if openAIReq.Messages[0].Content != "Hello" {
	t.Errorf("Expected content 'Hello', got '%s'", openAIReq.Messages[0].Content)
	}

	if *openAIReq.MaxTokens != 100 {
	t.Errorf("Expected max_tokens 100, got %d", *openAIReq.MaxTokens)
	}

	if *openAIReq.Temperature != 0.7 {
	t.Errorf("Expected temperature 0.7, got %f", *openAIReq.Temperature)
	}
	}

	func TestOpenAIProvider_ConvertResponse(t *testing.T) {
	provider := &OpenAIProvider{
	config: llm.Config{
	Provider: llm.ProviderOpenAI,
	APIKey: "test-key",
	BaseURL: "https://api.openai.com/v1",
	},
	}

	// Test basic response conversion
	openAIResp := OpenAIResponse{
	ID: "test-id",
	Object: "chat.completion",
	Created: 1234567890,
	Model: "gpt-3.5-turbo",
	Choices: []OpenAIChoice{
	{
	Index: 0,
	Message: OpenAIMessage{
	Role: "assistant",
	Content: "Hello! How can I help you?",
	},
	FinishReason: "stop",
	},
	},
	Usage: OpenAIUsage{
	PromptTokens: 10,
	CompletionTokens: 20,
	TotalTokens: 30,
	},
	}

	resp := provider.convertFromOpenAIResponse(openAIResp)

	if resp.ID != "test-id" {
	t.Errorf("Expected ID 'test-id', got '%s'", resp.ID)
	}

	if resp.Model != "gpt-3.5-turbo" {
	t.Errorf("Expected model 'gpt-3.5-turbo', got '%s'", resp.Model)
	}

	if resp.Provider != llm.ProviderOpenAI {
	t.Errorf("Expected provider OpenAI, got %s", resp.Provider)
	}

	if len(resp.Choices) != 1 {
	t.Errorf("Expected 1 choice, got %d", len(resp.Choices))
	}

	if resp.Choices[0].Message.Role != llm.RoleAssistant {
	t.Errorf("Expected role assistant, got %s", resp.Choices[0].Message.Role)
	}

	if resp.Choices[0].Message.Content != "Hello! How can I help you?" {
	t.Errorf("Expected content 'Hello! How can I help you?', got '%s'", resp.Choices[0].Message.Content)
	}

	if resp.Usage.PromptTokens != 10 {
	t.Errorf("Expected prompt tokens 10, got %d", resp.Usage.PromptTokens)
	}

	if resp.Usage.CompletionTokens != 20 {
	t.Errorf("Expected completion tokens 20, got %d", resp.Usage.CompletionTokens)
	}

	if resp.Usage.TotalTokens != 30 {
	t.Errorf("Expected total tokens 30, got %d", resp.Usage.TotalTokens)
	}
	}

	func TestOpenAIProvider_ConvertRequestWithTools(t *testing.T) {
	provider := &OpenAIProvider{
	config: llm.Config{
	Provider: llm.ProviderOpenAI,
	APIKey: "test-key",
	BaseURL: "https://api.openai.com/v1",
	},
	}

	// Test request with tools
	tools := []llm.Tool{
	{
	Type: "function",
	Function: llm.Function{
	Name: "get_weather",
	Description: "Get weather information",
	Parameters: map[string]interface{}{
	"type": "object",
	"properties": map[string]interface{}{
	"location": map[string]interface{}{
	"type": "string",
	},
	},
	},
	},
	},
	}

	req := llm.ChatCompletionRequest{
	Model: "gpt-3.5-turbo",
	Messages: []llm.Message{
	{Role: llm.RoleUser, Content: "What's the weather like?"},
	},
	Tools: tools,
	}

	openAIReq := provider.convertToOpenAIRequest(req)

	if len(openAIReq.Tools) != 1 {
	t.Errorf("Expected 1 tool, got %d", len(openAIReq.Tools))
	}

	if openAIReq.Tools[0].Type != "function" {
	t.Errorf("Expected tool type 'function', got '%s'", openAIReq.Tools[0].Type)
	}

	if openAIReq.Tools[0].Function.Name != "get_weather" {
	t.Errorf("Expected function name 'get_weather', got '%s'", openAIReq.Tools[0].Function.Name)
	}
	}

	func TestOpenAIProvider_ConvertResponseWithToolCalls(t *testing.T) {
	provider := &OpenAIProvider{
	config: llm.Config{
	Provider: llm.ProviderOpenAI,
	APIKey: "test-key",
	BaseURL: "https://api.openai.com/v1",
	},
	}

	// Test response with tool calls
	openAIResp := OpenAIResponse{
	ID: "test-id",
	Object: "chat.completion",
	Model: "gpt-3.5-turbo",
	Choices: []OpenAIChoice{
	{
	Index: 0,
	Message: OpenAIMessage{
	Role: "assistant",
	ToolCalls: []OpenAIToolCall{
	{
	ID: "call_123",
	Type: "function",
	Function: OpenAIFunction{
	Name: "get_weather",
	Parameters: map[string]interface{}{
	"location": "Tokyo",
	},
	},
	},
	},
	},
	FinishReason: "tool_calls",
	},
	},
	Usage: OpenAIUsage{
	PromptTokens: 10,
	CompletionTokens: 20,
	TotalTokens: 30,
	},
	}

	resp := provider.convertFromOpenAIResponse(openAIResp)

	if len(resp.Choices[0].Message.ToolCalls) != 1 {
	t.Errorf("Expected 1 tool call, got %d", len(resp.Choices[0].Message.ToolCalls))
	}

	if resp.Choices[0].Message.ToolCalls[0].ID != "call_123" {
	t.Errorf("Expected tool call ID 'call_123', got '%s'", resp.Choices[0].Message.ToolCalls[0].ID)
	}

	if resp.Choices[0].Message.ToolCalls[0].Function.Name != "get_weather" {
	t.Errorf("Expected function name 'get_weather', got '%s'", resp.Choices[0].Message.ToolCalls[0].Function.Name)
	}

	if resp.Choices[0].FinishReason != "tool_calls" {
	t.Errorf("Expected finish reason 'tool_calls', got '%s'", resp.Choices[0].FinishReason)
	}
	}

	func TestOpenAIProvider_ConvertEmbeddingRequest(t *testing.T) {
	req := llm.EmbeddingRequest{
	Input: "Hello, world!",
	Model: "text-embedding-ada-002",
	User: "test-user",
	}

	// The conversion is done inline in CreateEmbeddings, so we'll test the structure
	if req.Input != "Hello, world!" {
	t.Errorf("Expected input 'Hello, world!', got '%v'", req.Input)
	}

	if req.Model != "text-embedding-ada-002" {
	t.Errorf("Expected model 'text-embedding-ada-002', got '%s'", req.Model)
	}

	if req.User != "test-user" {
	t.Errorf("Expected user 'test-user', got '%s'", req.User)
	}
	}

	func TestOpenAIProvider_ConvertEmbeddingResponse(t *testing.T) {
	provider := &OpenAIProvider{
	config: llm.Config{
	Provider: llm.ProviderOpenAI,
	APIKey: "test-key",
	BaseURL: "https://api.openai.com/v1",
	},
	}

	// Test embedding response conversion
	openAIResp := OpenAIEmbeddingResponse{
	Object: "list",
	Model: "text-embedding-ada-002",
	Data: []OpenAIEmbeddingData{
	{
	Object: "embedding",
	Embedding: []float64{0.1, 0.2, 0.3},
	Index: 0,
	},
	},
	Usage: OpenAIUsage{
	PromptTokens: 5,
	CompletionTokens: 0,
	TotalTokens: 5,
	},
	}

	resp := provider.convertFromOpenAIEmbeddingResponse(openAIResp)

	if resp.Object != "list" {
	t.Errorf("Expected object 'list', got '%s'", resp.Object)
	}

	if resp.Model != "text-embedding-ada-002" {
	t.Errorf("Expected model 'text-embedding-ada-002', got '%s'", resp.Model)
	}

	if resp.Provider != llm.ProviderOpenAI {
	t.Errorf("Expected provider OpenAI, got %s", resp.Provider)
	}

	if len(resp.Data) != 1 {
	t.Errorf("Expected 1 embedding, got %d", len(resp.Data))
	}

	if len(resp.Data[0].Embedding) != 3 {
	t.Errorf("Expected embedding dimension 3, got %d", len(resp.Data[0].Embedding))
	}

	if resp.Data[0].Embedding[0] != 0.1 {
	t.Errorf("Expected first embedding value 0.1, got %f", resp.Data[0].Embedding[0])
	}
	}

	func TestOpenAIProvider_Close(t *testing.T) {
	provider := &OpenAIProvider{
	config: llm.Config{
	Provider: llm.ProviderOpenAI,
	APIKey: "test-key",
	BaseURL: "https://api.openai.com/v1",
	},
	}

	// Test that Close doesn't return an error
	err := provider.Close()
	if err != nil {
	t.Errorf("Close should not return an error: %v", err)
	}
	}

	func TestOpenAIProvider_Integration(t *testing.T) {
	// This test would require a real API key and would make actual API calls
	// It's commented out to avoid making real API calls during testing
	/*
	config := Config{
	Provider: ProviderOpenAI,
	APIKey: "your-real-api-key",
	BaseURL: "https://api.openai.com/v1",
	Timeout: 30 * time.Second,
	}

	provider, err := CreateProvider(config)
	if err != nil {
	t.Fatalf("Failed to create provider: %v", err)
	}
	defer provider.Close()

	req := ChatCompletionRequest{
	Model: "gpt-3.5-turbo",
	Messages: []Message{
	{Role: RoleUser, Content: "Say hello!"},
	},
	MaxTokens: &[]int{50}[0],
	}

	resp, err := provider.ChatCompletion(context.Background(), req)
	if err != nil {
	t.Fatalf("Chat completion failed: %v", err)
	}

	if len(resp.Choices) == 0 {
	t.Fatal("Expected at least one choice")
	}

	if resp.Choices[0].Message.Content == "" {
	t.Fatal("Expected non-empty response content")
	}
	*/
	}