ai-sdk-ollama 4.2.0 → 4.3.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 4.3.0
+
+### Minor Changes
+
+- 371f515: Track AI SDK 7.0.95 and open the provider up to custom Ollama clients.
+
+  - The `ai` peer range moves to `^7.0.95`, with `@ai-sdk/provider` and `@ai-sdk/provider-utils` updated to match.
+  - `OllamaClient` is a structural contract, so the official client, a maintained fork, or a custom adapter can be injected in both Node.js and browser builds. Streaming methods use the newly exported `AbortableStream` type.
+  - Per-request `AbortSignal`s are forwarded to the client, and an aborted request settles as a rejection across the reliability retry and fallback paths.
+  - Returned `message.thinking` is surfaced as AI SDK reasoning independently of the request's `think` setting, including on terminal stream chunks, and streamed text and reasoning blocks close symmetrically.
+  - Output usage carries the total token count Ollama reports and leaves the text/reasoning split unset, matching what the API provides.
+
 ## 4.2.0
 
 ### Minor Changes

package/README.md

@@ -740,7 +740,10 @@ const ollama = createOllama({ apiKey: process.env.OLLAMA_API_KEY });
 
 ### Using Existing Ollama Client
 
-You can also pass an existing Ollama client instance to reuse your configuration:
+You can also pass an existing Ollama client instance to reuse your configuration.
+The provider accepts the exported structural `OllamaClient` interface, so the
+official client, the maintained compatibility fork, or a custom adapter can be
+injected in Node.js and browser builds.
 
 ```typescript
 import { Ollama } from 'ollama';
@@ -756,13 +759,36 @@ const existingClient = new Ollama({
 const ollamaSdk = createOllama({ client: existingClient });
 
 // Use both clients as needed
-await ollamaRaw.list(); // Direct Ollama operations
+await existingClient.list(); // Direct Ollama operations
 const { text } = await generateText({
   model: ollamaSdk('llama3.2'),
   prompt: 'Hello!',
 });
 ```
 
+#### Custom client adapters
+
+`OllamaClient` is structural, so any object with the right shape works — no
+`Ollama` instance required. Streaming methods return an `AbortableStream`, an
+async iterable with an `abort()`:
+
+```typescript
+import type { AbortableStream, OllamaClient } from 'ai-sdk-ollama';
+import { createOllama } from 'ai-sdk-ollama';
+
+const client: OllamaClient = {
+  chat: myChat, // returns a ChatResponse, or an AbortableStream of them
+  embed: myEmbed,
+  webSearch: myWebSearch,
+  webFetch: myWebFetch,
+};
+
+const ollama = createOllama({ client });
+```
+
+Per-request cancellation is forwarded to the client as an `AbortSignal`, and an
+aborted request rejects rather than resolving with a retried or fallback result.
+
 ### Structured Output
 
 ```typescript
@@ -918,39 +944,38 @@ const { output: custom } = await generateText({
 
 ### Reasoning Support
 
-Some models like DeepSeek-R1 support reasoning (chain-of-thought) output. Enable this feature to see the model's thinking process:
+Use `think` to request reasoning generation from models that support it. Returned `message.thinking` is exposed as AI SDK reasoning, separately from final text, in both generation results and streams (including terminal chunks).
 
 ```typescript
 import { ollama } from 'ai-sdk-ollama';
 import { generateText } from 'ai';
 
 // Enable reasoning for models that support it (e.g., deepseek-r1:7b)
-const model = ollama('deepseek-r1:7b', { reasoning: true });
+const model = ollama('deepseek-r1:7b', { think: true });
 
 // Generate text with reasoning
-const { text } = await generateText({
+const { text, reasoningText } = await generateText({
   model,
   prompt:
     'Solve: If I have 3 boxes, each with 4 smaller boxes, and each smaller box has 5 items, how many items total?',
 });
 
 console.log('Answer:', text);
-// DeepSeek-R1 includes reasoning in the output with <think> tags:
-// <think>
-// First, I'll calculate the number of smaller boxes: 3 × 4 = 12
-// Then, the total items: 12 × 5 = 60
-// </think>
-// You have 60 items in total.
+console.log('Reasoning:', reasoningText);
 
 // Compare with reasoning disabled
-const modelNoReasoning = ollama('deepseek-r1:7b', { reasoning: false });
+const modelNoReasoning = ollama('deepseek-r1:7b', { think: false });
 const { text: noReasoningText } = await generateText({
   model: modelNoReasoning,
   prompt: 'Calculate 3 × 4 × 5',
 });
-// Output: 60 (without showing the thinking process)
+console.log('Answer:', noReasoningText);
 ```
 
+`think` controls the request, not filtering of the response. If the server returns thinking with `think` omitted or `false`, the adapter still preserves it as reasoning; it does not turn it into final text. If no thinking is returned, no reasoning content is added.
+
+Ollama supplies a combined output token count. The adapter preserves that total and the raw counters, but leaves the text/reasoning token breakdown unknown instead of attributing all output tokens to text.
+
 **Recommended Reasoning Models**:
 
 - `deepseek-r1:7b` - Balanced performance and reasoning capability (5GB)