feat: AI models admin, settings import, Anthropic adapter and the rest of AIService

- golem15_golem_models (encrypted write-only api_key) with its cabana list
  and form under golem15.golem.access_settings, and the Settings lookups
  (Models, DefaultModel with PHP's position-0 quirk, Vision, Image, File,
  ByName), every one Trusted
- golem:import-settings copies the WinterCMS golem_settings repeater once
- AnthropicAdapter; SendStream, SendFile/SendFilePath/SendFileReader,
  SendWithModel, SendToImageModel, SendToVisionModel, GenerateImage, Ask
- PromptFactory; README documents the config keys, the environment
  variable, the command and the admin screen
This commit is contained in:
Jakub Zych
2026-10-03 23:09:02 +02:00
parent da9fcde725
commit c93e2d9142
27 changed files with 2760 additions and 14 deletions

View File

@@ -0,0 +1,212 @@
// Package factories ports the WinterCMS plugin's PromptFactory: ready-made
// prompts for form field suggestions, categorisation, chats and
// completions.
package factories
import (
"regexp"
"strings"
"git.golem15.com/golem15/sm-golem-plugin/classes/valueobjects"
)
// Pair is one ordered key and value: a context field, a dropdown option.
type Pair struct {
Key string
Value string
}
// FormField is one field to suggest a value for.
type FormField struct {
Name string
Type string
}
// Category is one existing category an item may be assigned to.
type Category struct {
ID string
Name string
}
var fieldStrategies = map[string]string{
"text": "Generate a concise, descriptive text value",
"textarea": "Generate longer form text content",
"slug": "Generate a URL-friendly slug (lowercase, hyphens instead of spaces, no special characters)",
"richeditor": "Generate formatted HTML content with appropriate tags",
"markdown": "Generate Markdown-formatted content",
"code": "Generate code in the appropriate language",
"taglist": "Generate comma-separated tags/keywords",
"dropdown": "Select the most appropriate option from available choices",
}
// PromptFactory builds prompts (PHP PromptFactory's static methods).
type PromptFactory struct{}
// CreateSuggestionForField is the prompt for one form field's value.
// currentValue is nil when the field is empty; options are listed only
// for dropdown, radio and checkboxlist fields.
func (PromptFactory) CreateSuggestionForField(fieldName, fieldType string, currentValue *string, context []Pair, options []Pair) valueobjects.Prompt {
strategy, ok := fieldStrategies[fieldType]
if !ok {
strategy = "Generate an appropriate value"
}
system := "You are a helpful assistant that generates content for form fields. " +
"Your task is to: " + strategy + ". " +
"Respond with ONLY the value, no explanations or quotes."
return valueobjects.NewPrompt().
WithSystem(system).
AddUserMessage(buildFieldPrompt(fieldName, fieldType, currentValue, context, options))
}
// SuggestFieldsValues is the prompt for a JSON object of values for
// several fields. notes may be nil.
func (PromptFactory) SuggestFieldsValues(fields []FormField, context []Pair, notes *string) valueobjects.Prompt {
system := "You are an expert content generation assistant. " +
"Based on the provided context, suggest appropriate values for the specified fields. " +
"Respond in JSON format with field names as keys and generated values as values. " +
"Do not include any explanations or additional text, respond in raw json without any markdown. Never enclose result in ``` markdown."
var b strings.Builder
b.WriteString("Fields to generate values for:\n")
for _, f := range fields {
name, typ := f.Name, f.Type
if name == "" {
name = "unnamed"
}
if typ == "" {
typ = "text"
}
b.WriteString("- " + name + " (type: " + typ + ")\n")
}
if len(context) > 0 {
b.WriteString("\nContext to base the suggestions on:\n")
writeContext(&b, context, "- ", "\n")
}
if notes != nil && *notes != "" {
b.WriteString("\nAdditional notes:\n" + *notes + "\n")
}
return valueobjects.NewPrompt().WithSystem(system).AddUserMessage(b.String())
}
// SuggestCategoriesForItem is the prompt for the ids of the existing
// categories that fit an item. notes may be nil.
func (PromptFactory) SuggestCategoriesForItem(categories []Category, context []Pair, notes *string) valueobjects.Prompt {
system := "You are an expert content categorization assistant. " +
"Based on the provided context, suggest relevant categories from the existing list. " +
"Respond with a comma-separated list of category ids that best fit the content. " +
"Do not suggest categories that are not in the existing list. Respond with ids only, no quotes or explanations."
var b strings.Builder
b.WriteString("Existing categories:\n")
for _, c := range categories {
id, name := c.ID, c.Name
if id == "" {
id = "unknown"
}
if name == "" {
name = "unnamed"
}
b.WriteString("- " + id + ": " + name + "\n")
}
if len(context) > 0 {
b.WriteString("\nContext to assign categories to:\n")
writeContext(&b, context, "- ", "\n")
}
if notes != nil && *notes != "" {
b.WriteString("\nAdditional notes:\n" + *notes + "\n")
}
return valueobjects.NewPrompt().WithSystem(system).AddUserMessage(b.String())
}
// CreateChat is an empty chat with an optional system prompt.
func (PromptFactory) CreateChat(system string) valueobjects.Prompt {
p := valueobjects.NewPrompt()
if system != "" {
p = p.WithSystem(system)
}
return p
}
// CreateCompletion is a one-message prompt with an optional system prompt.
func (f PromptFactory) CreateCompletion(userMessage, system string) valueobjects.Prompt {
return f.CreateChat(system).AddUserMessage(userMessage)
}
func buildFieldPrompt(fieldName, fieldType string, currentValue *string, context, options []Pair) string {
var b strings.Builder
b.WriteString("Generate a value for the '" + HumanizeFieldName(fieldName) + "' field.")
if len(context) > 0 {
b.WriteString("\n\nContext from related fields:")
writeContext(&b, context, "\n- ", "")
}
if currentValue != nil && *currentValue != "" {
b.WriteString("\n\nCurrent value (improve or keep if already good): " + *currentValue)
}
if len(options) > 0 && (fieldType == "dropdown" || fieldType == "radio" || fieldType == "checkboxlist") {
b.WriteString("\n\nAvailable options:")
for _, o := range options {
b.WriteString("\n- " + o.Key + ": " + o.Value)
}
b.WriteString("\n\nRespond with ONLY the option key.")
}
switch fieldType {
case "slug":
b.WriteString("\n\nFormat: lowercase letters, numbers, and hyphens only. No spaces or special characters.")
case "taglist":
b.WriteString("\n\nFormat: comma-separated list of relevant keywords/tags.")
case "richeditor":
b.WriteString("\n\nFormat: valid HTML with appropriate tags (p, h2, h3, ul, li, strong, em).")
case "markdown":
b.WriteString("\n\nFormat: valid Markdown syntax.")
}
return b.String()
}
// writeContext writes each non-empty context value (PHP skips empty()
// values, "0" included) as prefix + humanized key + ": " + value + suffix.
func writeContext(b *strings.Builder, context []Pair, prefix, suffix string) {
for _, c := range context {
if c.Value == "" || c.Value == "0" {
continue
}
b.WriteString(prefix + HumanizeFieldName(c.Key) + ": " + c.Value + suffix)
}
}
var (
fieldPrefix = regexp.MustCompile(`^(field_|input_|txt_)`)
camelBreak = regexp.MustCompile(`([a-z])([A-Z])`)
)
// HumanizeFieldName turns a field name into words: the field_, input_ or
// txt_ prefix dropped, camelCase split, underscores and hyphens to
// spaces, each word capitalised (PHP ucwords(strtolower(...))).
func HumanizeFieldName(name string) string {
name = fieldPrefix.ReplaceAllString(name, "")
name = camelBreak.ReplaceAllString(name, "$1 $2")
name = strings.NewReplacer("_", " ", "-", " ").Replace(name)
return ucwords(asciiLower(name))
}
// asciiLower is PHP 8's strtolower: ASCII letters only.
func asciiLower(s string) string {
b := []byte(s)
for i, c := range b {
if c >= 'A' && c <= 'Z' {
b[i] = c + 'a' - 'A'
}
}
return string(b)
}
// ucwords upper-cases the first ASCII letter of each word, words being
// separated by PHP's default delimiters.
func ucwords(s string) string {
b := []byte(s)
start := true
for i, c := range b {
if start && c >= 'a' && c <= 'z' {
b[i] = c - 'a' + 'A'
}
start = c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\f' || c == '\v'
}
return string(b)
}

View File

@@ -0,0 +1,48 @@
package factories
import (
"strings"
"testing"
)
func TestPromptFactory(t *testing.T) {
f := PromptFactory{}
for in, want := range map[string]string{
"field_firstName": "First Name",
"input_meta-title": "Meta Title",
"txt_SEO_title": "Seo Title",
"catalog_number": "Catalog Number",
} {
if got := HumanizeFieldName(in); got != want {
t.Errorf("HumanizeFieldName(%q) = %q, want %q", in, got, want)
}
}
cur := "old-slug"
p := f.CreateSuggestionForField("post_slug", "slug", &cur, []Pair{{"title", "Hello World"}, {"empty", ""}, {"zero", "0"}}, nil)
if !strings.Contains(p.SystemPrompt(), "Generate a URL-friendly slug") {
t.Fatalf("system = %q", p.SystemPrompt())
}
want := "Generate a value for the 'Post Slug' field.\n\nContext from related fields:\n- Title: Hello World\n\nCurrent value (improve or keep if already good): old-slug\n\nFormat: lowercase letters, numbers, and hyphens only. No spaces or special characters."
if got := p.Messages()[0].Text; got != want {
t.Fatalf("user message = %q", got)
}
p = f.CreateSuggestionForField("format", "dropdown", nil, nil, []Pair{{"LP", "Vinyl LP"}, {"CD", "Compact disc"}})
if got := p.Messages()[0].Text; !strings.HasSuffix(got, "Available options:\n- LP: Vinyl LP\n- CD: Compact disc\n\nRespond with ONLY the option key.") {
t.Fatalf("dropdown = %q", got)
}
notes := "Keep it short."
p = f.SuggestFieldsValues([]FormField{{Name: "title"}, {Name: "body", Type: "markdown"}}, []Pair{{"topic", "Jazz"}}, &notes)
if got := p.Messages()[0].Text; got != "Fields to generate values for:\n- title (type: text)\n- body (type: markdown)\n\nContext to base the suggestions on:\n- Topic: Jazz\n\nAdditional notes:\nKeep it short.\n" {
t.Fatalf("fields = %q", got)
}
p = f.SuggestCategoriesForItem([]Category{{ID: "1", Name: "Jazz"}, {}}, nil, nil)
if got := p.Messages()[0].Text; got != "Existing categories:\n- 1: Jazz\n- unknown: unnamed\n" {
t.Fatalf("categories = %q", got)
}
if p := f.CreateChat(""); p.SystemPrompt() != "" || len(p.Messages()) != 0 {
t.Fatal("empty chat")
}
if p := f.CreateCompletion("hi", "sys"); p.SystemPrompt() != "sys" || p.Messages()[0].Text != "hi" {
t.Fatal("completion")
}
}

View File

@@ -49,6 +49,9 @@ const (
// ForName is ProviderFactory::make: the Anthropic adapter for "anthropic",
// the OpenAI-compatible adapter for anything else.
func ForName(adapter string) Adapter {
if adapter == "anthropic" {
return AnthropicAdapter{}
}
return OpenAIAdapter{}
}

View File

@@ -0,0 +1,195 @@
package providers
import (
"encoding/json"
"net/http"
"regexp"
"strings"
"git.golem15.com/golem15/sm-golem-plugin/classes/valueobjects"
"git.golem15.com/golem15/summercms/modules/fetchguard"
)
// Anthropic API headers PHP sends on every request.
const (
AnthropicVersion = "2023-06-01"
AnthropicBeta = "files-api-2025-04-14"
)
// AnthropicAdapter is the Anthropic Messages API mapping (PHP
// AnthropicAdapter).
type AnthropicAdapter struct{}
var _ Adapter = AnthropicAdapter{}
var dataURL = regexp.MustCompile(`^data:([^;]+);base64,(.+)$`)
func anthropicHeaders(apiKey string) http.Header {
return http.Header{
"X-Api-Key": {apiKey},
"Anthropic-Version": {AnthropicVersion},
"Anthropic-Beta": {AnthropicBeta},
}
}
// Headers are x-api-key, anthropic-version and anthropic-beta.
func (AnthropicAdapter) Headers(apiKey string) http.Header { return anthropicHeaders(apiKey) }
// ChatEndpoint is <base>/messages.
func (AnthropicAdapter) ChatEndpoint(baseURL string) string {
return endpoint(baseURL, AnthropicBaseURL, "/messages")
}
// FilesEndpoint is <base>/files.
func (AnthropicAdapter) FilesEndpoint(baseURL string) string {
return endpoint(baseURL, AnthropicBaseURL, "/files")
}
// ImageEndpoint is "": Anthropic generates no images.
func (AnthropicAdapter) ImageEndpoint(string) string { return "" }
// BuildChatPayload is the Messages body: model (the prompt's override or
// modelID), the messages with image_url blocks rewritten to image blocks
// (base64 for a data: URL, url otherwise) and file blocks to document
// blocks, the system prompt when set, max_tokens (the max_tokens option,
// else max_completion_tokens, else 4096) and every other option except
// response_format and max_completion_tokens.
func (AnthropicAdapter) BuildChatPayload(prompt valueobjects.Prompt, modelID string) *valueobjects.Payload {
msgs := prompt.Messages()
out := make([]map[string]any, 0, len(msgs))
for _, m := range msgs {
out = append(out, map[string]any{"role": m.Role, "content": anthropicContent(m)})
}
payload := valueobjects.NewPayload()
model := modelID
if p := prompt.Model(); p != nil {
model = *p
}
payload.Set("model", model)
payload.Set("messages", out)
if s := prompt.SystemPrompt(); s != "" {
payload.Set("system", s)
}
opts := prompt.Options()
var maxTokens any = 4096
if opts.IsSet("max_tokens") {
maxTokens, _ = opts.Get("max_tokens")
} else if opts.IsSet("max_completion_tokens") {
maxTokens, _ = opts.Get("max_completion_tokens")
}
payload.Set("max_tokens", maxTokens)
for _, k := range opts.Keys() {
if k == "response_format" || k == "max_completion_tokens" {
continue
}
v, _ := opts.Get(k)
payload.Set(k, v)
}
return payload
}
func anthropicContent(m valueobjects.Message) any {
if m.Parts == nil {
return m.Text
}
blocks := make([]any, 0, len(m.Parts))
for _, part := range m.Parts {
switch part.Type {
case "image_url":
u := ""
if part.ImageURL != nil {
u = part.ImageURL.URL
}
if strings.HasPrefix(u, "data:") {
media, data := "image/jpeg", ""
if mm := dataURL.FindStringSubmatch(u); mm != nil {
media, data = mm[1], mm[2]
}
blocks = append(blocks, map[string]any{"type": "image", "source": map[string]any{"type": "base64", "media_type": media, "data": data}})
} else {
blocks = append(blocks, map[string]any{"type": "image", "source": map[string]any{"type": "url", "url": u}})
}
case "file":
id := ""
if part.File != nil {
id = part.File.FileID
}
blocks = append(blocks, map[string]any{"type": "document", "source": map[string]any{"type": "file", "file_id": id}})
default:
blocks = append(blocks, part)
}
}
return blocks
}
// FileUploadFields is empty: the Anthropic files API takes the file only.
func (AnthropicAdapter) FileUploadFields(string) []fetchguard.FormField { return nil }
// FileUploadHeaders are the Messages headers.
func (AnthropicAdapter) FileUploadHeaders(apiKey string) http.Header {
return anthropicHeaders(apiKey)
}
// ParseChatResponse reads content[0].text; usage gains PHP's
// prompt_tokens, completion_tokens and total_tokens next to Anthropic's
// input_tokens and output_tokens; Raw keeps the whole answer, stop_reason
// included.
func (AnthropicAdapter) ParseChatResponse(data map[string]any) valueobjects.AIResponse {
if msg, ok := errorMessage(data); ok {
return valueobjects.Failure(msg, data)
}
content := dig(data, "content", 0, "text")
if content == nil {
return valueobjects.Failure("No content in AI response.", data)
}
usage := map[string]any{}
if u, ok := data["usage"].(map[string]any); ok {
for k, v := range u {
usage[k] = v
}
}
if in, ok := usage["input_tokens"]; ok && in != nil {
prompt := number(in)
completion := number(usage["output_tokens"])
usage["prompt_tokens"] = in
if usage["output_tokens"] == nil {
usage["completion_tokens"] = 0
} else {
usage["completion_tokens"] = usage["output_tokens"]
}
usage["total_tokens"] = prompt + completion
}
return valueobjects.Success(phpString(content), usage, data)
}
func number(v any) float64 {
if f, ok := v.(float64); ok {
return f
}
return 0
}
// ParseStreamChunk reads Anthropic's event stream: `event: message_stop`
// ends it, a `data:` line of type content_block_delta carries the text
// delta, anything else is skipped.
func (AnthropicAdapter) ParseStreamChunk(line string) (string, bool) {
if line == "" {
return "", false
}
if event, ok := strings.CutPrefix(line, "event: "); ok {
return "", event == "message_stop"
}
payload, ok := strings.CutPrefix(line, "data: ")
if !ok {
return "", false
}
var v map[string]any
if json.Unmarshal([]byte(payload), &v) != nil || len(v) == 0 {
return "", false
}
if v["type"] != "content_block_delta" {
return "", false
}
text, _ := dig(v, "delta", "text").(string)
return text, false
}

View File

@@ -179,3 +179,135 @@ func TestOpenAIAdapterPayload(t *testing.T) {
}
})
}
// TestAnthropicAdapterPayload pins AnthropicAdapter.php: headers,
// endpoints, the max_tokens fallback chain, the dropped options, image
// and file block rewriting, response parsing and the event stream.
func TestAnthropicAdapterPayload(t *testing.T) {
a := AnthropicAdapter{}
if _, ok := ForName("anthropic").(AnthropicAdapter); !ok {
t.Fatal("ForName(anthropic) is not the Anthropic adapter")
}
if _, ok := ForName("").(OpenAIAdapter); !ok {
t.Fatal("ForName(\"\") is not the OpenAI adapter")
}
t.Run("headers and endpoints", func(t *testing.T) {
h := a.Headers("sk-ant-test")
if h.Get("X-Api-Key") != "sk-ant-test" || h.Get("Anthropic-Version") != "2023-06-01" || h.Get("Anthropic-Beta") != "files-api-2025-04-14" || h.Get("Authorization") != "" {
t.Fatalf("headers = %v", h)
}
if a.FileUploadHeaders("k").Get("X-Api-Key") != "k" {
t.Fatal("file upload headers")
}
if got := a.ChatEndpoint(""); got != "https://api.anthropic.com/v1/messages" {
t.Fatal(got)
}
if got := a.ChatEndpoint("https://proxy.example.test/v1///"); got != "https://proxy.example.test/v1/messages" {
t.Fatal(got)
}
if got := a.FilesEndpoint(""); got != "https://api.anthropic.com/v1/files" {
t.Fatal(got)
}
if a.ImageEndpoint("") != "" || a.FileUploadFields("assistants") != nil {
t.Fatal("anthropic has no image endpoint and no upload fields")
}
})
t.Run("max_tokens chain and dropped options", func(t *testing.T) {
base := valueobjects.NewPrompt().AddUserMessage("hi")
if v, _ := a.BuildChatPayload(base, "claude-sonnet-4-6").Get("max_tokens"); v != 4096 {
t.Fatalf("default max_tokens = %v", v)
}
p := a.BuildChatPayload(base.WithOptions(map[string]any{"max_completion_tokens": 8192, "response_format": map[string]any{"type": "json_object"}, "temperature": 0.2}), "claude-sonnet-4-6")
if v, _ := p.Get("max_tokens"); v != 8192 {
t.Fatalf("max_completion_tokens fallback = %v", v)
}
if p.Has("max_completion_tokens") || p.Has("response_format") {
t.Fatalf("dropped options leaked: %v", p.Keys())
}
if v, _ := p.Get("temperature"); v != 0.2 {
t.Fatal("other options pass through")
}
p = a.BuildChatPayload(base.WithOptions(map[string]any{"max_tokens": 100, "max_completion_tokens": 200}, "max_tokens", "max_completion_tokens"), "m")
if v, _ := p.Get("max_tokens"); v != 100 {
t.Fatalf("explicit max_tokens wins: %v", v)
}
if p.Has("system") {
t.Fatal("system without a system prompt")
}
if got := strings.Join(a.BuildChatPayload(base.WithSystem("sys"), "m").Keys(), ","); got != "model,messages,system,max_tokens" {
t.Fatalf("keys = %s", got)
}
})
t.Run("image and file blocks", func(t *testing.T) {
prompt := valueobjects.NewPrompt().
WithSystem("You catalog physical items.").
AddUserMessageWithImage("What is this?", "QUJD", "image/png").
AddUserMessageWithFileID("Read this.", "file_123").
WithModel("claude-opus")
m := payloadMap(t, a.BuildChatPayload(prompt, "claude-sonnet-4-6"))
if m["model"] != "claude-opus" || m["system"] != "You catalog physical items." {
t.Fatalf("payload = %v", m)
}
msgs := m["messages"].([]any)
if len(msgs) != 2 {
t.Fatalf("messages = %v (the system prompt is not a message)", msgs)
}
img := msgs[0].(map[string]any)["content"].([]any)[1].(map[string]any)
src := img["source"].(map[string]any)
if img["type"] != "image" || src["type"] != "base64" || src["media_type"] != "image/png" || src["data"] != "QUJD" {
t.Fatalf("image block = %v", img)
}
doc := msgs[1].(map[string]any)["content"].([]any)[1].(map[string]any)
if doc["type"] != "document" || doc["source"].(map[string]any)["file_id"] != "file_123" {
t.Fatalf("document block = %v", doc)
}
remote := valueobjects.Message{Role: "user", Parts: []valueobjects.ContentPart{{Type: "image_url", ImageURL: &valueobjects.ImageURL{URL: "https://img.example.test/a.jpg"}}}}
blk := anthropicContent(remote).([]any)[0].(map[string]any)["source"].(map[string]any)
if blk["type"] != "url" || blk["url"] != "https://img.example.test/a.jpg" {
t.Fatalf("remote image = %v", blk)
}
})
t.Run("parse", func(t *testing.T) {
var data map[string]any
_ = json.Unmarshal([]byte(`{"content":[{"type":"text","text":"[]"}],"stop_reason":"max_tokens","usage":{"input_tokens":10,"output_tokens":5}}`), &data)
r := a.ParseChatResponse(data)
if !r.Success || r.Content != "[]" || r.Raw["stop_reason"] != "max_tokens" {
t.Fatalf("response = %+v", r)
}
if r.PromptTokens() != 10 || r.CompletionTokens() != 5 || r.TotalTokens() != 15 || r.Usage["input_tokens"] != float64(10) {
t.Fatalf("usage = %v", r.Usage)
}
r = a.ParseChatResponse(map[string]any{"type": "error", "error": map[string]any{"type": "authentication_error", "message": "invalid x-api-key"}})
if r.Success || r.Error != "invalid x-api-key" {
t.Fatalf("error = %+v", r)
}
r = a.ParseChatResponse(map[string]any{"content": []any{}})
if r.Error != "No content in AI response." {
t.Fatalf("empty = %+v", r)
}
})
t.Run("stream", func(t *testing.T) {
for _, c := range []struct {
line string
delta string
done bool
}{
{"", "", false},
{"event: content_block_delta", "", false},
{`data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"Hi"}}`, "Hi", false},
{`data: {"type":"message_delta","delta":{"stop_reason":"end_turn"}}`, "", false},
{"data: {}", "", false},
{"event: message_stop", "", true},
} {
d, done := a.ParseStreamChunk(c.line)
if d != c.delta || done != c.done {
t.Fatalf("%q: (%q,%v)", c.line, d, done)
}
}
})
}

View File

@@ -1,9 +1,17 @@
package services
import (
"bufio"
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"strings"
"sync"
"time"
"unicode/utf8"
@@ -161,7 +169,7 @@ func (s *AIService) Send(ctx context.Context, prompt valueobjects.Prompt, cfg *M
// DefaultModel is the admin's default model, nil when none is configured.
func (s *AIService) DefaultModel(ctx context.Context) (*ModelConfig, error) {
return nil, nil
return DefaultModel(ctx, s.db())
}
// applyModelSystemPrompt sets the model's system prompt on a prompt that
@@ -196,3 +204,326 @@ func failure(msg string, raw map[string]any, err error) valueobjects.AIResponse
r.Err = err
return r
}
// More of PHP's failure messages.
const (
msgInternal = "Internal server error"
msgNoFileModel = "No file model configured."
msgFilesConnect = "Failed to connect to files API at: "
msgFilesInvalid = "Invalid response from files API: "
msgNoFileID = "No file ID in response."
msgNoImageModel = "No image generation model configured."
msgNoImageModelLong = `No image generation model configured. Enable a model with "generates_images" in Settings > AI.`
msgNoImageEndpoint = "The configured adapter does not support image generation."
msgNoImageKey = "API key is not configured for the image model."
msgImageConnect = "Failed to connect to image generation service."
msgImageInvalid = "Invalid response: "
msgNoImageURL = "No image URL in response."
msgNoVisionModel = "No vision model configured."
msgUnknownAPIError = "Unknown API error"
defaultImageModelID = "dall-e-3"
defaultImageSize = "1792x1024"
defaultImageQuality = "standard"
defaultUploadPurpose = "assistants"
)
// safeMessage is SafeExceptionResponse::safeExceptionMessage: the error's
// own text with app.debug on, PHP's generic text otherwise.
func (s *AIService) safeMessage(err error) string {
if s.cfg != nil && s.cfg.Bool("app.debug") {
return err.Error()
}
return msgInternal
}
// SendStream is AIService::sendStream: the prompt is posted with stream
// true and Accept: text/event-stream, and onChunk receives, in order, one
// {"content":"<delta>"} JSON string per content delta the adapter reads
// from the server-sent events, until the provider ends the stream. A nil
// config is the default model. It fails with PHP's message when no model
// or no key is configured, with the transport error when the connection
// fails, and with "HTTP <status> from AI service" on a status of 400 or
// more.
func (s *AIService) SendStream(ctx context.Context, prompt valueobjects.Prompt, onChunk func(chunk string), cfg *ModelConfig) error {
if cfg == nil {
def, err := s.DefaultModel(ctx)
if err != nil {
return err
}
cfg = def
}
if cfg == nil {
return errors.New(msgNoModel)
}
if cfg.APIKey == "" {
return errors.New(msgNoAPIKey)
}
prompt = applyModelSystemPrompt(prompt, cfg)
adapter := providers.ForName(cfg.Adapter)
payload := adapter.BuildChatPayload(prompt, cfg.modelID(DefaultModelID))
payload.Set("stream", true)
raw, err := json.Marshal(payload)
if err != nil {
return err
}
c, err := s.client(cfg.Trusted)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, adapter.ChatEndpoint(cfg.BaseURL), bytes.NewReader(raw))
if err != nil {
return err
}
req.Header = requestHeaders("application/json", adapter.Headers(cfg.APIKey))
req.Header.Set("Accept", "text/event-stream")
resp, err := c.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
r := bufio.NewReader(resp.Body)
for {
line, err := r.ReadString('\n')
if err != nil {
// A last line without a newline is never processed, as in PHP.
if !errors.Is(err, io.EOF) {
return err
}
break
}
delta, done := adapter.ParseStreamChunk(strings.TrimRight(strings.TrimSuffix(line, "\n"), "\r"))
if done {
break
}
if delta != "" && onChunk != nil {
chunk, _ := json.Marshal(map[string]string{"content": delta})
onChunk(string(chunk))
}
}
if resp.StatusCode >= 400 {
return fmt.Errorf("HTTP %d from AI service", resp.StatusCode)
}
return nil
}
// SendFile is AIService::sendFile: body uploaded as fileName with
// contentType for the assistants purpose (see SendFileReader).
func (s *AIService) SendFile(ctx context.Context, body io.Reader, fileName, contentType, modelName string) valueobjects.AIResponse {
return s.SendFileReader(ctx, body, defaultUploadPurpose, modelName, contentType, fileName)
}
// SendFilePath is AIService::sendFilePath for a file on disk: mimeType and
// fileName default to the sniffed type and the base name. A missing file
// is PHP's caught exception: "Internal server error" outside app.debug.
func (s *AIService) SendFilePath(ctx context.Context, path, purpose, modelName, mimeType, fileName string) valueobjects.AIResponse {
cfg, fail := s.fileModel(ctx, modelName)
if fail != nil {
return *fail
}
data, err := os.ReadFile(path)
if err != nil {
return failure(s.safeMessage(fmt.Errorf("File not found: %s", path)), nil, err)
}
if mimeType == "" {
mimeType = http.DetectContentType(data)
if mimeType == "" {
mimeType = "application/octet-stream"
}
}
if fileName == "" {
fileName = filepath.Base(path)
}
return s.upload(ctx, cfg, bytes.NewReader(data), purpose, mimeType, fileName)
}
// SendFileReader uploads body to the files endpoint of the model named
// modelName (which must have a files endpoint), or of the first model
// with one when modelName is empty, and answers the uploaded file's id as
// Content. The upload is multipart: the adapter's fields (OpenAI's
// purpose), then the file part "file".
func (s *AIService) SendFileReader(ctx context.Context, body io.Reader, purpose, modelName, mimeType, fileName string) valueobjects.AIResponse {
cfg, fail := s.fileModel(ctx, modelName)
if fail != nil {
return *fail
}
if mimeType == "" {
mimeType = "application/octet-stream"
}
return s.upload(ctx, cfg, body, purpose, mimeType, fileName)
}
func (s *AIService) fileModel(ctx context.Context, modelName string) (*ModelConfig, *valueobjects.AIResponse) {
var cfg *ModelConfig
var err error
if modelName != "" {
cfg, err = ModelByName(ctx, s.db(), modelName)
if err == nil && (cfg == nil || !cfg.HasFilesEndpoint) {
r := valueobjects.Failure(fmt.Sprintf("Model '%s' does not support file uploads.", modelName), nil)
return nil, &r
}
} else {
cfg, err = FileModel(ctx, s.db())
}
if err != nil {
r := failure(s.safeMessage(err), nil, err)
return nil, &r
}
if cfg == nil {
r := valueobjects.Failure(msgNoFileModel, nil)
return nil, &r
}
return cfg, nil
}
func (s *AIService) upload(ctx context.Context, cfg *ModelConfig, body io.Reader, purpose, mimeType, fileName string) valueobjects.AIResponse {
adapter := providers.ForName(cfg.Adapter)
endpoint := adapter.FilesEndpoint(cfg.BaseURL)
c, err := s.client(cfg.Trusted)
if err != nil {
return failure(msgFilesConnect+endpoint, nil, err)
}
res, err := c.PostMultipart(ctx, endpoint, requestHeaders("", adapter.FileUploadHeaders(cfg.APIKey)),
adapter.FileUploadFields(purpose),
[]fetchguard.FormFile{{Field: "file", Filename: fileName, ContentType: mimeType, Body: body}})
if err != nil {
return failure(msgFilesConnect+endpoint, nil, err)
}
data, msg := decodeObject(res.Body)
if msg != "" {
return valueobjects.Failure(msgFilesInvalid+msg, map[string]any{"raw": string(res.Body)})
}
if e, ok := data["error"]; ok && e != nil {
text := msgUnknownAPIError
if m, ok := e.(map[string]any); ok {
if v, ok := m["message"].(string); ok {
text = v
}
}
return valueobjects.Failure(text, data)
}
id, _ := data["id"].(string)
if id == "" {
return valueobjects.Failure(msgNoFileID, data)
}
return valueobjects.Success(id, nil, data)
}
// SendWithModel is AIService::sendWithModel: Send with the enabled model
// named name, or PHP's not-found failure.
func (s *AIService) SendWithModel(ctx context.Context, prompt valueobjects.Prompt, name string) valueobjects.AIResponse {
cfg, err := ModelByName(ctx, s.db(), name)
if err != nil {
return failure(msgConnectFailed, nil, err)
}
if cfg == nil {
return valueobjects.Failure(fmt.Sprintf("Model '%s' not found in settings.", name), nil)
}
return s.Send(ctx, prompt, cfg)
}
// SendToImageModel is AIService::sendToImageModel: Send with the first
// model that generates images.
func (s *AIService) SendToImageModel(ctx context.Context, prompt valueobjects.Prompt) valueobjects.AIResponse {
cfg, err := ImageModel(ctx, s.db())
if err != nil {
return failure(msgConnectFailed, nil, err)
}
if cfg == nil {
return valueobjects.Failure(msgNoImageModel, nil)
}
return s.Send(ctx, prompt, cfg)
}
// SendToVisionModel is AIService::sendToVisionModel: Send with the first
// model that accepts images.
func (s *AIService) SendToVisionModel(ctx context.Context, prompt valueobjects.Prompt) valueobjects.AIResponse {
cfg, err := s.VisionModel(ctx)
if err != nil {
return failure(msgConnectFailed, nil, err)
}
if cfg == nil {
return valueobjects.Failure(msgNoVisionModel, nil)
}
return s.Send(ctx, prompt, cfg)
}
// VisionModel is the admin's vision model, nil when none is configured.
func (s *AIService) VisionModel(ctx context.Context) (*ModelConfig, error) {
return VisionModel(ctx, s.db())
}
// GenerateImage is AIService::generateImage: the image model's images
// endpoint is asked for one image (size defaults to 1792x1024, quality to
// standard, the model id to dall-e-3) and Content is the returned URL,
// with Raw {"url", "revised_prompt"}. The URL is the provider's: run it
// through security.AssertSafeURL before fetching it, as the WinterCMS
// plugin does.
func (s *AIService) GenerateImage(ctx context.Context, prompt, size, quality string) valueobjects.AIResponse {
cfg, err := ImageModel(ctx, s.db())
if err != nil {
return failure(msgImageConnect, nil, err)
}
if cfg == nil {
return valueobjects.Failure(msgNoImageModelLong, nil)
}
adapter := providers.ForName(cfg.Adapter)
endpoint := adapter.ImageEndpoint(cfg.BaseURL)
if endpoint == "" {
return valueobjects.Failure(msgNoImageEndpoint, nil)
}
if cfg.APIKey == "" {
return valueobjects.Failure(msgNoImageKey, nil)
}
if size == "" {
size = defaultImageSize
}
if quality == "" {
quality = defaultImageQuality
}
payload := valueobjects.NewPayload()
payload.Set("model", cfg.modelID(defaultImageModelID))
payload.Set("prompt", prompt)
payload.Set("n", 1)
payload.Set("size", size)
payload.Set("quality", quality)
c, err := s.client(cfg.Trusted)
if err != nil {
return failure(msgImageConnect, nil, err)
}
res, err := c.PostJSON(ctx, endpoint, requestHeaders("", adapter.Headers(cfg.APIKey)), payload)
if err != nil {
return failure(msgImageConnect, nil, err)
}
data, msg := decodeObject(res.Body)
if msg != "" {
return valueobjects.Failure(msgImageInvalid+msg, nil)
}
if e, ok := data["error"]; ok && e != nil {
text := msgUnknownAPIError
if m, ok := e.(map[string]any); ok {
if v, ok := m["message"].(string); ok {
text = v
}
}
return valueobjects.Failure(text, nil)
}
var first map[string]any
if list, ok := data["data"].([]any); ok && len(list) > 0 {
first, _ = list[0].(map[string]any)
}
url, _ := first["url"].(string)
if url == "" {
return valueobjects.Failure(msgNoImageURL, nil)
}
return valueobjects.Success(url, nil, map[string]any{"url": url, "revised_prompt": first["revised_prompt"]})
}
// Ask is AIService::ask: one user message, with an optional system
// prompt, sent with the default model.
func (s *AIService) Ask(ctx context.Context, message, system string) valueobjects.AIResponse {
p := valueobjects.NewPrompt()
if system != "" {
p = p.WithSystem(system)
}
return s.Send(ctx, p.AddUserMessage(message), nil)
}

View File

@@ -0,0 +1,469 @@
package services
import (
"context"
"encoding/json"
"errors"
"io"
"mime"
"mime/multipart"
"net"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"git.golem15.com/golem15/sm-golem-plugin/classes/security"
"git.golem15.com/golem15/sm-golem-plugin/classes/valueobjects"
"git.golem15.com/golem15/sm-golem-plugin/internal/pgtest"
"git.golem15.com/golem15/sm-golem-plugin/models"
"git.golem15.com/golem15/summercms/modules/fetchguard"
"git.golem15.com/golem15/summercms/modules/lagoon"
"gorm.io/gorm"
)
// rt is a scripted provider transport.
type rt func(*http.Request) (*http.Response, error)
func (f rt) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func answer(status int, body string) *http.Response {
return &http.Response{StatusCode: status, Header: http.Header{"Content-Type": {"application/json"}}, Body: io.NopCloser(strings.NewReader(body))}
}
func with(t *testing.T, f func(r *http.Request, body []byte) *http.Response) context.Context {
t.Helper()
return fetchguard.WithTransport(context.Background(), rt(func(r *http.Request) (*http.Response, error) {
var body []byte
if r.Body != nil {
body, _ = io.ReadAll(r.Body)
}
resp := f(r, body)
if resp == nil {
return nil, errors.New("connection refused")
}
resp.Request = r
return resp, nil
}))
}
// freshModels empties golem15_golem_models and inserts rows in order
// (sort_order is the slice index).
func freshModels(t *testing.T, rows ...models.AiModel) *gorm.DB {
t.Helper()
db := pgtest.DB(t)
if err := db.Exec(`DELETE FROM golem15_golem_models`).Error; err != nil {
t.Fatal(err)
}
for i := range rows {
rows[i].SortOrder = i
if rows[i].Adapter == "" {
rows[i].Adapter = "openai"
}
if err := db.Create(&rows[i]).Error; err != nil {
t.Fatal(err)
}
}
return db
}
func svcFor(db *gorm.DB) *AIService {
return NewAIService(func() *gorm.DB { return db }, nil)
}
const pong = `{"choices":[{"message":{"content":"pong"},"finish_reason":"stop"}],"usage":{"total_tokens":3}}`
// TestAIServiceFailures pins AIService's PHP failure messages and the
// request each call sends.
func TestAIServiceFailures(t *testing.T) {
user := &ModelConfig{Adapter: "openai", APIKey: "sk-user-test", Model: "gpt-4o-mini"}
prompt := valueobjects.NewPrompt().AddUserMessage("ping")
t.Run("no model, no key", func(t *testing.T) {
s := NewAIService(nil, nil)
if r := s.Send(context.Background(), prompt, nil); r.Success || r.Error != "No AI model configured. Please add a model in Settings > AI." {
t.Fatalf("no model = %+v", r)
}
if r := s.Send(context.Background(), prompt, &ModelConfig{Adapter: "openai"}); r.Error != "API key is not configured for the selected model." {
t.Fatalf("no key = %+v", r)
}
if r := s.Ask(context.Background(), "hi", ""); r.Error != "No AI model configured. Please add a model in Settings > AI." {
t.Fatalf("ask = %+v", r)
}
})
t.Run("connection and answers", func(t *testing.T) {
s := NewAIService(nil, nil)
r := s.Send(with(t, func(*http.Request, []byte) *http.Response { return nil }), prompt, user)
if r.Error != "Failed to connect to AI service." || r.Err == nil {
t.Fatalf("refused = %+v", r)
}
r = s.Send(with(t, func(*http.Request, []byte) *http.Response { return answer(502, "<html>Bad gateway</html>") }), prompt, user)
if r.Error != "Invalid response from AI service: Syntax error" || r.Raw["raw"] != "<html>Bad gateway</html>" {
t.Fatalf("not json = %+v", r)
}
r = s.Send(with(t, func(*http.Request, []byte) *http.Response { return answer(200, "{\"x\":\"\xff\"}") }), prompt, user)
if r.Error != "Invalid response from AI service: Malformed UTF-8 characters, possibly incorrectly encoded" {
t.Fatalf("bad utf-8 = %+v", r)
}
r = s.Send(with(t, func(*http.Request, []byte) *http.Response { return answer(200, "") }), prompt, user)
if r.Error != "Invalid response from AI service: Syntax error" {
t.Fatalf("empty = %+v", r)
}
// The status is not judged: a 401 body is parsed.
r = s.Send(with(t, func(*http.Request, []byte) *http.Response {
return answer(401, `{"error":{"message":"Incorrect API key provided"}}`)
}), prompt, user)
if r.Error != "Incorrect API key provided" {
t.Fatalf("401 = %+v", r)
}
})
t.Run("model system prompt", func(t *testing.T) {
s := NewAIService(nil, nil)
cfg := *user
cfg.SystemPrompt = "Model default."
var got []string
ctx := with(t, func(r *http.Request, body []byte) *http.Response {
var m struct {
Messages []struct {
Role string `json:"role"`
Content string `json:"content"`
} `json:"messages"`
}
_ = json.Unmarshal(body, &m)
got = append(got, m.Messages[0].Role+":"+m.Messages[0].Content)
return answer(200, pong)
})
s.Send(ctx, prompt, &cfg)
s.Send(ctx, prompt.WithSystem("Caller."), &cfg)
if strings.Join(got, "|") != "system:Model default.|system:Caller." {
t.Fatalf("system prompts = %v", got)
}
})
t.Run("settings lookups", func(t *testing.T) {
db := freshModels(t,
models.AiModel{Name: "chat", Model: "gpt-4o", APIKey: lagoon.NewEncrypted("sk-admin-chat"), IsEnabled: true, IsDefault: true},
models.AiModel{Name: "claude", Adapter: "anthropic", Model: "claude-sonnet-4-6", APIKey: lagoon.NewEncrypted("sk-admin-claude"), IsEnabled: true},
)
s := svcFor(db)
var url string
ctx := with(t, func(r *http.Request, _ []byte) *http.Response {
url = r.URL.String()
if strings.Contains(url, "anthropic") {
return answer(200, `{"content":[{"type":"text","text":"hi"}]}`)
}
return answer(200, pong)
})
if r := s.Ask(ctx, "hi", "be brief"); !r.Success || url != "https://api.openai.com/v1/chat/completions" {
t.Fatalf("ask with the default model = %+v %s", r, url)
}
if r := s.SendWithModel(ctx, prompt, "claude"); !r.Success || url != "https://api.anthropic.com/v1/messages" {
t.Fatalf("by name = %+v %s", r, url)
}
if r := s.SendWithModel(ctx, prompt, "nope"); r.Error != "Model 'nope' not found in settings." {
t.Fatalf("unknown name = %+v", r)
}
if r := s.SendToImageModel(ctx, prompt); r.Error != "No image generation model configured." {
t.Fatalf("no image model = %+v", r)
}
if r := s.SendToVisionModel(ctx, prompt); r.Error != "No vision model configured." {
t.Fatalf("no vision model = %+v", r)
}
if r := s.GenerateImage(ctx, "a cat", "", ""); r.Error != `No image generation model configured. Enable a model with "generates_images" in Settings > AI.` {
t.Fatalf("generate without model = %+v", r)
}
if r := s.SendFilePath(ctx, "/nonexistent", "assistants", "", "", ""); r.Error != "No file model configured." {
t.Fatalf("no file model = %+v", r)
}
// A named model without a files endpoint refuses the upload before
// anything is read or sent.
if r := s.SendFilePath(ctx, "/nonexistent", "assistants", "chat", "", ""); r.Error != "Model 'chat' does not support file uploads." {
t.Fatalf("file upload refused = %+v", r)
}
if r := s.SendFile(ctx, strings.NewReader("x"), "a.txt", "text/plain", "missing"); r.Error != "Model 'missing' does not support file uploads." {
t.Fatalf("missing model upload = %+v", r)
}
})
t.Run("file upload", func(t *testing.T) {
db := freshModels(t,
models.AiModel{Name: "files", Model: "gpt-4o", APIKey: lagoon.NewEncrypted("sk-admin-files"), IsEnabled: true, HasFilesEndpoint: true, BaseURL: ptr("https://llm.example.test/v1")},
)
s := svcFor(db)
path := filepath.Join(t.TempDir(), "invoice.pdf")
if err := os.WriteFile(path, []byte("%PDF-1.4 parity"), 0o600); err != nil {
t.Fatal(err)
}
ctx := with(t, func(r *http.Request, body []byte) *http.Response {
if r.URL.String() != "https://llm.example.test/v1/files" || r.Header.Get("Authorization") != "Bearer sk-admin-files" {
t.Errorf("upload request %s %v", r.URL, r.Header)
}
mt, params, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil || mt != "multipart/form-data" {
t.Errorf("content type %q", r.Header.Get("Content-Type"))
return answer(400, "{}")
}
mr := multipart.NewReader(strings.NewReader(string(body)), params["boundary"])
var parts []string
for {
p, err := mr.NextPart()
if err != nil {
break
}
data, _ := io.ReadAll(p)
parts = append(parts, p.FormName()+"|"+p.FileName()+"|"+p.Header.Get("Content-Type")+"|"+string(data))
}
if strings.Join(parts, ";") != "purpose|||assistants;file|invoice.pdf|application/pdf|%PDF-1.4 parity" {
t.Errorf("parts = %v", parts)
}
return answer(200, `{"id":"file-abc123","object":"file"}`)
})
if r := s.SendFilePath(ctx, path, "assistants", "files", "application/pdf", ""); !r.Success || r.Content != "file-abc123" {
t.Fatalf("upload = %+v", r)
}
if r := s.SendFilePath(ctx, filepath.Join(t.TempDir(), "gone.pdf"), "assistants", "", "", ""); r.Error != "Internal server error" {
t.Fatalf("missing file = %+v", r)
}
noID := with(t, func(*http.Request, []byte) *http.Response { return answer(200, `{"object":"file"}`) })
if r := s.SendFile(noID, strings.NewReader("x"), "a.txt", "text/plain", ""); r.Error != "No file ID in response." {
t.Fatalf("no id = %+v", r)
}
apiErr := with(t, func(*http.Request, []byte) *http.Response {
return answer(400, `{"error":{"message":"purpose is invalid"}}`)
})
if r := s.SendFile(apiErr, strings.NewReader("x"), "a.txt", "text/plain", ""); r.Error != "purpose is invalid" {
t.Fatalf("api error = %+v", r)
}
down := with(t, func(*http.Request, []byte) *http.Response { return nil })
if r := s.SendFile(down, strings.NewReader("x"), "a.txt", "text/plain", ""); r.Error != "Failed to connect to files API at: https://llm.example.test/v1/files" {
t.Fatalf("down = %+v", r)
}
})
t.Run("generate image", func(t *testing.T) {
db := freshModels(t,
models.AiModel{Name: "dalle", Model: "dall-e-3", APIKey: lagoon.NewEncrypted("sk-admin-dalle"), IsEnabled: true, GeneratesImages: true},
)
s := svcFor(db)
returned := "https://oaidalleapiprodscus.blob.core.windows.net/private/img-1.png"
ctx := with(t, func(r *http.Request, body []byte) *http.Response {
var m map[string]any
_ = json.Unmarshal(body, &m)
if r.URL.String() != "https://api.openai.com/v1/images/generations" || m["model"] != "dall-e-3" || m["prompt"] != "a cat" || m["n"] != float64(1) || m["size"] != "1792x1024" || m["quality"] != "standard" {
t.Errorf("image request %s %v", r.URL, m)
}
return answer(200, `{"data":[{"url":"`+returned+`","revised_prompt":"a fluffy cat"}]}`)
})
r := s.GenerateImage(ctx, "a cat", "", "")
if !r.Success || r.Content != returned || r.Raw["revised_prompt"] != "a fluffy cat" {
t.Fatalf("generate = %+v", r)
}
// The returned URL is checked before anyone fetches it.
prev := security.DefaultResolver
security.DefaultResolver = staticResolver{"oaidalleapiprodscus.blob.core.windows.net": "20.60.40.1", "evil.example.com": "203.0.114.9"}
t.Cleanup(func() { security.DefaultResolver = prev })
if err := security.AssertSafeURL(context.Background(), r.Content, security.DefaultAllowedHosts); err != nil {
t.Fatalf("returned URL refused: %v", err)
}
evil := with(t, func(*http.Request, []byte) *http.Response {
return answer(200, `{"data":[{"url":"https://evil.example.com/x.png"}]}`)
})
r = s.GenerateImage(evil, "a cat", "1024x1024", "hd")
if err := security.AssertSafeURL(context.Background(), r.Content, security.DefaultAllowedHosts); err == nil || err.Error() != "Host not in allowlist: evil.example.com" {
t.Fatalf("a foreign returned URL must fail the guard: %v", err)
}
if r := s.GenerateImage(with(t, func(*http.Request, []byte) *http.Response { return answer(200, `{"data":[]}`) }), "x", "", ""); r.Error != "No image URL in response." {
t.Fatalf("no url = %+v", r)
}
if r := s.GenerateImage(with(t, func(*http.Request, []byte) *http.Response { return answer(200, `nope`) }), "x", "", ""); r.Error != "Invalid response: Syntax error" {
t.Fatalf("bad json = %+v", r)
}
if r := s.GenerateImage(with(t, func(*http.Request, []byte) *http.Response {
return answer(400, `{"error":{"message":"content policy"}}`)
}), "x", "", ""); r.Error != "content policy" {
t.Fatalf("api error = %+v", r)
}
if r := s.GenerateImage(with(t, func(*http.Request, []byte) *http.Response { return nil }), "x", "", ""); r.Error != "Failed to connect to image generation service." {
t.Fatalf("down = %+v", r)
}
freshModels(t, models.AiModel{Name: "claude", Adapter: "anthropic", Model: "claude", APIKey: lagoon.NewEncrypted("k"), IsEnabled: true, GeneratesImages: true})
if r := s.GenerateImage(ctx, "x", "", ""); r.Error != "The configured adapter does not support image generation." {
t.Fatalf("anthropic image = %+v", r)
}
})
}
type staticResolver map[string]string
func (s staticResolver) LookupIPAddr(_ context.Context, host string) ([]net.IPAddr, error) {
ip, ok := s[host]
if !ok {
return nil, &net.DNSError{Err: "no such host", Name: host, IsNotFound: true}
}
return []net.IPAddr{{IP: net.ParseIP(ip)}}, nil
}
func ptr(s string) *string { return &s }
// TestAIServiceStream delivers the content deltas of a server-sent event
// stream in order, as {"content":…} chunks, and stops at the end event.
func TestAIServiceStream(t *testing.T) {
s := NewAIService(nil, nil)
stream := func(status int, body string, check func(r *http.Request, payload map[string]any)) context.Context {
return fetchguard.WithTransport(context.Background(), rt(func(r *http.Request) (*http.Response, error) {
raw, _ := io.ReadAll(r.Body)
var m map[string]any
_ = json.Unmarshal(raw, &m)
check(r, m)
return &http.Response{StatusCode: status, Header: http.Header{"Content-Type": {"text/event-stream"}}, Body: io.NopCloser(strings.NewReader(body)), Request: r}, nil
}))
}
var chunks []string
collect := func(c string) { chunks = append(chunks, c) }
openai := "data: {\"choices\":[{\"delta\":{\"role\":\"assistant\"}}]}\n\n" +
"data: {\"choices\":[{\"delta\":{\"content\":\"Hel\"}}]}\n\n" +
"data: {\"choices\":[{\"delta\":{\"content\":\"lo \\\"you\\\"\"}}]}\r\n\r\n" +
"data: [DONE]\n\n" +
"data: {\"choices\":[{\"delta\":{\"content\":\"after done\"}}]}\n"
err := s.SendStream(stream(200, openai, func(r *http.Request, m map[string]any) {
if m["stream"] != true || r.Header.Get("Accept") != "text/event-stream" || r.Header.Get("Content-Type") != "application/json" {
t.Errorf("stream request %v %v", r.Header, m)
}
}), valueobjects.NewPrompt().AddUserMessage("hi"), collect, &ModelConfig{Adapter: "openai", APIKey: "k", Model: "gpt-4o"})
if err != nil {
t.Fatal(err)
}
if strings.Join(chunks, "") != `{"content":"Hel"}{"content":"lo \"you\""}` {
t.Fatalf("openai chunks = %v", chunks)
}
chunks = nil
anthropic := "event: message_start\ndata: {\"type\":\"message_start\"}\n\n" +
"event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"delta\":{\"type\":\"text_delta\",\"text\":\"Cze\"}}\n\n" +
"event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"delta\":{\"type\":\"text_delta\",\"text\":\"ść\"}}\n\n" +
"event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n" +
"data: {\"type\":\"content_block_delta\",\"delta\":{\"text\":\"late\"}}\n"
err = s.SendStream(stream(200, anthropic, func(r *http.Request, m map[string]any) {
if r.Header.Get("X-Api-Key") != "k" || m["stream"] != true {
t.Errorf("anthropic stream request %v", r.Header)
}
}), valueobjects.NewPrompt().AddUserMessage("hi"), collect, &ModelConfig{Adapter: "anthropic", APIKey: "k", Model: "claude"})
if err != nil {
t.Fatal(err)
}
if strings.Join(chunks, "") != `{"content":"Cze"}{"content":"ść"}` {
t.Fatalf("anthropic chunks = %v", chunks)
}
if err := s.SendStream(stream(401, `{"error":{"message":"bad key"}}`, func(*http.Request, map[string]any) {}), valueobjects.NewPrompt(), collect, &ModelConfig{APIKey: "k"}); err == nil || err.Error() != "HTTP 401 from AI service" {
t.Fatalf("401 = %v", err)
}
if err := s.SendStream(context.Background(), valueobjects.NewPrompt(), collect, nil); err == nil || err.Error() != "No AI model configured. Please add a model in Settings > AI." {
t.Fatalf("no model = %v", err)
}
if err := s.SendStream(context.Background(), valueobjects.NewPrompt(), collect, &ModelConfig{}); err == nil || err.Error() != "API key is not configured for the selected model." {
t.Fatalf("no key = %v", err)
}
}
// TestDefaultModelQuirk pins Settings::getDefaultModel: the first enabled
// default model, else the model at position 0 only when it is enabled.
func TestDefaultModelQuirk(t *testing.T) {
ctx := context.Background()
key := lagoon.NewEncrypted("sk-admin")
db := freshModels(t,
models.AiModel{Name: "zero", Model: "m0", APIKey: key},
models.AiModel{Name: "one", Model: "m1", APIKey: key, IsEnabled: true, AcceptsImages: true},
)
def, err := DefaultModel(ctx, db)
if err != nil || def != nil {
t.Fatalf("model 0 disabled, model 1 enabled without is_default: default = %+v, %v; want none", def, err)
}
all, _ := Models(ctx, db)
if len(all) != 1 || all[0].Name != "one" || all[0].Position != 1 || !all[0].Trusted || all[0].APIKey != "sk-admin" {
t.Fatalf("models = %+v", all)
}
if v, _ := VisionModel(ctx, db); v == nil || v.Name != "one" || !v.Trusted {
t.Fatalf("vision = %+v", v)
}
db = freshModels(t,
models.AiModel{Name: "zero", Model: "m0", APIKey: key},
models.AiModel{Name: "one", Model: "m1", APIKey: key, IsEnabled: true, IsDefault: true},
)
if def, _ := DefaultModel(ctx, db); def == nil || def.Name != "one" {
t.Fatalf("explicit default = %+v", def)
}
db = freshModels(t,
models.AiModel{Name: "zero", Model: "m0", APIKey: key, IsEnabled: true},
models.AiModel{Name: "one", Model: "m1", APIKey: key, IsEnabled: true},
)
if def, _ := DefaultModel(ctx, db); def == nil || def.Name != "zero" {
t.Fatalf("position 0 fallback = %+v", def)
}
// A disabled default never counts.
db = freshModels(t,
models.AiModel{Name: "zero", Model: "m0", APIKey: key, IsEnabled: true},
models.AiModel{Name: "one", Model: "m1", APIKey: key, IsDefault: true},
)
if def, _ := DefaultModel(ctx, db); def == nil || def.Name != "zero" {
t.Fatalf("disabled default = %+v", def)
}
db = freshModels(t,
models.AiModel{Name: "a", Model: "m", APIKey: key, IsEnabled: true, HasFilesEndpoint: true, BaseURL: ptr("https://x.test/v1"), SystemPrompt: ptr("sys"), MaxCompletionTokens: func() *int { n := 2048; return &n }()},
models.AiModel{Name: "b", Model: "m", APIKey: key, IsEnabled: true, GeneratesImages: true},
)
if m, _ := FileModel(ctx, db); m == nil || m.Name != "a" || m.BaseURL != "https://x.test/v1" || m.SystemPrompt != "sys" || m.MaxCompletionTokens != 2048 {
t.Fatalf("file model = %+v", m)
}
if m, _ := ImageModel(ctx, db); m == nil || m.Name != "b" {
t.Fatalf("image model = %+v", m)
}
if m, _ := ModelByName(ctx, db, "b"); m == nil || m.Name != "b" {
t.Fatalf("by name = %+v", m)
}
if m, _ := Models(ctx, nil); m != nil {
t.Fatal("no database means no models")
}
}
// TestAdminModelTrusted: an operator's model reaches a plain-http
// loopback endpoint (fetchguard TrustedMode); a user's config to a
// loopback endpoint is refused by the dial guard.
func TestAdminModelTrusted(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/v1/chat/completions" {
http.NotFound(w, r)
return
}
_, _ = io.WriteString(w, pong)
}))
defer srv.Close()
tls := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_, _ = io.WriteString(w, pong)
}))
defer tls.Close()
s := NewAIService(nil, nil)
prompt := valueobjects.NewPrompt().AddUserMessage("ping")
admin := &ModelConfig{Adapter: "openai", APIKey: "sk-admin", Model: "local", BaseURL: srv.URL + "/v1", Trusted: true}
if r := s.Send(context.Background(), prompt, admin); !r.Success || r.Content != "pong" {
t.Fatalf("admin model on the local network = %+v", r)
}
user := &ModelConfig{Adapter: "openai", APIKey: "sk-user", Model: "local", BaseURL: tls.URL + "/v1"}
r := s.Send(context.Background(), prompt, user)
var fe *fetchguard.Error
if r.Success || r.Error != "Failed to connect to AI service." || !errors.As(r.Err, &fe) || fe.Reason != fetchguard.ReasonPrivateIP {
t.Fatalf("user config to loopback = %+v (%v)", r, r.Err)
}
user.BaseURL = srv.URL + "/v1"
r = s.Send(context.Background(), prompt, user)
if !errors.As(r.Err, &fe) || fe.Reason != fetchguard.ReasonScheme {
t.Fatalf("user config over http = %+v (%v)", r, r.Err)
}
}

View File

@@ -23,6 +23,12 @@ type ModelConfig struct {
AcceptsImages bool `json:"-"`
GeneratesImages bool `json:"-"`
Trusted bool `json:"-"`
// Position is an admin model's place among all configured models
// (the WinterCMS repeater index); only the configs Models returns
// carry one.
Position int `json:"-"`
isDefault bool
}
// DefaultModelID is the model a config without one uses (PHP's

View File

@@ -0,0 +1,119 @@
package services
import (
"context"
"git.golem15.com/golem15/sm-golem-plugin/models"
"gorm.io/gorm"
)
// The functions below port the WinterCMS plugin's Settings model over the
// golem15_golem_models rows (in sort_order, then id order). Every config
// they return is an operator's model: Trusted is set. A nil db means no
// model is configured.
// Models is Settings::getModels: the enabled models, in order. Each keeps
// its Position among all models, enabled or not, as PHP's array_filter
// keeps the repeater keys.
func Models(ctx context.Context, db *gorm.DB) ([]*ModelConfig, error) {
if db == nil {
return nil, nil
}
var rows []models.AiModel
if err := db.WithContext(ctx).Order("sort_order, id").Find(&rows).Error; err != nil {
return nil, err
}
var out []*ModelConfig
for i := range rows {
if !rows[i].IsEnabled {
continue
}
c := modelConfigFrom(&rows[i])
c.Position = i
out = append(out, c)
}
return out, nil
}
// DefaultModel is Settings::getDefaultModel: the first enabled model
// marked default, else the model at position 0 when it is enabled. PHP's
// `$models[0] ?? null` reads the filtered array by key, so a disabled
// first model means no default even when later models are enabled.
func DefaultModel(ctx context.Context, db *gorm.DB) (*ModelConfig, error) {
all, err := Models(ctx, db)
if err != nil {
return nil, err
}
for _, m := range all {
if m.isDefault {
return m, nil
}
}
for _, m := range all {
if m.Position == 0 {
return m, nil
}
}
return nil, nil
}
// VisionModel is Settings::getVisionModel: the first enabled model that
// accepts images.
func VisionModel(ctx context.Context, db *gorm.DB) (*ModelConfig, error) {
return firstModel(ctx, db, func(m *ModelConfig) bool { return m.AcceptsImages })
}
// ImageModel is Settings::getImageModel: the first enabled model that
// generates images.
func ImageModel(ctx context.Context, db *gorm.DB) (*ModelConfig, error) {
return firstModel(ctx, db, func(m *ModelConfig) bool { return m.GeneratesImages })
}
// FileModel is Settings::getFileModel: the first enabled model with a
// files endpoint.
func FileModel(ctx context.Context, db *gorm.DB) (*ModelConfig, error) {
return firstModel(ctx, db, func(m *ModelConfig) bool { return m.HasFilesEndpoint })
}
// ModelByName is Settings::getModelByName: the first enabled model named
// name.
func ModelByName(ctx context.Context, db *gorm.DB, name string) (*ModelConfig, error) {
return firstModel(ctx, db, func(m *ModelConfig) bool { return m.Name == name })
}
func firstModel(ctx context.Context, db *gorm.DB, match func(*ModelConfig) bool) (*ModelConfig, error) {
all, err := Models(ctx, db)
if err != nil {
return nil, err
}
for _, m := range all {
if match(m) {
return m, nil
}
}
return nil, nil
}
func modelConfigFrom(row *models.AiModel) *ModelConfig {
c := &ModelConfig{
Name: row.Name,
Adapter: row.Adapter,
APIKey: row.APIKey.Reveal(),
Model: row.Model,
HasFilesEndpoint: row.HasFilesEndpoint,
AcceptsImages: row.AcceptsImages,
GeneratesImages: row.GeneratesImages,
Trusted: true,
isDefault: row.IsDefault,
}
if row.BaseURL != nil {
c.BaseURL = *row.BaseURL
}
if row.SystemPrompt != nil {
c.SystemPrompt = *row.SystemPrompt
}
if row.MaxCompletionTokens != nil {
c.MaxCompletionTokens = *row.MaxCompletionTokens
}
return c
}