ai-sdk-ollama 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.2.0
+
+### Minor Changes
+
+- bf0905a: Fix streaming examples and improve TypeScript type checking
+  - Fix "Stream error: text part not found" by using textStream instead of fullStream for basic streaming
+  - Fix TypeScript errors in all examples (error handling, index access, undefined checks)
+  - Remove rootDir restriction in tsconfig.json to enable type checking for examples
+  - Fix tool call parameter handling and error messages
+  - Remove deprecated model capabilities and suggestions utilities
+  - Improve error handling with proper type checking throughout examples
+  - Update streaming examples to work with AI SDK v5 API changes
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),

package/README.md

@@ -151,7 +151,7 @@ const { text } = await generateText({
 
 ### Tool Calling Support
 
-Ollama supports tool calling with compatible models:
+Ollama supports tool calling with compatible models.
 
 ```typescript
 import { z } from 'zod';
@@ -162,7 +162,7 @@ const { text, toolCalls } = await generateText({
   tools: {
     getWeather: {
       description: 'Get current weather for a location',
-      parameters: z.object({
+      inputSchema: z.object({
         location: z.string().describe('City name'),
         unit: z.enum(['celsius', 'fahrenheit']).optional(),
       }),
@@ -175,28 +175,26 @@ const { text, toolCalls } = await generateText({
 });
 ```
 
-### Smart Model Intelligence
+> **Note on Tool Parameters**: Due to Zod version compatibility issues, tool schemas may not always convert properly. When this happens, Ollama may use different parameter names than defined in your schema. It's recommended to handle parameter variations in your tool's execute function (e.g., checking for both `location` and `city`).
 
-The provider automatically detects model capabilities and provides helpful suggestions:
+### Simple and Predictable
+
+The provider works the same way with any model - just try the features you need:
 
 ```typescript
-// The provider will automatically warn you if a model doesn't support tools
+// No capability checking required - just use any model
 const { text } = await generateText({
-  model: ollama('llama3'), // Older model without tool support
+  model: ollama('any-model'),
   prompt: 'What is the weather?',
   tools: {
     /* ... */
-  }, // This will throw a helpful error with suggestions
+  }, // If the model doesn't support tools, you'll get a clear error
 });
 
-// Get model recommendations for specific features
-import { suggestModelsForFeatures } from 'ai-sdk-ollama';
-
-const suggestions = suggestModelsForFeatures({
-  toolCalling: true,
-  performance: 'fast',
-});
-// Returns: [{ modelId: 'llama3.2', reason: 'Excellent tool calling...' }]
+// The provider is simple and predictable
+// - Try any feature with any model
+// - Get clear error messages if something doesn't work
+// - No hidden complexity or capability detection
 ```
 
 ## Advanced Features

package/dist/compatibility.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compatibility.test.d.ts.map

package/dist/compatibility.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.test.d.ts","sourceRoot":"","sources":["../src/compatibility.test.ts"],"names":[],"mappings":""}

package/dist/compatibility.test.js

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest';
+import { ollama } from './index';
+describe('OpenAI API Compatibility', () => {
+    describe('Provider Interface Compatibility', () => {
+        it('should implement standard provider pattern like OpenAI provider', () => {
+            // Test that our provider follows the same pattern as Vercel's OpenAI provider
+            expect(typeof ollama).toBe('function');
+            expect(typeof ollama.chat).toBe('function');
+            expect(typeof ollama.languageModel).toBe('function');
+            expect(typeof ollama.embedding).toBe('function');
+            expect(typeof ollama.textEmbedding).toBe('function');
+            expect(typeof ollama.textEmbeddingModel).toBe('function');
+        });
+        it('should create LanguageModelV2 compatible models', () => {
+            const model = ollama('llama3.2');
+            // Test LanguageModelV2 interface compliance
+            expect(model.specificationVersion).toBe('v2');
+            expect(typeof model.modelId).toBe('string');
+            expect(typeof model.provider).toBe('string');
+            expect(typeof model.doGenerate).toBe('function');
+            expect(typeof model.doStream).toBe('function');
+            // Test that model has expected properties (interface may have changed)
+            expect(typeof model.supportedUrls).toBe('object');
+        });
+        it('should create EmbeddingModelV2 compatible models', () => {
+            const model = ollama.embedding('nomic-embed-text');
+            // Test EmbeddingModelV2 interface compliance
+            expect(model.specificationVersion).toBe('v2');
+            expect(typeof model.modelId).toBe('string');
+            expect(typeof model.provider).toBe('string');
+            expect(typeof model.doEmbed).toBe('function');
+            // Test standard properties
+            expect(typeof model.maxEmbeddingsPerCall).toBe('number');
+            expect(typeof model.supportsParallelCalls).toBe('boolean');
+        });
+    });
+    describe('AI SDK Integration Compatibility', () => {
+        it('should work with generateText like OpenAI provider', () => {
+            const model = ollama('llama3.2');
+            // Test that model can be used with AI SDK functions
+            expect(typeof model.doGenerate).toBe('function');
+            expect(model.doGenerate.length).toBe(1); // Takes one parameter (options)
+        });
+        it('should work with streamText like OpenAI provider', () => {
+            const model = ollama('llama3.2');
+            expect(typeof model.doStream).toBe('function');
+            expect(model.doStream.length).toBe(1); // Takes one parameter (options)
+        });
+        it('should work with embed like OpenAI provider', () => {
+            const model = ollama.embedding('nomic-embed-text');
+            expect(() => {
+                // Test embedding interface compatibility
+                expect(typeof model.doEmbed).toBe('function');
+                expect(model.doEmbed.length).toBe(1); // Takes one parameter (options)
+            }).not.toThrow();
+        });
+    });
+    describe('Response Format Compatibility', () => {
+        it('should support JSON response format like OpenAI', () => {
+            const model = ollama('llama3.2');
+            // Test that our model exists and can be configured
+            expect(model.provider).toBe('ollama');
+            expect(model.modelId).toBe('llama3.2');
+        });
+        it('should support standard parameters like OpenAI', () => {
+            const model = ollama('llama3.2');
+            // Test basic model properties
+            expect(typeof model.doGenerate).toBe('function');
+            expect(typeof model.doStream).toBe('function');
+        });
+    });
+    describe('Error Handling Compatibility', () => {
+        it('should handle errors consistently with OpenAI provider', () => {
+            const model = ollama('llama3.2');
+            // Test that our error handling follows standard patterns
+            expect(model.provider).toBe('ollama');
+            expect(model.modelId).toBe('llama3.2');
+            // Models should have consistent error behavior
+            expect(() => {
+                // Test model creation with invalid parameters
+                ollama(''); // Empty model name
+            }).not.toThrow(); // Should create model, errors happen at runtime
+        });
+    });
+    describe('Provider Settings Compatibility', () => {
+        it('should support provider-specific settings like OpenAI', () => {
+            // Test custom settings similar to how OpenAI provider works
+            const modelWithSettings = ollama('llama3.2', {
+                options: {
+                    temperature: 0.8,
+                    num_ctx: 4096,
+                    top_k: 50,
+                },
+            });
+            expect(modelWithSettings.modelId).toBe('llama3.2');
+            expect(modelWithSettings.provider).toBe('ollama');
+        });
+        it('should support structured outputs setting', () => {
+            const modelWithStructuredOutputs = ollama('llama3.2', {
+                structuredOutputs: true,
+            });
+            expect(modelWithStructuredOutputs.provider).toBe('ollama');
+        });
+    });
+    describe('Embedding Model Compatibility', () => {
+        it('should handle embeddings consistently with OpenAI', () => {
+            const embeddingModel = ollama.embedding('nomic-embed-text');
+            expect(embeddingModel.modelId).toBe('nomic-embed-text');
+            expect(embeddingModel.provider).toBe('ollama');
+            expect(embeddingModel.specificationVersion).toBe('v2');
+            expect(typeof embeddingModel.maxEmbeddingsPerCall).toBe('number');
+            expect(embeddingModel.maxEmbeddingsPerCall).toBeGreaterThan(0);
+        });
+        it('should support embedding settings', () => {
+            const embeddingModel = ollama.embedding('nomic-embed-text', {
+                options: {
+                    num_thread: 8,
+                },
+            });
+            expect(embeddingModel.provider).toBe('ollama');
+        });
+    });
+});