@pi-in-go/pigpen-ollama-native 0.1.0

package/extensions/ollama-native/models_test.go

@@ -0,0 +1,223 @@
+package ollamanative
+
+import (
+	"context"
+	"encoding/json"
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+func TestNormalizeHost(t *testing.T) {
+	for in, want := range map[string]string{
+		"":                           "http://127.0.0.1:11434",
+		"   ":                        "http://127.0.0.1:11434",
+		"http://127.0.0.1:11434":     "http://127.0.0.1:11434",
+		"http://box:8080/":           "http://box:8080",
+		"box":                        "http://box:11434",
+		"box:8080":                   "http://box:8080",
+		":9000":                      "http://127.0.0.1:9000",
+		"https://ollama.example.com": "https://ollama.example.com:443",
+		"https://o.example.com:8443": "https://o.example.com:8443",
+		"http://box":                 "http://box:80",
+		"[::1]:11434":                "http://[::1]:11434",
+	} {
+		if got := normalizeHost(in); got != want {
+			t.Errorf("normalizeHost(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+// Registering the provider must not touch the network: pig starts without Ollama
+// running, and a model list is only fetched when the host asks for a refresh.
+func TestConstructionAndGetModelsMakeNoRequests(t *testing.T) {
+	f := newFake(t)
+	t.Setenv("OLLAMA_HOST", f.URL)
+	_ = Extension()
+	p := newProvider(newClient(f.URL))
+	models, err := p.GetModels()
+	if err != nil || len(models) != 0 {
+		t.Fatalf("GetModels before any refresh = %v, %v; want empty", models, err)
+	}
+	if f.count() != 0 {
+		t.Fatalf("requests at startup: %v", f.requests)
+	}
+}
+
+func TestDiscoverReadsModelsFromTagsAndShow(t *testing.T) {
+	f := newFake(t)
+	models, err := newClient(f.URL).discover(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// nomic-embed-text only embeds: it cannot chat, so it is not offered.
+	if len(models) != 2 {
+		t.Fatalf("models = %v", models)
+	}
+	g, q := models[0], models[1]
+	if g["id"] != "granite4.1:3b" || g["api"] != "ollama-native" || g["contextWindow"] != 131072 || g["reasoning"] != false {
+		t.Errorf("granite = %v", g)
+	}
+	if in := g["input"].([]string); len(in) != 1 || in[0] != "text" {
+		t.Errorf("granite input = %v", in)
+	}
+	if q["id"] != "qwen3:8b" || q["contextWindow"] != 40960 || q["reasoning"] != true {
+		t.Errorf("qwen3 = %v", q)
+	}
+	if in := q["input"].([]string); len(in) != 2 || in[1] != "image" {
+		t.Errorf("qwen3 input = %v", in)
+	}
+}
+
+// /api/show is best effort: a model it cannot describe still gets listed, with
+// plain defaults, so one bad model does not hide the rest.
+func TestDiscoverFallsBackToDefaultsWhenShowFails(t *testing.T) {
+	f := newFake(t)
+	f.tags = "tags_empty.json"
+	f.Server.Config.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/api/tags" {
+			w.Write([]byte(`{"models":[{"name":"mystery:1b"}]}`))
+			return
+		}
+		http.Error(w, `{"error":"boom"}`, 500)
+	})
+	models, err := newClient(f.URL).discover(context.Background())
+	if err != nil || len(models) != 1 {
+		t.Fatalf("models = %v, err = %v", models, err)
+	}
+	m := models[0]
+	if m["id"] != "mystery:1b" || m["contextWindow"] != defaultContextWindow || m["reasoning"] != false {
+		t.Errorf("defaults = %v", m)
+	}
+}
+
+func TestDiscoverEmptyListIsNotAnError(t *testing.T) {
+	f := newFake(t)
+	f.tags = "tags_empty.json"
+	models, err := newClient(f.URL).discover(context.Background())
+	if err != nil || len(models) != 0 {
+		t.Fatalf("models = %v, err = %v", models, err)
+	}
+}
+
+func TestDiscoverReportsOllamaNotRunning(t *testing.T) {
+	f := newFake(t)
+	url := f.URL
+	f.Close()
+	_, err := newClient(url).discover(context.Background())
+	if err == nil || !strings.Contains(err.Error(), "not reachable at "+url) || !strings.Contains(err.Error(), "OLLAMA_HOST") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestRefreshModelsPublishesAndSwapsTheCatalog(t *testing.T) {
+	f := newFake(t)
+	p := newProvider(newClient(f.URL))
+
+	// Offline: no request, catalog untouched.
+	if err := p.RefreshModels(sdk.RefreshModelsContext{AllowNetwork: false, Signal: context.Background(), Publish: func(sdk.ModelsPublication) (bool, error) { t.Fatal("published offline"); return false, nil }}); err != nil {
+		t.Fatal(err)
+	}
+	if f.count() != 0 {
+		t.Fatalf("offline refresh made requests: %v", f.requests)
+	}
+
+	published := 0
+	err := p.RefreshModels(sdk.RefreshModelsContext{AllowNetwork: true, Signal: context.Background(), Publish: func(pub sdk.ModelsPublication) (bool, error) {
+		published++
+		// The catalog is stored for the next start, which must not need Ollama.
+		var entry struct {
+			Models    []map[string]any `json:"models"`
+			CheckedAt float64          `json:"checkedAt"`
+		}
+		if err := json.Unmarshal(pub.Persist, &entry); err != nil || len(entry.Models) != 2 || entry.CheckedAt == 0 {
+			t.Errorf("persist = %s (%v)", pub.Persist, err)
+		}
+		if before, _ := p.GetModels(); len(before) != 0 {
+			t.Error("catalog changed before the host applied the update")
+		}
+		return true, pub.Update()
+	}})
+	if err != nil || published != 1 {
+		t.Fatalf("refresh err = %v, published = %d", err, published)
+	}
+	models, _ := p.GetModels()
+	if len(models) != 2 || models[0]["id"] != "granite4.1:3b" {
+		t.Fatalf("models after refresh = %v", models)
+	}
+}
+
+// A failed refresh keeps the last good catalog and reports the reason.
+func TestRefreshModelsKeepsLastCatalogWhenOllamaStops(t *testing.T) {
+	f := newFake(t)
+	c := newClient(f.URL)
+	p := newProvider(c)
+	publish := func(pub sdk.ModelsPublication) (bool, error) { return true, pub.Update() }
+	if err := p.RefreshModels(sdk.RefreshModelsContext{AllowNetwork: true, Signal: context.Background(), Publish: publish}); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	err := p.RefreshModels(sdk.RefreshModelsContext{AllowNetwork: true, Signal: context.Background(), Publish: publish})
+	if err == nil || !strings.Contains(err.Error(), "not reachable") {
+		t.Fatalf("err = %v", err)
+	}
+	if models, _ := p.GetModels(); len(models) != 2 {
+		t.Fatalf("catalog dropped: %v", models)
+	}
+}
+
+// PiG calls RefreshModels once without the network at start, handing back what
+// was stored. That is how `pig -p --model ollama-native/x` finds its model with
+// Ollama not even asked.
+func TestOfflinePassRestoresTheStoredCatalogWithoutRequests(t *testing.T) {
+	f := newFake(t)
+	// A first process refreshes and persists.
+	var stored json.RawMessage
+	first := newProvider(newClient(f.URL))
+	err := first.RefreshModels(sdk.RefreshModelsContext{AllowNetwork: true, Signal: context.Background(), Publish: func(pub sdk.ModelsPublication) (bool, error) {
+		stored = pub.Persist
+		return true, pub.Update()
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := f.count()
+
+	// A second process starts: PiG hands the stored entry back, as decoded JSON.
+	var entry map[string]any
+	if err := json.Unmarshal(stored, &entry); err != nil {
+		t.Fatal(err)
+	}
+	second := newProvider(newClient(f.URL))
+	applied := 0
+	err = second.RefreshModels(sdk.RefreshModelsContext{AllowNetwork: false, Stored: entry, Signal: context.Background(), Publish: func(pub sdk.ModelsPublication) (bool, error) {
+		applied++
+		if pub.Persist != nil {
+			t.Error("the offline pass must not rewrite the store")
+		}
+		return true, pub.Update()
+	}})
+	if err != nil || applied != 1 {
+		t.Fatalf("err = %v, applied = %d", err, applied)
+	}
+	if f.count() != before {
+		t.Fatalf("the offline pass made requests: %v", f.requests[before:])
+	}
+	models, _ := second.GetModels()
+	if len(models) != 2 || models[1]["id"] != "qwen3:8b" || models[1]["api"] != "ollama-native" {
+		t.Fatalf("restored = %v", models)
+	}
+}
+
+func TestOfflinePassIgnoresAMalformedStore(t *testing.T) {
+	p := newProvider(newClient("http://127.0.0.1:1"))
+	err := p.RefreshModels(sdk.RefreshModelsContext{AllowNetwork: false, Stored: map[string]any{"models": []any{"junk", map[string]any{"name": "no id"}, map[string]any{"id": "ok:1b", "api": "ollama-native"}}},
+		Publish: func(pub sdk.ModelsPublication) (bool, error) { return true, pub.Update() }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if models, _ := p.GetModels(); len(models) != 1 || models[0]["id"] != "ok:1b" {
+		t.Fatalf("models = %v", models)
+	}
+}

package/extensions/ollama-native/request.go

@@ -0,0 +1,184 @@
+package ollamanative
+
+import (
+	"slices"
+	"strings"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+// chatRequest turns PiG's transcript into an /api/chat body.
+//
+// The transcript is {"messages": [...]}. System messages also carry the tool
+// set: "toolsAdded" and "toolsRemoved" are changes, applied in order, so the
+// tools on offer are what is left after the last message.
+func chatRequest(model, transcript map[string]any, opts sdk.ProviderStreamOptions) map[string]any {
+	req := map[string]any{"model": model["id"], "stream": true}
+	var messages []map[string]any
+	var instructions []string
+	sections := map[string]string{}
+	var toolNames []string
+	tools := map[string]map[string]any{}
+
+	raw, _ := transcript["messages"].([]any)
+	for _, item := range raw {
+		m, _ := item.(map[string]any)
+		switch m["role"] {
+		case "system":
+			for _, t := range list(m["toolsRemoved"]) {
+				name, _ := t["name"].(string)
+				delete(tools, name)
+				toolNames = remove(toolNames, name)
+			}
+			for _, t := range list(m["toolsAdded"]) {
+				name, _ := t["name"].(string)
+				if _, seen := tools[name]; !seen {
+					toolNames = append(toolNames, name)
+				}
+				tools[name] = t
+			}
+			if text, _ := textAndImages(m["content"]); text != "" {
+				instructions = append(instructions, text)
+			}
+			if named, ok := m["sections"].(map[string]any); ok {
+				for name, value := range named {
+					if text, ok := value.(string); ok {
+						sections[name] = text
+					} else {
+						delete(sections, name) // null removes the section
+					}
+				}
+			}
+		case "user":
+			text, images := textAndImages(m["content"])
+			msg := map[string]any{"role": "user", "content": text}
+			if len(images) > 0 {
+				msg["images"] = images
+			}
+			messages = append(messages, msg)
+		case "assistant":
+			// Thinking is not sent back: Ollama's models are not trained on it as input.
+			var text []string
+			var calls []map[string]any
+			for _, b := range list(m["content"]) {
+				switch b["type"] {
+				case "text":
+					if s, _ := b["text"].(string); s != "" {
+						text = append(text, s)
+					}
+				case "toolCall":
+					args, _ := b["arguments"].(map[string]any)
+					if args == nil {
+						args = map[string]any{}
+					}
+					calls = append(calls, map[string]any{"function": map[string]any{"name": b["name"], "arguments": args}})
+				}
+			}
+			if len(text) == 0 && len(calls) == 0 {
+				continue // an aborted or failed turn that said nothing
+			}
+			msg := map[string]any{"role": "assistant", "content": strings.Join(text, "\n")}
+			if len(calls) > 0 {
+				msg["tool_calls"] = calls
+			}
+			messages = append(messages, msg)
+		case "toolResult":
+			text, images := textAndImages(m["content"])
+			msg := map[string]any{"role": "tool", "tool_name": m["toolName"], "content": text}
+			if len(images) > 0 {
+				msg["images"] = images
+			}
+			messages = append(messages, msg)
+		}
+	}
+	names := make([]string, 0, len(sections))
+	for name, text := range sections {
+		if text != "" {
+			names = append(names, name)
+		}
+	}
+	slices.Sort(names)
+	for _, name := range names {
+		instructions = append(instructions, sections[name])
+	}
+	if len(instructions) > 0 {
+		messages = append([]map[string]any{{"role": "system", "content": strings.Join(instructions, "\n\n")}}, messages...)
+	}
+	req["messages"] = messages
+
+	if len(toolNames) > 0 {
+		offered := make([]map[string]any, 0, len(toolNames))
+		for _, name := range toolNames {
+			t := tools[name]
+			params, _ := t["parameters"].(map[string]any)
+			if params == nil {
+				params = map[string]any{"type": "object", "properties": map[string]any{}}
+			}
+			offered = append(offered, map[string]any{"type": "function", "function": map[string]any{
+				"name": name, "description": t["description"], "parameters": params}})
+		}
+		req["tools"] = offered
+	}
+
+	options := map[string]any{}
+	if v, ok := opts.Values["temperature"].(float64); ok {
+		options["temperature"] = v
+	}
+	if v, ok := opts.Values["maxTokens"].(float64); ok && v > 0 {
+		options["num_predict"] = int(v)
+	}
+	if len(options) > 0 {
+		req["options"] = options
+	}
+	// Ollama refuses `think` for a model without the capability, so it is sent
+	// only to models the catalog marked as reasoning, and only when asked for.
+	if reasoning, _ := model["reasoning"].(bool); reasoning {
+		if on, ok := opts.Values["thinkingEnabled"].(bool); ok {
+			req["think"] = on
+		}
+	}
+	return req
+}
+
+func list(v any) []map[string]any {
+	items, _ := v.([]any)
+	out := make([]map[string]any, 0, len(items))
+	for _, item := range items {
+		if m, ok := item.(map[string]any); ok {
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
+func remove(names []string, name string) []string {
+	out := names[:0]
+	for _, n := range names {
+		if n != name {
+			out = append(out, n)
+		}
+	}
+	return out
+}
+
+// textAndImages reads message content, which is a string or a list of blocks.
+// Text blocks are joined with newlines; image blocks give their base64 data.
+func textAndImages(content any) (string, []string) {
+	if s, ok := content.(string); ok {
+		return s, nil
+	}
+	var text, images []string
+	for _, b := range list(content) {
+		switch b["type"] {
+		case "text":
+			if s, _ := b["text"].(string); s != "" {
+				text = append(text, s)
+			}
+		case "image":
+			if s, _ := b["data"].(string); s != "" {
+				images = append(images, s)
+			}
+		}
+	}
+	return strings.Join(text, "\n"), images
+}

package/extensions/ollama-native/testdata/chat_404.json

@@ -0,0 +1 @@
+{"error":"model 'nope:1b' not found"}

package/extensions/ollama-native/testdata/chat_length.ndjson

@@ -0,0 +1,2 @@
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:46:01.001Z","message":{"role":"assistant","content":"Long answer"},"done":false}
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:46:01.031Z","message":{"role":"assistant","content":""},"done_reason":"length","done":true,"prompt_eval_count":8,"eval_count":2}

package/extensions/ollama-native/testdata/chat_midstream_error.ndjson

@@ -0,0 +1,2 @@
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:44:01.001Z","message":{"role":"assistant","content":"Partial "},"done":false}
+{"error":"model runner has unexpectedly stopped, this may be due to resource limitations or an internal error, check ollama server logs for details"}

package/extensions/ollama-native/testdata/chat_text.ndjson

@@ -0,0 +1,4 @@
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:41:07.101Z","message":{"role":"assistant","content":"Hel"},"done":false}
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:41:07.131Z","message":{"role":"assistant","content":"lo"},"done":false}
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:41:07.161Z","message":{"role":"assistant","content":", world."},"done":false}
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:41:07.190Z","message":{"role":"assistant","content":""},"done_reason":"stop","done":true,"total_duration":812345678,"load_duration":4567890,"prompt_eval_count":26,"prompt_eval_duration":123456789,"eval_count":5,"eval_duration":456789012}

package/extensions/ollama-native/testdata/chat_thinking.ndjson

@@ -0,0 +1,4 @@
+{"model":"qwen3:8b","created_at":"2026-10-05T20:42:01.001Z","message":{"role":"assistant","content":"","thinking":"The user "},"done":false}
+{"model":"qwen3:8b","created_at":"2026-10-05T20:42:01.031Z","message":{"role":"assistant","content":"","thinking":"wants a greeting."},"done":false}
+{"model":"qwen3:8b","created_at":"2026-10-05T20:42:01.061Z","message":{"role":"assistant","content":"Hi!"},"done":false}
+{"model":"qwen3:8b","created_at":"2026-10-05T20:42:01.091Z","message":{"role":"assistant","content":""},"done_reason":"stop","done":true,"prompt_eval_count":12,"eval_count":9}

package/extensions/ollama-native/testdata/chat_toolcalls.ndjson

@@ -0,0 +1,4 @@
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:43:11.001Z","message":{"role":"assistant","content":"Checking."},"done":false}
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:43:11.031Z","message":{"role":"assistant","content":"","tool_calls":[{"function":{"name":"read","arguments":{"path":"README.md"}}}]},"done":false}
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:43:11.061Z","message":{"role":"assistant","content":"","tool_calls":[{"id":"call_server7","function":{"index":1,"name":"bash","arguments":{"command":"ls -la","timeout":10}}}]},"done":false}
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:43:11.091Z","message":{"role":"assistant","content":""},"done_reason":"stop","done":true,"prompt_eval_count":210,"eval_count":44}

package/extensions/ollama-native/testdata/chat_truncated.ndjson

@@ -0,0 +1 @@
+{"model":"granite4.1:3b","created_at":"2026-10-05T20:45:01.001Z","message":{"role":"assistant","content":"Cut o"},"done":false}

package/extensions/ollama-native/testdata/show_granite4.1_3b.json

@@ -0,0 +1 @@
+{"license":"Apache 2.0","modelfile":"# Modelfile","parameters":"stop \"<|end_of_text|>\"","template":"{{ .Prompt }}","details":{"parent_model":"","format":"gguf","family":"granite","families":["granite"],"parameter_size":"3.2B","quantization_level":"Q4_K_M"},"model_info":{"general.architecture":"granite","general.parameter_count":3188310016,"granite.context_length":131072},"capabilities":["completion","tools"]}

package/extensions/ollama-native/testdata/show_nomic-embed-text_latest.json

@@ -0,0 +1 @@
+{"details":{"family":"nomic-bert"},"model_info":{"general.architecture":"nomic-bert","nomic-bert.context_length":2048},"capabilities":["embedding"]}

package/extensions/ollama-native/testdata/show_qwen3_8b.json

@@ -0,0 +1 @@
+{"details":{"family":"qwen3","parameter_size":"8.2B"},"model_info":{"general.architecture":"qwen3","qwen3.context_length":40960},"capabilities":["completion","tools","thinking","vision"]}

package/extensions/ollama-native/testdata/tags.json

@@ -0,0 +1 @@
+{"models":[{"name":"granite4.1:3b","model":"granite4.1:3b","modified_at":"2026-09-30T10:12:44.1234567-06:00","size":2013458432,"digest":"b1c2d3e4f5a60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90","details":{"parent_model":"","format":"gguf","family":"granite","families":["granite"],"parameter_size":"3.2B","quantization_level":"Q4_K_M"}},{"name":"qwen3:8b","model":"qwen3:8b","modified_at":"2026-09-28T08:01:02.5-06:00","size":5225388032,"digest":"0a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90","details":{"parent_model":"","format":"gguf","family":"qwen3","families":["qwen3"],"parameter_size":"8.2B","quantization_level":"Q4_K_M"}},{"name":"nomic-embed-text:latest","model":"nomic-embed-text:latest","modified_at":"2026-09-01T08:01:02.5-06:00","size":274302450,"digest":"c0ffee00c0ffee00c0ffee00c0ffee00c0ffee00c0ffee00c0ffee00c0ffee00","details":{"parent_model":"","format":"gguf","family":"nomic-bert","families":["nomic-bert"],"parameter_size":"137M","quantization_level":"F16"}}]}

package/extensions/ollama-native/testdata/tags_empty.json

@@ -0,0 +1 @@
+{"models":[]}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@pi-in-go/pigpen-ollama-native",
+  "version": "0.1.0",
+  "description": "PiG model provider (Go extension) for Ollama's native /api/chat, with the model list read from the server",
+  "keywords": [
+    "pig-package",
+    "pigpen",
+    "extension"
+  ],
+  "license": "MIT",
+  "author": "Michael Kinsy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MichaelKinsy/pigpen.git",
+    "directory": "components/ollama-native"
+  },
+  "homepage": "https://github.com/MichaelKinsy/pigpen/tree/main/components/ollama-native#readme",
+  "bugs": {
+    "url": "https://github.com/MichaelKinsy/pigpen/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "extensions",
+    "README.md",
+    "CREDITS.md",
+    "LICENSE",
+    "provenance.json"
+  ],
+  "contributors": [
+    "Peder Munksgaard"
+  ],
+  "pi": {
+    "extensions": [
+      "extensions/ollama-native"
+    ]
+  }
+}

package/provenance.json

@@ -0,0 +1,7 @@
+{
+  "origin": "original",
+  "authors": ["Peder Munksgaard", "Michael Kinsy"],
+  "license": "MIT",
+  "licenseFile": "LICENSE",
+  "upstreams": []
+}