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

package/CREDITS.md

@@ -0,0 +1,24 @@
+# Credits
+
+The idea, the first working extension and the choice of Ollama's native `/api/chat`
+endpoint (with the model list read from `/api/tags`) are by **Peder Munksgaard**
+(<peder1981@gmail.com>, GitHub @peder1981), contributed as pigpen pull request 3,
+"feat: add ollama-native extension with dynamic model listing". MIT.
+
+This Package is a rewrite of that extension for Pigpen's rules, and keeps its
+design and its `ollama-native/<model>` naming. What changed, and why:
+
+- **No network at startup.** The first version asked Ollama for its models while
+  the extension was being constructed, so a pig start waited for (or failed on) a
+  server that might not be running. Here the catalog is read when PiG refreshes
+  provider catalogs, stored, and restored from the store at the next start.
+- **More than the first tool call.** Ollama sends no tool-call ids and may send
+  several calls in one answer; every call is kept and gets an id.
+- **No 120-second cap on a whole request.** A cold model or a long answer outlasts
+  it; only connecting is bounded. Cancelling a turn cancels the request.
+- **The whole conversation goes to the model**: the system prompt, earlier tool
+  calls and their results, and images.
+- **Context window, thinking and image support** come from `/api/show` instead of
+  fixed numbers.
+- Tests with recorded-format fixtures, a README, and a `go.mod` pinned like the
+  other Pigpen modules.

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Michael Kinsy
+Copyright (c) 2026 Peder Munksgaard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# ollama-native Package
+
+A PiG model provider for [Ollama](https://ollama.com), through Ollama's **native**
+`/api/chat` endpoint (not the OpenAI-compatible `/v1` one), so tool calls, thinking
+and images use Ollama's own message format. Models appear as `ollama-native/<model>`.
+Go extension on PiG's public SDK; PiG builds it from source with a Go toolchain, and a
+Piglet Binary can fuse it. It was started by Peder Munksgaard; see [CREDITS.md](CREDITS.md).
+
+**It does nothing until you use it.** It is not part of any Piglet. It makes no network
+call at start-up, so pig starts the same with Ollama stopped. It asks Ollama for
+anything only when PiG refreshes provider catalogs, when you run `/ollama refresh`, or
+when you send a message to an `ollama-native` model.
+
+## Set up
+
+1. Install and start Ollama, and pull a model that supports tools:
+   `ollama pull granite4.1:3b` (or `qwen3:8b`, `llama3.2`, and so on).
+2. Install the Package from the Pigpen checkout root:
+
+   ```sh
+   pig package validate ./components/ollama-native
+   pig install ./components/ollama-native
+   ```
+
+   The local install references this checkout; keep it where it is and remove it with
+   `pig remove` using the same path. To try it without installing, load the source
+   directly: `pig -e ./components/ollama-native/extensions/ollama-native`.
+3. Load the model list once. Start `pig` interactively (PiG refreshes provider
+   catalogs when a session starts) or run `/ollama refresh`. The list is stored, so
+   later runs, including one-shot `pig -p`, find the models with Ollama not asked:
+
+   ```sh
+   pig --list-models ollama
+   pig --model ollama-native/granite4.1:3b -p "Say hello"
+   ```
+
+Run `/ollama refresh` again after `ollama pull` or `ollama rm`.
+
+## Configuration
+
+| Variable | Meaning | Default |
+| --- | --- | --- |
+| `OLLAMA_HOST` | Where Ollama listens: `host`, `host:port`, `:port` or a full `http(s)://` URL, as Ollama's own tools read it. | `http://127.0.0.1:11434` |
+| `OLLAMA_API_KEY` | Sent as `Authorization: Bearer` to a protected server (a proxy, Ollama's hosted service). A local Ollama needs none, and no key is ever sent unless this is set. | unset |
+
+`PI_OFFLINE=1` (or `--offline`) keeps PiG from refreshing catalogs on its own.
+
+## What it does
+
+- **Models** come from `/api/tags`; none is written down in the code. For each model
+  `/api/show` gives the context length and capabilities: `thinking` marks a reasoning
+  model, `vision` adds image input, and a model without `completion` (an embedding
+  model) is left out. When `/api/show` fails the model is still listed, with a 32,768
+  token context window.
+- **Chat** streams `/api/chat`: text, thinking, and any number of tool calls per answer.
+  Ollama sends no tool-call ids, so each call gets one. Tool results go back as `tool`
+  messages. Token counts come from Ollama's final message. Cancelling a turn closes the
+  request.
+- **Errors** say what to do: Ollama not reachable (start it with `ollama serve` or set
+  `OLLAMA_HOST`), a model that is not installed (`ollama pull <model>`), or the message
+  Ollama returned, including one that arrives in the middle of a stream.
+- `think` is sent only to models marked as reasoning, and only when a thinking level
+  is chosen.
+
+## Limits
+
+- Tool calls need a model that supports them. Ollama says so in the error when it does not.
+- PiG 0.4.0 gives a provider the system prompt's named sections as an unordered map,
+  so they are sent in name order, not PiG's authored order. The text is all there.
+- The catalog's `maxTokens` is 8,192 (or the context window if smaller); PiG sends a
+  limit only when you set one.
+- Only chat is covered: no embeddings, no model management (pull, delete).
+
+## Tests
+
+`extensions/ollama-native/testdata/` holds the Ollama responses the tests replay from a
+local HTTP server: `/api/tags`, `/api/show` and the `/api/chat` streams (text,
+thinking, tool calls, length stop, a mid-stream error, a truncated body, a 404). They
+are written to the wire format in Ollama's API documentation, not recorded from a live
+server. `go test ./...` in `extensions/ollama-native` runs them; nothing needs Ollama.
+A run against a real Ollama is the owner's check; it has not been done here.

package/extensions/ollama-native/chat.go

@@ -0,0 +1,241 @@
+package ollamanative
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+// stream sends one chat turn to Ollama's /api/chat and streams the answer back
+// as PiG model events. It returns at once; the work runs on its own goroutine,
+// and every failure becomes an error event on the stream.
+func (c *client) stream(model, transcript map[string]any, opts sdk.ProviderStreamOptions) (*sdk.ModelEventStream, error) {
+	out := sdk.CreateAssistantMessageEventStream()
+	ctx := opts.Signal
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	id, _ := model["id"].(string)
+	go c.run(ctx, out, id, chatRequest(model, transcript, opts), apiKey(opts))
+	return out, nil
+}
+
+func apiKey(opts sdk.ProviderStreamOptions) string {
+	key, _ := opts.Values["apiKey"].(string)
+	if key == localKey {
+		return ""
+	}
+	return key
+}
+
+// reply is the assistant message under construction. Each event carries a
+// snapshot of it, so later changes never reach an event already delivered.
+type reply struct {
+	model  string
+	blocks []map[string]any
+	usage  map[string]any
+	stop   string
+	now    func() time.Time
+}
+
+func (r *reply) snapshot() map[string]any {
+	blocks := make([]any, len(r.blocks))
+	for i, b := range r.blocks {
+		cp := make(map[string]any, len(b))
+		for k, v := range b {
+			cp[k] = v
+		}
+		blocks[i] = cp
+	}
+	msg := map[string]any{
+		"role": "assistant", "api": ProviderID, "provider": ProviderID, "model": r.model,
+		"content": blocks, "stopReason": r.stop, "timestamp": r.now().UnixMilli(),
+		"usage": r.usage,
+	}
+	return msg
+}
+
+func zeroUsage() map[string]any {
+	return map[string]any{"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0, "totalTokens": 0,
+		"cost": map[string]any{"input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0, "total": 0}}
+}
+
+// chunk is one line of Ollama's streamed /api/chat answer.
+type chunk struct {
+	Error   string `json:"error"`
+	Message struct {
+		Content   string `json:"content"`
+		Thinking  string `json:"thinking"`
+		ToolCalls []struct {
+			ID       string `json:"id"`
+			Function struct {
+				Name      string         `json:"name"`
+				Arguments map[string]any `json:"arguments"`
+			} `json:"function"`
+		} `json:"tool_calls"`
+	} `json:"message"`
+	Done            bool   `json:"done"`
+	DoneReason      string `json:"done_reason"`
+	PromptEvalCount int    `json:"prompt_eval_count"`
+	EvalCount       int    `json:"eval_count"`
+}
+
+func (c *client) run(ctx context.Context, out *sdk.ModelEventStream, model string, request map[string]any, key string) {
+	r := &reply{model: model, usage: zeroUsage(), stop: "stop", now: time.Now}
+	out.Push(map[string]any{"type": "start", "partial": r.snapshot()})
+
+	fail := func(err error) {
+		reason, text := "error", err.Error()
+		if ctx.Err() != nil {
+			reason, text = "aborted", "Request was aborted"
+		}
+		r.stop = reason
+		msg := r.snapshot()
+		msg["errorMessage"] = text
+		out.Push(map[string]any{"type": "error", "reason": reason, "error": msg})
+	}
+
+	base := c.baseURL()
+	resp, cancel, err := c.doChat(ctx, request, key)
+	if err != nil {
+		if isDialFailure(err) {
+			err = unreachable(base, err)
+		} else if ctx.Err() == nil {
+			err = fmt.Errorf("request to Ollama at %s failed: %w", base, rootCause(err))
+		}
+		fail(err)
+		return
+	}
+	defer cancel()
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		text := apiError(resp)
+		if resp.StatusCode == http.StatusNotFound && strings.Contains(strings.ToLower(text), "not found") {
+			fail(fmt.Errorf("Ollama has no model %q (%s). Install it with: ollama pull %s", model, text, model))
+			return
+		}
+		fail(fmt.Errorf("Ollama at %s answered %d: %s", base, resp.StatusCode, text))
+		return
+	}
+
+	var open string // "text" or "thinking": the block deltas are going into, if any
+	closeOpen := func() {
+		if open == "" {
+			return
+		}
+		last := r.blocks[len(r.blocks)-1]
+		key := "text"
+		if open == "thinking" {
+			key = "thinking"
+		}
+		out.Push(map[string]any{"type": open + "_end", "contentIndex": len(r.blocks) - 1, "content": last[key], "partial": r.snapshot()})
+		open = ""
+	}
+	delta := func(kind, text string) {
+		if text == "" {
+			return
+		}
+		if open != kind {
+			closeOpen()
+			r.blocks = append(r.blocks, map[string]any{"type": kind, kind: ""})
+			open = kind
+			out.Push(map[string]any{"type": kind + "_start", "contentIndex": len(r.blocks) - 1, "partial": r.snapshot()})
+		}
+		last := r.blocks[len(r.blocks)-1]
+		last[kind] = last[kind].(string) + text
+		out.Push(map[string]any{"type": kind + "_delta", "contentIndex": len(r.blocks) - 1, "delta": text, "partial": r.snapshot()})
+	}
+
+	toolCalls := 0
+	reader := bufio.NewReaderSize(resp.Body, 64<<10)
+	for {
+		line, readErr := reader.ReadBytes('\n')
+		if len(strings.TrimSpace(string(line))) > 0 {
+			var ch chunk
+			if err := json.Unmarshal(line, &ch); err != nil {
+				fail(fmt.Errorf("Ollama sent a line that is not JSON: %.80q", line))
+				return
+			}
+			if ch.Error != "" {
+				fail(errors.New(ch.Error))
+				return
+			}
+			delta("thinking", ch.Message.Thinking)
+			delta("text", ch.Message.Content)
+			for _, tc := range ch.Message.ToolCalls {
+				closeOpen()
+				id := tc.ID
+				if id == "" {
+					id = c.newID()
+				}
+				args := tc.Function.Arguments
+				if args == nil {
+					args = map[string]any{}
+				}
+				idx := len(r.blocks)
+				call := map[string]any{"type": "toolCall", "id": id, "name": tc.Function.Name, "arguments": map[string]any{}}
+				r.blocks = append(r.blocks, call)
+				out.Push(map[string]any{"type": "toolcall_start", "contentIndex": idx, "partial": r.snapshot()})
+				call["arguments"] = args
+				raw, _ := json.Marshal(args)
+				out.Push(map[string]any{"type": "toolcall_delta", "contentIndex": idx, "delta": string(raw), "partial": r.snapshot()})
+				out.Push(map[string]any{"type": "toolcall_end", "contentIndex": idx, "toolCall": call, "partial": r.snapshot()})
+				toolCalls++
+			}
+			if ch.Done {
+				closeOpen()
+				r.usage["input"], r.usage["output"] = ch.PromptEvalCount, ch.EvalCount
+				r.usage["totalTokens"] = ch.PromptEvalCount + ch.EvalCount
+				switch {
+				case toolCalls > 0:
+					r.stop = "toolUse"
+				case ch.DoneReason == "length":
+					r.stop = "length"
+				default:
+					r.stop = "stop"
+				}
+				out.Push(map[string]any{"type": "done", "reason": r.stop, "message": r.snapshot()})
+				return
+			}
+		}
+		if readErr != nil {
+			if errors.Is(readErr, io.EOF) {
+				fail(errors.New("The response stream from Ollama ended before it finished (no final message)."))
+			} else {
+				fail(fmt.Errorf("reading Ollama's response failed: %w", rootCause(readErr)))
+			}
+			return
+		}
+	}
+}
+
+func (c *client) doChat(ctx context.Context, request map[string]any, key string) (*http.Response, context.CancelFunc, error) {
+	body, err := json.Marshal(request)
+	if err != nil {
+		return nil, nil, err
+	}
+	ctx, cancel := context.WithCancel(ctx)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL()+"/api/chat", strings.NewReader(string(body)))
+	if err != nil {
+		cancel()
+		return nil, nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if key != "" {
+		req.Header.Set("Authorization", "Bearer "+key)
+	}
+	resp, err := c.http.Do(req)
+	if err != nil {
+		cancel()
+		return nil, nil, err
+	}
+	return resp, cancel, nil
+}

package/extensions/ollama-native/chat_test.go

@@ -0,0 +1,287 @@
+package ollamanative
+
+import (
+	"context"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+func run(t *testing.T, c *client, model, transcript map[string]any, opts sdk.ProviderStreamOptions) streamed {
+	t.Helper()
+	stream, err := c.stream(model, transcript, opts)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return collect(t, stream)
+}
+
+func content(msg map[string]any) []any { return msg["content"].([]any) }
+
+func TestStreamText(t *testing.T) {
+	f := newFake(t)
+	s := run(t, newClient(f.URL), graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{})
+	want := []string{"start", "text_start", "text_delta", "text_delta", "text_delta", "text_end", "done"}
+	if !reflect.DeepEqual(s.types(), want) {
+		t.Fatalf("events = %v", s.types())
+	}
+	done := s.terminal()
+	msg := done["message"].(map[string]any)
+	if done["reason"] != "stop" || msg["stopReason"] != "stop" {
+		t.Errorf("reason = %v / %v", done["reason"], msg["stopReason"])
+	}
+	if blocks := content(msg); len(blocks) != 1 || blocks[0].(map[string]any)["text"] != "Hello, world." {
+		t.Errorf("content = %v", msg["content"])
+	}
+	u := msg["usage"].(map[string]any)
+	if u["input"] != 26 || u["output"] != 5 || u["totalTokens"] != 31 {
+		t.Errorf("usage = %v", u)
+	}
+	if msg["api"] != "ollama-native" || msg["provider"] != "ollama-native" || msg["model"] != "granite4.1:3b" {
+		t.Errorf("identity = %v", msg)
+	}
+	// Deltas carry the right slice of text.
+	if s.events[2]["delta"] != "Hel" || s.events[4]["delta"] != ", world." {
+		t.Errorf("deltas = %v %v", s.events[2], s.events[4])
+	}
+	// The request is the native chat shape: streaming, one user message, no tools.
+	req := f.chats[0]
+	if req["model"] != "granite4.1:3b" || req["stream"] != true || req["tools"] != nil {
+		t.Errorf("request = %v", req)
+	}
+	if f.requests[0] != "POST /api/chat" {
+		t.Errorf("path = %v", f.requests)
+	}
+}
+
+func TestStreamThinkingThenText(t *testing.T) {
+	f := newFake(t)
+	f.chat = "chat_thinking.ndjson"
+	s := run(t, newClient(f.URL), map[string]any{"id": "qwen3:8b", "reasoning": true}, userTranscript("hi"), sdk.ProviderStreamOptions{})
+	want := []string{"start", "thinking_start", "thinking_delta", "thinking_delta", "thinking_end", "text_start", "text_delta", "text_end", "done"}
+	if !reflect.DeepEqual(s.types(), want) {
+		t.Fatalf("events = %v", s.types())
+	}
+	blocks := content(s.terminal()["message"].(map[string]any))
+	if len(blocks) != 2 || blocks[0].(map[string]any)["thinking"] != "The user wants a greeting." || blocks[1].(map[string]any)["text"] != "Hi!" {
+		t.Errorf("content = %v", blocks)
+	}
+}
+
+func TestStreamToolCalls(t *testing.T) {
+	f := newFake(t)
+	f.chat = "chat_toolcalls.ndjson"
+	s := run(t, newClient(f.URL), graniteModel, userTranscript("look around"), sdk.ProviderStreamOptions{})
+	want := []string{"start", "text_start", "text_delta", "text_end",
+		"toolcall_start", "toolcall_delta", "toolcall_end",
+		"toolcall_start", "toolcall_delta", "toolcall_end", "done"}
+	if !reflect.DeepEqual(s.types(), want) {
+		t.Fatalf("events = %v", s.types())
+	}
+	done := s.terminal()
+	msg := done["message"].(map[string]any)
+	if done["reason"] != "toolUse" || msg["stopReason"] != "toolUse" {
+		t.Errorf("stop = %v / %v", done["reason"], msg["stopReason"])
+	}
+	blocks := content(msg)
+	if len(blocks) != 3 {
+		t.Fatalf("content = %v", blocks)
+	}
+	first, second := blocks[1].(map[string]any), blocks[2].(map[string]any)
+	// Ollama sent no id for the first call: one is made up, and is unique.
+	if first["type"] != "toolCall" || first["name"] != "read" || first["id"] != "call_t1" {
+		t.Errorf("first = %v", first)
+	}
+	if !reflect.DeepEqual(first["arguments"], map[string]any{"path": "README.md"}) {
+		t.Errorf("first args = %v", first["arguments"])
+	}
+	// A server-sent id is kept.
+	if second["name"] != "bash" || second["id"] != "call_server7" || second["arguments"].(map[string]any)["timeout"] != float64(10) {
+		t.Errorf("second = %v", second)
+	}
+	end := s.events[6]
+	if end["contentIndex"] != 1 || end["toolCall"].(map[string]any)["name"] != "read" {
+		t.Errorf("toolcall_end = %v", end)
+	}
+}
+
+func TestStreamLengthStop(t *testing.T) {
+	f := newFake(t)
+	f.chat = "chat_length.ndjson"
+	s := run(t, newClient(f.URL), graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{})
+	if s.terminal()["reason"] != "length" {
+		t.Errorf("terminal = %v", s.terminal())
+	}
+}
+
+func errorMessage(s streamed) string {
+	e := s.terminal()
+	if e["type"] != "error" {
+		return "<not an error: " + e["type"].(string) + ">"
+	}
+	return e["error"].(map[string]any)["errorMessage"].(string)
+}
+
+func TestStreamMidStreamError(t *testing.T) {
+	f := newFake(t)
+	f.chat = "chat_midstream_error.ndjson"
+	s := run(t, newClient(f.URL), graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{})
+	if msg := errorMessage(s); !strings.Contains(msg, "model runner has unexpectedly stopped") {
+		t.Errorf("error = %q (events %v)", msg, s.types())
+	}
+	// What arrived before the failure is kept on the failed message.
+	partial := content(s.terminal()["error"].(map[string]any))
+	if len(partial) != 1 || partial[0].(map[string]any)["text"] != "Partial " {
+		t.Errorf("partial = %v", partial)
+	}
+	if s.terminal()["reason"] != "error" {
+		t.Errorf("reason = %v", s.terminal()["reason"])
+	}
+}
+
+func TestStreamTruncatedBodyIsAnError(t *testing.T) {
+	f := newFake(t)
+	f.chat = "chat_truncated.ndjson"
+	s := run(t, newClient(f.URL), graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{})
+	if msg := errorMessage(s); !strings.Contains(msg, "ended before") {
+		t.Errorf("error = %q", msg)
+	}
+}
+
+func TestStreamUnknownModelTellsYouToPull(t *testing.T) {
+	f := newFake(t)
+	f.chat, f.chatStatus = "chat_404.json", 404
+	s := run(t, newClient(f.URL), map[string]any{"id": "nope:1b"}, userTranscript("hi"), sdk.ProviderStreamOptions{})
+	msg := errorMessage(s)
+	if !strings.Contains(msg, "nope:1b") || !strings.Contains(msg, "ollama pull nope:1b") {
+		t.Errorf("error = %q", msg)
+	}
+}
+
+func TestStreamOllamaNotRunning(t *testing.T) {
+	f := newFake(t)
+	url := f.URL
+	f.Close()
+	s := run(t, newClient(url), graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{})
+	msg := errorMessage(s)
+	if !strings.Contains(msg, "Ollama is not reachable at "+url) || !strings.Contains(msg, "ollama serve") || !strings.Contains(msg, "OLLAMA_HOST") {
+		t.Errorf("error = %q", msg)
+	}
+}
+
+func TestStreamAbort(t *testing.T) {
+	f := newFake(t)
+	f.hold = make(chan struct{})
+	defer close(f.hold)
+	ctx, cancel := context.WithCancel(context.Background())
+	stream, err := newClient(f.URL).stream(graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{Signal: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	go func() { time.Sleep(100 * time.Millisecond); cancel() }()
+	s := collect(t, stream)
+	if s.terminal()["type"] != "error" || s.terminal()["reason"] != "aborted" {
+		t.Errorf("terminal = %v", s.terminal())
+	}
+}
+
+func TestChatRequestMapsTheTranscript(t *testing.T) {
+	transcript := map[string]any{"messages": []any{
+		map[string]any{"role": "system", "content": "Be brief.", "timestamp": 0,
+			"sections": map[string]any{"cwd": "<cwd>/work</cwd>", "docs": "<docs>old</docs>", "gone": "x"},
+			"toolsAdded": []any{
+				map[string]any{"name": "read", "description": "Read a file", "parameters": map[string]any{"type": "object", "properties": map[string]any{"path": map[string]any{"type": "string"}}}},
+				map[string]any{"name": "bash", "description": "Run", "parameters": map[string]any{"type": "object"}},
+			}},
+		map[string]any{"role": "system", "content": []any{map[string]any{"type": "text", "text": "Later note."}}, "timestamp": 1,
+			"sections":     map[string]any{"docs": "<docs>new</docs>", "gone": nil},
+			"toolsRemoved": []any{map[string]any{"name": "bash"}}},
+		map[string]any{"role": "user", "content": []any{
+			map[string]any{"type": "text", "text": "what is this?"},
+			map[string]any{"type": "image", "data": "aGVsbG8=", "mimeType": "image/png"}}},
+		map[string]any{"role": "assistant", "stopReason": "toolUse", "content": []any{
+			map[string]any{"type": "thinking", "thinking": "hmm"},
+			map[string]any{"type": "text", "text": "Reading."},
+			map[string]any{"type": "toolCall", "id": "call_1", "name": "read", "arguments": map[string]any{"path": "a.txt"}}}},
+		map[string]any{"role": "toolResult", "toolCallId": "call_1", "toolName": "read", "isError": false,
+			"content": []any{map[string]any{"type": "text", "text": "line one"}, map[string]any{"type": "text", "text": "line two"}}},
+		// An aborted turn that produced nothing is not replayed.
+		map[string]any{"role": "assistant", "stopReason": "aborted", "content": []any{}},
+		map[string]any{"role": "user", "content": "thanks"},
+	}}
+	opts := sdk.ProviderStreamOptions{Values: map[string]any{"temperature": 0.2, "maxTokens": float64(512)}}
+	req := chatRequest(map[string]any{"id": "granite4.1:3b"}, transcript, opts)
+
+	if req["model"] != "granite4.1:3b" || req["stream"] != true {
+		t.Fatalf("req = %v", req)
+	}
+	msgs := req["messages"].([]map[string]any)
+	roles := []string{}
+	for _, m := range msgs {
+		roles = append(roles, m["role"].(string))
+	}
+	if want := []string{"system", "user", "assistant", "tool", "user"}; !reflect.DeepEqual(roles, want) {
+		t.Fatalf("roles = %v", roles)
+	}
+	// One system message, as PiG itself renders it: the instructions, then the
+	// sections with later values replacing earlier ones and null removing one.
+	// PiG 0.4.0 hands a provider the sections as a map, so their authored order
+	// is lost: they come in name order.
+	if want := "Be brief.\n\nLater note.\n\n<cwd>/work</cwd>\n\n<docs>new</docs>"; msgs[0]["content"] != want {
+		t.Errorf("system = %q, want %q", msgs[0]["content"], want)
+	}
+	if msgs[1]["content"] != "what is this?" || !reflect.DeepEqual(msgs[1]["images"], []string{"aGVsbG8="}) {
+		t.Errorf("user = %v", msgs[1])
+	}
+	a := msgs[2]
+	calls := a["tool_calls"].([]map[string]any)
+	if a["content"] != "Reading." || a["thinking"] != nil || len(calls) != 1 {
+		t.Fatalf("assistant = %v", a)
+	}
+	fn := calls[0]["function"].(map[string]any)
+	if fn["name"] != "read" || !reflect.DeepEqual(fn["arguments"], map[string]any{"path": "a.txt"}) {
+		t.Errorf("call = %v", calls[0])
+	}
+	if msgs[3]["tool_name"] != "read" || msgs[3]["content"] != "line one\nline two" {
+		t.Errorf("tool result = %v", msgs[3])
+	}
+
+	// bash was removed by the second system message; only read is offered.
+	tools := req["tools"].([]map[string]any)
+	if len(tools) != 1 || tools[0]["type"] != "function" || tools[0]["function"].(map[string]any)["name"] != "read" {
+		t.Errorf("tools = %v", tools)
+	}
+	o := req["options"].(map[string]any)
+	if o["temperature"] != 0.2 || o["num_predict"] != 512 {
+		t.Errorf("options = %v", o)
+	}
+}
+
+func TestChatRequestThinkingOnlyForModelsThatThink(t *testing.T) {
+	on := sdk.ProviderStreamOptions{Values: map[string]any{"thinkingEnabled": true}}
+	if got := chatRequest(map[string]any{"id": "qwen3:8b", "reasoning": true}, userTranscript("x"), on)["think"]; got != true {
+		t.Errorf("think = %v", got)
+	}
+	// Ollama rejects `think` for a model that cannot think.
+	if _, has := chatRequest(map[string]any{"id": "granite4.1:3b", "reasoning": false}, userTranscript("x"), on)["think"]; has {
+		t.Error("think sent to a model without the thinking capability")
+	}
+	if _, has := chatRequest(map[string]any{"id": "qwen3:8b", "reasoning": true}, userTranscript("x"), sdk.ProviderStreamOptions{})["think"]; has {
+		t.Error("think sent although no level was asked for")
+	}
+}
+
+func TestAPIKeyOnlyWhenOneIsConfigured(t *testing.T) {
+	f := newFake(t)
+	var auth []string
+	inner := f.Server.Config.Handler
+	f.Server.Config.Handler = httpHandler(func(h map[string][]string) { auth = append(auth, strings.Join(h["Authorization"], "")) }, inner)
+	run(t, newClient(f.URL), graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{Values: map[string]any{"apiKey": "ollama"}})
+	run(t, newClient(f.URL), graniteModel, userTranscript("hi"), sdk.ProviderStreamOptions{Values: map[string]any{"apiKey": "sk-cloud"}})
+	if !reflect.DeepEqual(auth, []string{"", "Bearer sk-cloud"}) {
+		t.Errorf("Authorization headers = %q", auth)
+	}
+}