Cut modules over to Scriptorium prompts
This commit is contained in:
@@ -1,364 +0,0 @@
|
||||
package llm
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
||||
)
|
||||
|
||||
const openAICompatibleProviderName = "openai-compatible"
|
||||
|
||||
// OpenAICompatibleClientConfig configures the direct HTTP structured-output adapter.
|
||||
type OpenAICompatibleClientConfig struct {
|
||||
BaseURL string
|
||||
Model string
|
||||
APIKey string
|
||||
MaxRetries int
|
||||
HTTPClient *http.Client
|
||||
RequestTimeout time.Duration
|
||||
}
|
||||
|
||||
// OpenAICompatibleClient sends OpenAI-compatible chat-completion requests with
|
||||
// response_format.type=json_schema.
|
||||
type OpenAICompatibleClient struct {
|
||||
baseURL string
|
||||
model string
|
||||
apiKey string
|
||||
maxRetries int
|
||||
httpClient *http.Client
|
||||
requestTimeout time.Duration
|
||||
}
|
||||
|
||||
var _ contracts.StructuredLLMClient = (*OpenAICompatibleClient)(nil)
|
||||
|
||||
func NewOpenAICompatibleClient(cfg OpenAICompatibleClientConfig) (*OpenAICompatibleClient, error) {
|
||||
normalized, err := normalizeOpenAICompatibleConfig(cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
client := normalized.HTTPClient
|
||||
if client == nil {
|
||||
client = http.DefaultClient
|
||||
}
|
||||
|
||||
return &OpenAICompatibleClient{
|
||||
baseURL: normalized.BaseURL,
|
||||
model: normalized.Model,
|
||||
apiKey: normalized.APIKey,
|
||||
maxRetries: normalized.MaxRetries,
|
||||
httpClient: client,
|
||||
requestTimeout: normalized.RequestTimeout,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (c *OpenAICompatibleClient) CompleteStructured(
|
||||
ctx context.Context,
|
||||
req contracts.StructuredCompletionRequest,
|
||||
out any,
|
||||
) (contracts.StructuredCompletionResponse, error) {
|
||||
if c == nil {
|
||||
return contracts.StructuredCompletionResponse{}, fmt.Errorf("openai-compatible client must not be nil")
|
||||
}
|
||||
if err := validateOutputTarget(out); err != nil {
|
||||
return contracts.StructuredCompletionResponse{}, err
|
||||
}
|
||||
|
||||
model := strings.TrimSpace(req.Model)
|
||||
if model == "" {
|
||||
model = c.model
|
||||
}
|
||||
if model == "" {
|
||||
return contracts.StructuredCompletionResponse{}, fmt.Errorf("structured completion model must not be empty")
|
||||
}
|
||||
|
||||
schemaName := strings.TrimSpace(req.ResponseSchemaName)
|
||||
if schemaName == "" {
|
||||
return contracts.StructuredCompletionResponse{}, fmt.Errorf("structured completion response schema name must not be empty")
|
||||
}
|
||||
if len(bytes.TrimSpace(req.ResponseSchema)) == 0 || !json.Valid(req.ResponseSchema) {
|
||||
return contracts.StructuredCompletionResponse{}, fmt.Errorf("structured completion response schema JSON must be valid")
|
||||
}
|
||||
|
||||
messages, err := toOpenAICompatibleMessages(req.Messages)
|
||||
if err != nil {
|
||||
return contracts.StructuredCompletionResponse{}, err
|
||||
}
|
||||
|
||||
endpoint := buildChatCompletionsURL(c.baseURL)
|
||||
var lastErr error
|
||||
for attempt := 0; attempt <= c.maxRetries; attempt++ {
|
||||
content, metadata, callErr := c.completeStructuredOnce(ctx, endpoint, model, messages, schemaName, req.ResponseSchema)
|
||||
if callErr == nil {
|
||||
if decodeErr := json.Unmarshal(content, out); decodeErr != nil {
|
||||
callErr = retryableError{err: fmt.Errorf("decode structured output: %w", decodeErr)}
|
||||
} else {
|
||||
return contracts.StructuredCompletionResponse{
|
||||
Content: content,
|
||||
Provider: openAICompatibleProviderName,
|
||||
Model: firstNonEmpty(metadata.Model, model),
|
||||
PromptTokens: metadata.PromptTokens,
|
||||
CompletionTokens: metadata.CompletionTokens,
|
||||
TotalTokens: metadata.TotalTokens,
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
|
||||
if ctx.Err() != nil {
|
||||
return contracts.StructuredCompletionResponse{}, ctx.Err()
|
||||
}
|
||||
lastErr = c.redactError(callErr)
|
||||
if !canRetry(ctx, attempt, c.maxRetries, callErr) {
|
||||
return contracts.StructuredCompletionResponse{}, lastErr
|
||||
}
|
||||
}
|
||||
|
||||
if lastErr == nil {
|
||||
lastErr = fmt.Errorf("structured completion failed")
|
||||
}
|
||||
return contracts.StructuredCompletionResponse{}, lastErr
|
||||
}
|
||||
|
||||
type openAICompatibleMessage struct {
|
||||
Role string `json:"role"`
|
||||
Content string `json:"content"`
|
||||
}
|
||||
|
||||
type openAICompatibleRequest struct {
|
||||
Model string `json:"model"`
|
||||
Messages []openAICompatibleMessage `json:"messages"`
|
||||
ResponseFormat openAICompatibleStructuredOutputShape `json:"response_format"`
|
||||
}
|
||||
|
||||
type openAICompatibleStructuredOutputShape struct {
|
||||
Type string `json:"type"`
|
||||
JSONSchema openAICompatibleSchemaEnvelope `json:"json_schema"`
|
||||
}
|
||||
|
||||
type openAICompatibleSchemaEnvelope struct {
|
||||
Name string `json:"name"`
|
||||
Strict bool `json:"strict"`
|
||||
Schema json.RawMessage `json:"schema"`
|
||||
}
|
||||
|
||||
type openAICompatibleChatCompletionsResponse struct {
|
||||
Model string `json:"model"`
|
||||
Choices []struct {
|
||||
Message struct {
|
||||
Content json.RawMessage `json:"content"`
|
||||
} `json:"message"`
|
||||
} `json:"choices"`
|
||||
Usage *openAICompatibleUsage `json:"usage,omitempty"`
|
||||
}
|
||||
|
||||
type openAICompatibleUsage struct {
|
||||
PromptTokens int `json:"prompt_tokens"`
|
||||
CompletionTokens int `json:"completion_tokens"`
|
||||
TotalTokens int `json:"total_tokens"`
|
||||
}
|
||||
|
||||
type openAICompatibleResponseMetadata struct {
|
||||
Model string
|
||||
PromptTokens int
|
||||
CompletionTokens int
|
||||
TotalTokens int
|
||||
}
|
||||
|
||||
func normalizeOpenAICompatibleConfig(cfg OpenAICompatibleClientConfig) (OpenAICompatibleClientConfig, error) {
|
||||
cfg.BaseURL = strings.TrimSpace(cfg.BaseURL)
|
||||
cfg.Model = strings.TrimSpace(cfg.Model)
|
||||
cfg.APIKey = strings.TrimSpace(cfg.APIKey)
|
||||
if cfg.MaxRetries < 0 {
|
||||
return OpenAICompatibleClientConfig{}, fmt.Errorf("max retries must be zero or greater")
|
||||
}
|
||||
if cfg.BaseURL == "" {
|
||||
return OpenAICompatibleClientConfig{}, fmt.Errorf("base URL must not be empty")
|
||||
}
|
||||
if _, err := url.ParseRequestURI(cfg.BaseURL); err != nil {
|
||||
return OpenAICompatibleClientConfig{}, fmt.Errorf("base URL must be valid: %w", err)
|
||||
}
|
||||
if cfg.Model == "" {
|
||||
return OpenAICompatibleClientConfig{}, fmt.Errorf("model must not be empty")
|
||||
}
|
||||
cfg.BaseURL = strings.TrimRight(cfg.BaseURL, "/")
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
func (c *OpenAICompatibleClient) completeStructuredOnce(
|
||||
ctx context.Context,
|
||||
endpoint string,
|
||||
model string,
|
||||
messages []openAICompatibleMessage,
|
||||
responseSchemaName string,
|
||||
responseSchemaJSON json.RawMessage,
|
||||
) (json.RawMessage, openAICompatibleResponseMetadata, error) {
|
||||
requestCtx := ctx
|
||||
var cancel context.CancelFunc
|
||||
if c.requestTimeout > 0 {
|
||||
requestCtx, cancel = context.WithTimeout(ctx, c.requestTimeout)
|
||||
defer cancel()
|
||||
}
|
||||
|
||||
requestBody := openAICompatibleRequest{
|
||||
Model: model,
|
||||
Messages: messages,
|
||||
ResponseFormat: openAICompatibleStructuredOutputShape{
|
||||
Type: "json_schema",
|
||||
JSONSchema: openAICompatibleSchemaEnvelope{
|
||||
Name: responseSchemaName,
|
||||
Strict: true,
|
||||
Schema: responseSchemaJSON,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
payload, err := json.Marshal(requestBody)
|
||||
if err != nil {
|
||||
return nil, openAICompatibleResponseMetadata{}, fmt.Errorf("marshal provider request: %w", err)
|
||||
}
|
||||
|
||||
httpReq, err := http.NewRequestWithContext(requestCtx, http.MethodPost, endpoint, bytes.NewReader(payload))
|
||||
if err != nil {
|
||||
return nil, openAICompatibleResponseMetadata{}, fmt.Errorf("build provider request: %w", err)
|
||||
}
|
||||
httpReq.Header.Set("Content-Type", "application/json")
|
||||
if c.apiKey != "" {
|
||||
httpReq.Header.Set("Authorization", "Bearer "+c.apiKey)
|
||||
}
|
||||
|
||||
httpResp, err := c.httpClient.Do(httpReq)
|
||||
if err != nil {
|
||||
return nil, openAICompatibleResponseMetadata{}, retryableError{err: fmt.Errorf("provider request failed: %w", err)}
|
||||
}
|
||||
defer func() {
|
||||
_ = httpResp.Body.Close()
|
||||
}()
|
||||
|
||||
rawResp, err := io.ReadAll(httpResp.Body)
|
||||
if err != nil {
|
||||
return nil, openAICompatibleResponseMetadata{}, retryableError{err: fmt.Errorf("read provider response: %w", err)}
|
||||
}
|
||||
|
||||
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
|
||||
statusErr := parseProviderErrorBody(httpResp.StatusCode, rawResp)
|
||||
if httpResp.StatusCode == http.StatusTooManyRequests || httpResp.StatusCode >= 500 {
|
||||
return nil, openAICompatibleResponseMetadata{}, retryableError{err: statusErr}
|
||||
}
|
||||
return nil, openAICompatibleResponseMetadata{}, statusErr
|
||||
}
|
||||
|
||||
return decodeChatCompletionsResponse(rawResp)
|
||||
}
|
||||
|
||||
func toOpenAICompatibleMessages(messages []contracts.LLMMessage) ([]openAICompatibleMessage, error) {
|
||||
if len(messages) == 0 {
|
||||
return nil, fmt.Errorf("structured completion messages must not be empty")
|
||||
}
|
||||
|
||||
result := make([]openAICompatibleMessage, len(messages))
|
||||
for i, message := range messages {
|
||||
role := strings.TrimSpace(message.Role)
|
||||
content := strings.TrimSpace(message.Content)
|
||||
if role == "" {
|
||||
return nil, fmt.Errorf("message[%d] role must not be empty", i)
|
||||
}
|
||||
if content == "" {
|
||||
return nil, fmt.Errorf("message[%d] content must not be empty", i)
|
||||
}
|
||||
result[i] = openAICompatibleMessage{
|
||||
Role: role,
|
||||
Content: content,
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func buildChatCompletionsURL(baseURL string) string {
|
||||
return strings.TrimRight(baseURL, "/") + "/chat/completions"
|
||||
}
|
||||
|
||||
func decodeChatCompletionsResponse(raw []byte) (json.RawMessage, openAICompatibleResponseMetadata, error) {
|
||||
var parsed openAICompatibleChatCompletionsResponse
|
||||
if err := json.Unmarshal(raw, &parsed); err != nil {
|
||||
return nil, openAICompatibleResponseMetadata{}, retryableError{err: fmt.Errorf("decode provider response envelope: %w", err)}
|
||||
}
|
||||
if len(parsed.Choices) == 0 {
|
||||
return nil, openAICompatibleResponseMetadata{}, retryableError{err: fmt.Errorf("provider response missing choices")}
|
||||
}
|
||||
|
||||
content, err := extractAssistantContentJSON(parsed.Choices[0].Message.Content)
|
||||
if err != nil {
|
||||
return nil, openAICompatibleResponseMetadata{}, retryableError{err: err}
|
||||
}
|
||||
|
||||
metadata := openAICompatibleResponseMetadata{
|
||||
Model: parsed.Model,
|
||||
}
|
||||
if parsed.Usage != nil {
|
||||
metadata.PromptTokens = parsed.Usage.PromptTokens
|
||||
metadata.CompletionTokens = parsed.Usage.CompletionTokens
|
||||
metadata.TotalTokens = parsed.Usage.TotalTokens
|
||||
}
|
||||
return content, metadata, nil
|
||||
}
|
||||
|
||||
func extractAssistantContentJSON(raw json.RawMessage) (json.RawMessage, error) {
|
||||
trimmedRaw := bytes.TrimSpace(raw)
|
||||
if len(trimmedRaw) == 0 || bytes.Equal(trimmedRaw, []byte("null")) {
|
||||
return nil, fmt.Errorf("provider response missing assistant message content")
|
||||
}
|
||||
|
||||
var textContent string
|
||||
if err := json.Unmarshal(trimmedRaw, &textContent); err == nil {
|
||||
textContent = strings.TrimSpace(textContent)
|
||||
if textContent == "" {
|
||||
return nil, fmt.Errorf("provider response assistant message content is empty")
|
||||
}
|
||||
if !json.Valid([]byte(textContent)) {
|
||||
return nil, fmt.Errorf("provider response assistant message content is not valid JSON")
|
||||
}
|
||||
return json.RawMessage(textContent), nil
|
||||
}
|
||||
|
||||
if json.Valid(trimmedRaw) {
|
||||
return append(json.RawMessage(nil), trimmedRaw...), nil
|
||||
}
|
||||
return nil, fmt.Errorf("provider response assistant message content is not valid JSON")
|
||||
}
|
||||
|
||||
func parseProviderErrorBody(status int, body []byte) error {
|
||||
trimmed := strings.TrimSpace(string(body))
|
||||
if trimmed == "" {
|
||||
return fmt.Errorf("provider returned status %d", status)
|
||||
}
|
||||
|
||||
var payload map[string]any
|
||||
if err := json.Unmarshal(body, &payload); err == nil {
|
||||
if nested, ok := payload["error"].(map[string]any); ok {
|
||||
if msg, ok := nested["message"].(string); ok && strings.TrimSpace(msg) != "" {
|
||||
return fmt.Errorf("provider returned status %d: %s", status, strings.TrimSpace(msg))
|
||||
}
|
||||
}
|
||||
if msg, ok := payload["message"].(string); ok && strings.TrimSpace(msg) != "" {
|
||||
return fmt.Errorf("provider returned status %d: %s", status, strings.TrimSpace(msg))
|
||||
}
|
||||
}
|
||||
|
||||
return fmt.Errorf("provider returned status %d: %s", status, trimmed)
|
||||
}
|
||||
|
||||
func (c *OpenAICompatibleClient) redactError(err error) error {
|
||||
secrets := []string{c.apiKey}
|
||||
if c.apiKey != "" {
|
||||
secrets = append(secrets, "Bearer "+c.apiKey)
|
||||
}
|
||||
return ErrorWithSecretsRedacted(err, secrets)
|
||||
}
|
||||
@@ -1,494 +0,0 @@
|
||||
package llm
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
|
||||
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
||||
)
|
||||
|
||||
type testArtifact struct {
|
||||
Value string `json:"value"`
|
||||
}
|
||||
|
||||
func TestNewOpenAICompatibleClientValidation(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
cfg OpenAICompatibleClientConfig
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "empty base URL",
|
||||
cfg: OpenAICompatibleClientConfig{
|
||||
BaseURL: " ",
|
||||
Model: "model",
|
||||
},
|
||||
want: "base URL",
|
||||
},
|
||||
{
|
||||
name: "invalid base URL",
|
||||
cfg: OpenAICompatibleClientConfig{
|
||||
BaseURL: "://bad",
|
||||
Model: "model",
|
||||
},
|
||||
want: "base URL",
|
||||
},
|
||||
{
|
||||
name: "empty model",
|
||||
cfg: OpenAICompatibleClientConfig{
|
||||
BaseURL: "https://example.test/v1",
|
||||
Model: " ",
|
||||
},
|
||||
want: "model",
|
||||
},
|
||||
{
|
||||
name: "negative retries",
|
||||
cfg: OpenAICompatibleClientConfig{
|
||||
BaseURL: "https://example.test/v1",
|
||||
Model: "model",
|
||||
MaxRetries: -1,
|
||||
},
|
||||
want: "max retries",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
_, err := NewOpenAICompatibleClient(tc.cfg)
|
||||
if err == nil || !strings.Contains(err.Error(), tc.want) {
|
||||
t.Fatalf("expected error containing %q, got %v", tc.want, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientSuccessfulStructuredCompletion(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_, _ = io.WriteString(w, `{
|
||||
"model":"provider-model",
|
||||
"choices":[{"message":{"content":"{\"value\":\"ok\"}"}}],
|
||||
"usage":{"prompt_tokens":11,"completion_tokens":7,"total_tokens":18}
|
||||
}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newTestClient(t, server.URL, "default-model", 0)
|
||||
var out testArtifact
|
||||
resp, err := client.CompleteStructured(context.Background(), validStructuredRequest(""), &out)
|
||||
if err != nil {
|
||||
t.Fatalf("CompleteStructured: %v", err)
|
||||
}
|
||||
|
||||
if out.Value != "ok" {
|
||||
t.Fatalf("unexpected decoded output: %+v", out)
|
||||
}
|
||||
if string(resp.Content) != `{"value":"ok"}` {
|
||||
t.Fatalf("unexpected raw content: %s", resp.Content)
|
||||
}
|
||||
if resp.Provider != openAICompatibleProviderName {
|
||||
t.Fatalf("unexpected provider: %q", resp.Provider)
|
||||
}
|
||||
if resp.Model != "provider-model" {
|
||||
t.Fatalf("unexpected model: %q", resp.Model)
|
||||
}
|
||||
if resp.PromptTokens != 11 || resp.CompletionTokens != 7 || resp.TotalTokens != 18 {
|
||||
t.Fatalf("unexpected token metadata: %+v", resp)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientRequestBodyIncludesStructuredOutputShape(t *testing.T) {
|
||||
var seenPath string
|
||||
var seenAuthorization string
|
||||
var seenReq map[string]any
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
seenPath = r.URL.Path
|
||||
seenAuthorization = r.Header.Get("Authorization")
|
||||
if err := json.NewDecoder(r.Body).Decode(&seenReq); err != nil {
|
||||
t.Fatalf("decode request: %v", err)
|
||||
}
|
||||
_, _ = io.WriteString(w, `{"choices":[{"message":{"content":"{\"value\":\"ok\"}"}}]}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client, err := NewOpenAICompatibleClient(OpenAICompatibleClientConfig{
|
||||
BaseURL: server.URL + "/v1",
|
||||
Model: "default-model",
|
||||
APIKey: "secret-key",
|
||||
MaxRetries: 0,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("NewOpenAICompatibleClient: %v", err)
|
||||
}
|
||||
|
||||
var out testArtifact
|
||||
_, err = client.CompleteStructured(context.Background(), validStructuredRequest("request-model"), &out)
|
||||
if err != nil {
|
||||
t.Fatalf("CompleteStructured: %v", err)
|
||||
}
|
||||
|
||||
if seenPath != "/v1/chat/completions" {
|
||||
t.Fatalf("unexpected request path: %q", seenPath)
|
||||
}
|
||||
if seenAuthorization != "Bearer secret-key" {
|
||||
t.Fatalf("unexpected authorization header: %q", seenAuthorization)
|
||||
}
|
||||
if seenReq["model"] != "request-model" {
|
||||
t.Fatalf("unexpected model: %v", seenReq["model"])
|
||||
}
|
||||
|
||||
messages, ok := seenReq["messages"].([]any)
|
||||
if !ok || len(messages) != 1 {
|
||||
t.Fatalf("unexpected messages: %#v", seenReq["messages"])
|
||||
}
|
||||
message, ok := messages[0].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("unexpected message shape: %#v", messages[0])
|
||||
}
|
||||
if message["role"] != "user" || message["content"] != "extract this" {
|
||||
t.Fatalf("unexpected message: %#v", message)
|
||||
}
|
||||
|
||||
responseFormat, ok := seenReq["response_format"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("expected response_format object, got %T", seenReq["response_format"])
|
||||
}
|
||||
if responseFormat["type"] != "json_schema" {
|
||||
t.Fatalf("unexpected response_format.type: %v", responseFormat["type"])
|
||||
}
|
||||
jsonSchema, ok := responseFormat["json_schema"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("expected response_format.json_schema object, got %T", responseFormat["json_schema"])
|
||||
}
|
||||
if jsonSchema["name"] != "test_artifact" {
|
||||
t.Fatalf("unexpected schema name: %v", jsonSchema["name"])
|
||||
}
|
||||
if jsonSchema["strict"] != true {
|
||||
t.Fatalf("expected strict=true, got %v", jsonSchema["strict"])
|
||||
}
|
||||
schema, ok := jsonSchema["schema"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("expected schema object, got %T", jsonSchema["schema"])
|
||||
}
|
||||
if schema["type"] != "object" {
|
||||
t.Fatalf("unexpected schema: %#v", schema)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientDefaultModelFallbackAndOverride(t *testing.T) {
|
||||
var seenModels []string
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
var req map[string]any
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
t.Fatalf("decode request: %v", err)
|
||||
}
|
||||
seenModels = append(seenModels, fmt.Sprint(req["model"]))
|
||||
_, _ = io.WriteString(w, `{"choices":[{"message":{"content":"{\"value\":\"ok\"}"}}]}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newTestClient(t, server.URL, "default-model", 0)
|
||||
var first testArtifact
|
||||
if _, err := client.CompleteStructured(context.Background(), validStructuredRequest(""), &first); err != nil {
|
||||
t.Fatalf("first CompleteStructured: %v", err)
|
||||
}
|
||||
var second testArtifact
|
||||
if _, err := client.CompleteStructured(context.Background(), validStructuredRequest("override-model"), &second); err != nil {
|
||||
t.Fatalf("second CompleteStructured: %v", err)
|
||||
}
|
||||
|
||||
if len(seenModels) != 2 || seenModels[0] != "default-model" || seenModels[1] != "override-model" {
|
||||
t.Fatalf("unexpected models: %v", seenModels)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientInvalidOutputTarget(t *testing.T) {
|
||||
client := newTestClient(t, "https://example.test/v1", "default-model", 0)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
out any
|
||||
}{
|
||||
{name: "nil", out: nil},
|
||||
{name: "non-pointer", out: testArtifact{}},
|
||||
{name: "nil pointer", out: (*testArtifact)(nil)},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
_, err := client.CompleteStructured(context.Background(), validStructuredRequest(""), tc.out)
|
||||
if err == nil || !strings.Contains(err.Error(), "output target") {
|
||||
t.Fatalf("expected output target error, got %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientMissingAndInvalidSchema(t *testing.T) {
|
||||
client := newTestClient(t, "https://example.test/v1", "default-model", 0)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
mutate func(*contracts.StructuredCompletionRequest)
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "missing schema name",
|
||||
mutate: func(req *contracts.StructuredCompletionRequest) {
|
||||
req.ResponseSchemaName = " "
|
||||
},
|
||||
want: "schema name",
|
||||
},
|
||||
{
|
||||
name: "missing schema JSON",
|
||||
mutate: func(req *contracts.StructuredCompletionRequest) {
|
||||
req.ResponseSchema = nil
|
||||
},
|
||||
want: "schema JSON",
|
||||
},
|
||||
{
|
||||
name: "invalid schema JSON",
|
||||
mutate: func(req *contracts.StructuredCompletionRequest) {
|
||||
req.ResponseSchema = json.RawMessage(`{"type":`)
|
||||
},
|
||||
want: "schema JSON",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
req := validStructuredRequest("")
|
||||
tc.mutate(&req)
|
||||
var out testArtifact
|
||||
_, err := client.CompleteStructured(context.Background(), req, &out)
|
||||
if err == nil || !strings.Contains(err.Error(), tc.want) {
|
||||
t.Fatalf("expected error containing %q, got %v", tc.want, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientRejectsEmptyMessages(t *testing.T) {
|
||||
client := newTestClient(t, "https://example.test/v1", "default-model", 0)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
mutate func(*contracts.StructuredCompletionRequest)
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "no messages",
|
||||
mutate: func(req *contracts.StructuredCompletionRequest) {
|
||||
req.Messages = nil
|
||||
},
|
||||
want: "messages",
|
||||
},
|
||||
{
|
||||
name: "empty role",
|
||||
mutate: func(req *contracts.StructuredCompletionRequest) {
|
||||
req.Messages[0].Role = " "
|
||||
},
|
||||
want: "role",
|
||||
},
|
||||
{
|
||||
name: "empty content",
|
||||
mutate: func(req *contracts.StructuredCompletionRequest) {
|
||||
req.Messages[0].Content = " "
|
||||
},
|
||||
want: "content",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
req := validStructuredRequest("")
|
||||
tc.mutate(&req)
|
||||
var out testArtifact
|
||||
_, err := client.CompleteStructured(context.Background(), req, &out)
|
||||
if err == nil || !strings.Contains(err.Error(), tc.want) {
|
||||
t.Fatalf("expected error containing %q, got %v", tc.want, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientProviderNon2xxBehavior(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
_, _ = io.WriteString(w, `{"error":{"message":"bad request"}}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newTestClient(t, server.URL, "default-model", 0)
|
||||
var out testArtifact
|
||||
_, err := client.CompleteStructured(context.Background(), validStructuredRequest(""), &out)
|
||||
if err == nil || !strings.Contains(err.Error(), "status 400: bad request") {
|
||||
t.Fatalf("expected provider status error, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientRetries429And5xx(t *testing.T) {
|
||||
var attempts atomic.Int32
|
||||
statuses := []int{http.StatusTooManyRequests, http.StatusInternalServerError, http.StatusOK}
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
attempt := int(attempts.Add(1)) - 1
|
||||
if statuses[attempt] != http.StatusOK {
|
||||
w.WriteHeader(statuses[attempt])
|
||||
_, _ = io.WriteString(w, `{"error":{"message":"try again"}}`)
|
||||
return
|
||||
}
|
||||
_, _ = io.WriteString(w, `{"choices":[{"message":{"content":"{\"value\":\"ok\"}"}}]}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newTestClient(t, server.URL, "default-model", 2)
|
||||
var out testArtifact
|
||||
if _, err := client.CompleteStructured(context.Background(), validStructuredRequest(""), &out); err != nil {
|
||||
t.Fatalf("CompleteStructured: %v", err)
|
||||
}
|
||||
if attempts.Load() != 3 {
|
||||
t.Fatalf("expected 3 attempts, got %d", attempts.Load())
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientRetriesMalformedResponses(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
firstBody string
|
||||
}{
|
||||
{
|
||||
name: "malformed provider envelope",
|
||||
firstBody: `{"choices":[]}`,
|
||||
},
|
||||
{
|
||||
name: "malformed assistant JSON",
|
||||
firstBody: `{"choices":[{"message":{"content":"{"}}]}`,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
var attempts atomic.Int32
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if attempts.Add(1) == 1 {
|
||||
_, _ = io.WriteString(w, tc.firstBody)
|
||||
return
|
||||
}
|
||||
_, _ = io.WriteString(w, `{"choices":[{"message":{"content":"{\"value\":\"ok\"}"}}]}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newTestClient(t, server.URL, "default-model", 1)
|
||||
var out testArtifact
|
||||
if _, err := client.CompleteStructured(context.Background(), validStructuredRequest(""), &out); err != nil {
|
||||
t.Fatalf("CompleteStructured: %v", err)
|
||||
}
|
||||
if attempts.Load() != 2 {
|
||||
t.Fatalf("expected 2 attempts, got %d", attempts.Load())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientNoRetryForNonRetryable4xx(t *testing.T) {
|
||||
var attempts atomic.Int32
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
attempts.Add(1)
|
||||
w.WriteHeader(http.StatusForbidden)
|
||||
_, _ = io.WriteString(w, `{"error":{"message":"forbidden"}}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client := newTestClient(t, server.URL, "default-model", 3)
|
||||
var out testArtifact
|
||||
_, err := client.CompleteStructured(context.Background(), validStructuredRequest(""), &out)
|
||||
if err == nil || !strings.Contains(err.Error(), "status 403") {
|
||||
t.Fatalf("expected forbidden error, got %v", err)
|
||||
}
|
||||
if attempts.Load() != 1 {
|
||||
t.Fatalf("expected 1 attempt, got %d", attempts.Load())
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientProviderErrorRedactsAPIKey(t *testing.T) {
|
||||
const apiKey = "secret-api-key"
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
_, _ = io.WriteString(w, `{"error":{"message":"Bearer secret-api-key failed for secret-api-key"}}`)
|
||||
}))
|
||||
defer server.Close()
|
||||
|
||||
client, err := NewOpenAICompatibleClient(OpenAICompatibleClientConfig{
|
||||
BaseURL: server.URL,
|
||||
Model: "default-model",
|
||||
APIKey: apiKey,
|
||||
MaxRetries: 0,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("NewOpenAICompatibleClient: %v", err)
|
||||
}
|
||||
|
||||
var out testArtifact
|
||||
_, err = client.CompleteStructured(context.Background(), validStructuredRequest(""), &out)
|
||||
if err == nil {
|
||||
t.Fatalf("expected provider error")
|
||||
}
|
||||
if strings.Contains(err.Error(), apiKey) || strings.Contains(err.Error(), "Bearer "+apiKey) {
|
||||
t.Fatalf("expected API key to be redacted, got %q", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpenAICompatibleClientRespectsContextCancellation(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
|
||||
client := newTestClient(t, "https://example.test/v1", "default-model", 1)
|
||||
var out testArtifact
|
||||
_, err := client.CompleteStructured(ctx, validStructuredRequest(""), &out)
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatalf("expected context canceled, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func newTestClient(t *testing.T, baseURL string, model string, maxRetries int) *OpenAICompatibleClient {
|
||||
t.Helper()
|
||||
client, err := NewOpenAICompatibleClient(OpenAICompatibleClientConfig{
|
||||
BaseURL: baseURL,
|
||||
Model: model,
|
||||
MaxRetries: maxRetries,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("NewOpenAICompatibleClient: %v", err)
|
||||
}
|
||||
return client
|
||||
}
|
||||
|
||||
func validStructuredRequest(model string) contracts.StructuredCompletionRequest {
|
||||
return contracts.StructuredCompletionRequest{
|
||||
Messages: []contracts.LLMMessage{
|
||||
{Role: " user ", Content: " extract this "},
|
||||
},
|
||||
Model: model,
|
||||
ResponseSchemaName: " test_artifact ",
|
||||
ResponseSchema: testResponseSchema(),
|
||||
}
|
||||
}
|
||||
|
||||
func testResponseSchema() json.RawMessage {
|
||||
return json.RawMessage(`{
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"value": {"type": "string"}
|
||||
},
|
||||
"required": ["value"],
|
||||
"additionalProperties": false
|
||||
}`)
|
||||
}
|
||||
Reference in New Issue
Block a user