ollama-haskell 0.2.1.0 → 0.3.0.0

raw patch · 81 files changed

+4664/−4997 lines, 81 filesdep +QuickCheckdep +case-insensitivedep +conduitdep −base64-bytestringdep −directorydep −filepathdep ~aesondep ~basedep ~bytestringnew-component:exe:ollama-example-all-featuresnew-component:exe:ollama-example-basic-chatnew-component:exe:ollama-example-embeddingsnew-component:exe:ollama-example-model-managementnew-component:exe:ollama-example-streaming-chatnew-component:exe:ollama-example-structured-outputnew-component:exe:ollama-example-tool-callingPVP ok

version bump matches the API change (PVP)

Dependencies added: QuickCheck, case-insensitive, conduit, conduit-extra, hashable, resourcet, retry, tasty-bench, tasty-golden, tasty-quickcheck, unliftio-core

Dependencies removed: base64-bytestring, directory, filepath, scientific, silently

Dependency ranges changed: aeson, base, bytestring, containers, mtl, stm, tasty, text, time

API changes (from Hackage documentation)

Files

• CHANGELOG.md +27/−61
• README.md +136/−57
• bench/Main.hs +66/−0
• doc/COMPARISON.md +66/−0
• examples/AllFeatures.hs +187/−0
• examples/BasicChat.hs +21/−0
• examples/Embeddings.hs +12/−0
• examples/ModelManagement.hs +13/−0
• examples/StreamingChat.hs +18/−0
• examples/StructuredOutput.hs +28/−0
• examples/ToolCalling.hs +41/−0
• ollama-haskell.cabal +223/−97
• src/Data/Ollama/Blob.hs +0/−176
• src/Data/Ollama/Chat.hs +0/−295
• src/Data/Ollama/Common/Config.hs +0/−90
• src/Data/Ollama/Common/Error.hs +0/−65
• src/Data/Ollama/Common/SchemaBuilder.hs +0/−191
• src/Data/Ollama/Common/Types.hs +0/−464
• src/Data/Ollama/Common/Utils.hs +0/−303
• src/Data/Ollama/Conversation.hs +0/−186
• src/Data/Ollama/Copy.hs +0/−86
• src/Data/Ollama/Create.hs +0/−214
• src/Data/Ollama/Delete.hs +0/−71
• src/Data/Ollama/Embeddings.hs +0/−189
• src/Data/Ollama/Generate.hs +0/−248
• src/Data/Ollama/List.hs +0/−105
• src/Data/Ollama/Load.hs +0/−103
• src/Data/Ollama/Ps.hs +0/−109
• src/Data/Ollama/Pull.hs +0/−153
• src/Data/Ollama/Push.hs +0/−115
• src/Data/Ollama/Show.hs +0/−230
• src/Ollama.hs +160/−170
• src/Ollama/API/Blobs.hs +45/−0
• src/Ollama/API/Chat.hs +170/−0
• src/Ollama/API/Embed.hs +175/−0
• src/Ollama/API/Generate.hs +199/−0
• src/Ollama/API/Models.hs +171/−0
• src/Ollama/API/Models/Create.hs +165/−0
• src/Ollama/API/Models/Pull.hs +100/−0
• src/Ollama/API/Models/Push.hs +100/−0
• src/Ollama/API/Ps.hs +31/−0
• src/Ollama/API/Version.hs +30/−0
• src/Ollama/Client.hs +110/−0
• src/Ollama/Client/Config.hs +103/−0
• src/Ollama/Client/Internal.hs +276/−0
• src/Ollama/Conversation.hs +110/−0
• src/Ollama/Error.hs +65/−0
• src/Ollama/Streaming.hs +41/−0
• src/Ollama/Testing.hs +162/−0
• src/Ollama/Types.hs +38/−0
• src/Ollama/Types/Common.hs +152/−0
• src/Ollama/Types/Format.hs +38/−0
• src/Ollama/Types/Format/SchemaBuilder.hs +223/−0
• src/Ollama/Types/Message.hs +129/−0
• src/Ollama/Types/Model.hs +161/−0
• src/Ollama/Types/Options.hs +135/−0
• src/Ollama/Types/Tool.hs +148/−0
• test-integration/Main.hs +176/−0
• test/Main.hs +22/−37
• test/Test/Ollama/Blob.hs +0/−50
• test/Test/Ollama/Chat.hs +0/−307
• test/Test/Ollama/Common.hs +0/−91
• test/Test/Ollama/Copy.hs +0/−45
• test/Test/Ollama/Create.hs +0/−79
• test/Test/Ollama/Delete.hs +0/−42
• test/Test/Ollama/Embedding.hs +0/−53
• test/Test/Ollama/Generate.hs +0/−360
• test/Test/Ollama/Golden/Chat.hs +25/−0
• test/Test/Ollama/Golden/Embed.hs +16/−0
• test/Test/Ollama/Golden/Generate.hs +16/−0
• test/Test/Ollama/Golden/Models.hs +16/−0
• test/Test/Ollama/List.hs +0/−41
• test/Test/Ollama/Load.hs +0/−53
• test/Test/Ollama/Property/Arbitrary.hs +51/−0
• test/Test/Ollama/Property/Roundtrip.hs +34/−0
• test/Test/Ollama/Show.hs +0/−61
• test/Test/Ollama/Unit/Config.hs +19/−0
• test/Test/Ollama/Unit/Error.hs +22/−0
• test/Test/Ollama/Unit/SchemaBuilder.hs +33/−0
• test/Test/Ollama/Unit/Testing.hs +87/−0
• test/Test/Ollama/Unit/Types.hs +72/−0

@@ -1,67 +1,33 @@-# Revision history for ollama-haskell--## Unreleased--## 0.2.1.0 -- 2025-09-24--* Added blob module for managing binary large objects (GGUF files/safetensors).-* Breaking: Added `dimensions` option in embeddings for specifying embedding dimensions.-* Breaking: Added `doneReason` field in chat and generate responses.-* Improved test suite with more comprehensive test cases.-* Added `onComplete` callback function in stream handlers for better streaming control.-* Breaking: Standardized field names across the library for consistency.-* Applied fourmolu code formatting and added hlint for better code quality.--## 0.2.0.0 -- 2025-06-05--* Added stack matrix to ensure lib is buildable from lts-19.33-* Made parameters & template fields optional in `ShowModelResponse`.-* Added extra parameters fields in `ModelInfo`.-* Added strict annotations for all fields.-* Fixed ToJSON instance for delete model request body.-* Removed duplicate code by using unified `withOllamaRequest` function for all API calls.-* Added unified config type `OllamaConfig` to hold common configuration options.-* Added validation for generate and chat functions to ensure required fields are present.-* Added convience functions for generating Message and ToolCall types.-* Added thinking field for chat and generate function.-* Added ModelOptions type to encapsulate model options.-* Added get ollama version function.-* Added Common Manager, Callback functions and retry option in OllamaConfig.-* Fixed tool_calls.-* Added MonadIO versions of api functions.-* Added more comprehensive error handling for API calls.-* Added more comprehensive test cases for all functions.-* Added schema builder for passing json format for structured output.--## 0.1.3.0 -- 2025-03-25--* Added options, tools and tool_calls fields in chat and generate.-* Exported EmbeddingResponse.-* Added Format argument in chat and generate function for structured output.--## 0.1.2.0 -- 2024-11-20--* Added hostUrl and responseTimeOut options in generate function.-* Added hostUrl and responseTimeOut options in chat function.--## 0.1.1.3 -- 2024-11-08--* Increase response timeout to 15 minutes-* Added encodeImage utility function that converts image filePath to base64 image data.-* Added generateJson and chatJson. High level function to return response in Haskell type.--## 0.1.0.3 -- 2024-11-05--* Moving to stack instead of cabal.+# Changelog -## 0.1.0.2 -- 2024-10-18+All notable changes to `ollama-haskell` will be documented in this file.+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),+and this project adheres to [PVP (Haskell Package Versioning Policy)](https://pvp.haskell.org/). -* Increased response timeout time for chat function. +--- -## 0.1.0.1 -- 2024-10-18+## [0.3.0.0] - 2026-08-04 -* Renaming Lib.hs to OllamaExamples.hs as it was conflicting `Lib.hs` name+### Added+- **`OllamaClient` Core**: Thread-safe client handle with automatic connection manager lifecycle management (`newClient`, `defaultClient`, `clientFromEnv`, `withClient`).+- **First-Class Streaming Pipeline**: `conduit`-based response streaming (`chatStream`, `generateStream`, `pullStream`, `pushStream`, `createModelStream`).+- **Stream Combinators**: `collectStream` and `foldStream` in `Ollama.Streaming`.+- **Structured Output DSL**: Type-safe `SchemaBuilder` DSL in `Ollama.Types.Format.SchemaBuilder` (`|+`, `|++`, `|!`, `|!!`) for constructing JSON Schemas.+- **Thinking / Reasoning Models Support**: `Think` ADT (`ThinkEnabled`, `ThinkDisabled`, `ThinkLevel`) and `ThinkingLevel` (`ThinkLow`, `ThinkMedium`, `ThinkHigh`, `ThinkMax`) supporting models such as `qwen3.5` and `deepseek-r1`.+- **Function / Tool Calling**: `Tool`, `FunctionDef`, `FunctionParameters`, `ToolCall`, and `toolResultMessage` helper.+- **Environment Resolution**: Automatic `OLLAMA_HOST` parsing and normalization in `clientFromEnv` supporting `host:port`, `http://host:port`, and bare `host`.+- **Authorization & Headers**: Support for `OLLAMA_API_KEY` bearer tokens and custom `configHeaders`.+- **Configurable Resilience**: `RetryPolicy` ADT (`NoRetry`, `ConstantRetry`, `ExponentialRetry`), lifecycle callbacks (`configOnStart`, `configOnSuccess`, `configOnError`), and structured logger `configLogger`.+- **Token Throughput Metrics**: Metrics helpers `chatEvalTokensPerSecond`, `chatPromptEvalTokensPerSecond`, `evalTokensPerSecond`, `promptEvalTokensPerSecond`, `tokensPerSecond`.+- **Testing Infrastructure**: Built-in mock testing module `Ollama.Testing` (`newMockClient`, `withMockClient`, `mockGenerateResponse`, `mockChatResponse`, `mockEmbedResponse`, `mockListModelsResponse`).+- **Conversation Store**: Transactional STM-backed `InMemoryStore` and `ConversationStore` typeclass.+- **New API Endpoints**: `Ollama.API.Embed` (`/api/embed`), `Ollama.API.Blobs` (`/api/blobs`), `Ollama.API.Ps` (`/api/ps`), `Ollama.API.Version` (`/api/version`).+- **Benchmark Suite**: Criterion/tasty-bench suite in `bench/Main.hs` measuring serialization and throughput. -## 0.1.0.0 -- YYYY-mm-dd+### Changed+- **MonadIO / MonadUnliftIO Polymorphism**: All API functions use `MonadIO m =>` / `MonadUnliftIO m =>` signatures instead of dual `*M` variants.+- **Typed Newtypes**: `ModelName`, `Digest`, `Base64Image`, `Duration`, `Version` replace primitive string types.+- **Unified Error Type**: `OllamaError` sum type with structured constructors and `Exception` instance. -* First version. Released on an unsuspecting world.+### Deprecated+- `embeddings` endpoint (`/api/embeddings`) marked deprecated in favor of `/api/embed`.

@@ -1,102 +1,181 @@-# 🦙 Ollama Haskell+# ollama-haskell -<div style="text-align: center;">-<img src="./examples/ollama_haskell.png" alt="logo image" height="200"/>-</div>+[![Hackage](https://img.shields.io/hackage/v/ollama-haskell.svg)](https://hackage.haskell.org/package/ollama-haskell)+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE) -**`ollama-haskell`** is an unofficial Haskell client for [Ollama](https://ollama.com), inspired by [`ollama-python`](https://github.com/ollama/ollama-python). It enables interaction with locally running LLMs through the Ollama HTTP API — directly from Haskell.+Industry-grade, feature-complete, modern Haskell client library for the [Ollama](https://ollama.com) local LLM engine. +## Features++- **Client-Centric Architecture**: Thread-safe `OllamaClient` handle with connection pooling and resource management (`newClient`, `defaultClient`, `clientFromEnv`, `withClient`).+- **First-Class Streaming**: `conduit`-based response streaming (`chatStream`, `generateStream`, `pullStream`, `pushStream`, `createModelStream`).+- **Complete API Surface**: Text generation, chat completions, vector embeddings, model management (list, show, copy, delete, pull, push, create), and system endpoints.+- **Structured Outputs**: Powerful `SchemaBuilder` DSL (`|+`, `|++`, `|!`, `|!!`) for type-safe JSON Schema structured responses.+- **Function / Tool Calling**: Full support for tool definitions (`Tool`), tool calls (`ToolCall`), and execution results (`toolResultMessage`).+- **Thinking Models Support**: Native support for reasoning models (`qwen3.5`, `deepseek-r1`) with `Think` / `ThinkingLevel` types.+- **Environment & Auth Integration**: Robust URL normalization for `OLLAMA_HOST` and bearer token support for `OLLAMA_API_KEY`.+- **Configurable Resilience**: Flexible retry policies (`NoRetry`, `ConstantRetry`, `ExponentialRetry`), lifecycle callbacks, and structured logging.+- **Conversation Store**: Transactional STM-backed `InMemoryStore` and `ConversationStore` typeclass for managing multi-turn chat sessions.+- **SDK Comparison Matrix**: Detailed feature comparison against Python, JS/TS, and Go SDKs in [doc/COMPARISON.md](doc/COMPARISON.md).+ --- -## ✨ Features+## Installation -* 💬 Chat with models-* ✍️ Text generation (with streaming)-* ✅ Chat with structured messages and tools-* 🧠 Embeddings-* 🧰 Model management (list, pull, push, show, delete)-* 🗃️ In-memory conversation history-* ⚙️ Configurable timeouts, retries, streaming handlers+Add `ollama-haskell` to your `.cabal` file: +```cabal+build-depends:+    base >= 4.17 && < 5+  , ollama-haskell >= 0.3.0.0+```++Or using Stack in `package.yaml`:++```yaml+dependencies:+  - ollama-haskell >= 0.3.0.0+```+ --- -## ⚡ Quick Example+## Quick Start (5 Lines)  ```haskell-{-# LANGUAGE OverloadedStrings #-}-module Main where--import Data.Ollama.Generate-import qualified Data.Text.IO as T+import Data.List.NonEmpty (NonEmpty ((:|)))+import Data.Text.IO qualified as TIO+import Ollama  main :: IO () main = do-  let ops =-        defaultGenerateOps-          { modelName = "gemma3"-          , prompt = "What is the meaning of life?"-          }-  eRes <- generate ops Nothing-  case eRes of-    Left err -> putStrLn $ "Something went wrong: " ++ show err-    Right r -> do-      putStr "LLM response: "-      T.putStrLn (genResponse r)+  client <- defaultClient+  res <- chat client $ chatRequest "qwen3.5:2b" (userMessage "Why is the sky blue?" :| [])+  case res of+    Left err   -> print err+    Right resp -> mapM_ (TIO.putStrLn . messageContent) (crMessage resp) ```  --- -## 📦 Installation+## Streaming Responses with Conduit -Add to your `.cabal` file:+Stream LLM responses token-by-token as they generate: -```cabal-build-depends:-  base >=4.7 && <5,-  ollama-haskell-```+```haskell+import Data.List.NonEmpty (NonEmpty ((:|)))+import Data.Text.IO qualified as TIO+import Ollama -Or use with `stack`/`nix-shell`.+main :: IO ()+main = do+  client <- defaultClient+  let req = chatRequest "qwen3.5:2b" (userMessage "Count from 1 to 5." :| [])+  +  -- Stream chunks directly into stdout or collect them+  chunks <- collectStream (chatStream client req)+  mapM_ (TIO.putStr . maybe "" messageContent . crMessage) chunks+  putStrLn ""+```  --- -## 📚 More Examples+## Function & Tool Calling -See [`examples/OllamaExamples.hs`](examples/OllamaExamples.hs) for:+Define function signatures and let the LLM execute structured tool calls: -* Chat with conversation memory-* Structured JSON output-* Embeddings-* Tool/function calling-* Multimodal input-* Streaming and non-streaming variants+```haskell+import Data.List.NonEmpty (NonEmpty ((:|)))+import Ollama +calculatorTool :: Tool+calculatorTool = Tool "function" $ FunctionDef+  { fnName = "add"+  , fnDescription = Just "Add two numbers"+  , fnParameters = Just (FunctionParameters "object" Nothing (Just ["a", "b"]) Nothing Nothing Nothing)+  , fnStrict = Just True+  }++main :: IO ()+main = do+  client <- defaultClient+  let req = (chatRequest "qwen3.5:2b" (userMessage "What is 40 + 2?" :| []))+        { chatTools = Just [calculatorTool] }+  res <- chat client req+  case res of+    Left err   -> print err+    Right resp -> print (crMessage resp)+```+ --- -## 🛠 Prerequisite+## Structured Outputs (JSON Schema DSL) -Make sure you have [Ollama installed and running locally](https://ollama.com/download). Run `ollama pull llama3` to download a model.+Enforce structured JSON output formats using `SchemaBuilder`: +```haskell+import Data.Text.IO qualified as TIO+import Ollama+import Ollama.Types.Format.SchemaBuilder++personSchema :: Schema+personSchema = buildSchema $ emptyObject+  |+ ("name", JString)+  |+ ("age", JInteger)+  |! "name"++main :: IO ()+main = do+  client <- defaultClient+  let req = (generateRequest "qwen3.5:2b" "Generate a person profile.")+        { genFormat = Just (SchemaFormat personSchema) }+  res <- generate client req+  case res of+    Left err   -> print err+    Right resp -> TIO.putStrLn (grResponse resp)+```+ --- -## 🧪 Dev & Nix Support+## Environment Variables & Configuration -Use Nix:+Construct a client using environment variables (`OLLAMA_HOST`, `OLLAMA_API_KEY`): -```bash-nix-shell+```haskell+main :: IO ()+main = do+  client <- clientFromEnv+  -- Automatically connects to OLLAMA_HOST with optional Authorization: Bearer header+  ... ``` -This will install `stack` and Ollama.+Or configure custom retry policies and loggers: +```haskell+customConfig :: OllamaClientConfig+customConfig = defaultConfig+  { configBaseUrl = "http://my-ollama-server:11434"+  , configTimeout = 120+  , configRetry   = ExponentialRetry 3 1 -- 3 retries with exponential backoff+  , configLogger  = Just (\level msg -> putStrLn $ "[" <> show level <> "] " <> show msg)+  }++main :: IO ()+main = withClient customConfig $ \client -> do+  ...+```+ --- -## 👨‍💻 Author+## Documentation & SDK Comparison -Created and maintained by [@tusharad](https://github.com/tusharad). PRs and feedback are welcome!+- [doc/COMPARISON.md](doc/COMPARISON.md) — SDK Feature Matrix comparing `ollama-haskell` with Python, JS/TS, and Go SDKs.+- [ARCHITECTURE.md](ARCHITECTURE.md) — Detailed internal module design and extension guide.+- [CONTRIBUTING.md](CONTRIBUTING.md) — Development setup, testing guidelines, and code style.+- [CHANGELOG.md](CHANGELOG.md) — Release notes and changelog.+- [Hackage Documentation](https://hackage.haskell.org/package/ollama-haskell) — Full Haddock reference.  --- -## 🤝 Contributing+## License -Have ideas or improvements? Feel free to [open an issue](https://github.com/tusharad/ollama-haskell/issues) or submit a PR!+MIT © 2024–2026 Tushar Adhatrao

@@ -0,0 +1,66 @@+{-# LANGUAGE OverloadedStrings #-}++{- |+Module      : Main+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Benchmark suite for Ollama client JSON serialization and URL normalization operations.++@since 1.0.0.0+-}+module Main (main) where++import Data.Aeson (decode, encode)+import Data.ByteString.Lazy (ByteString)+import Data.List.NonEmpty (NonEmpty ((:|)))+import Ollama.API.Chat (ChatRequest, ChatResponse, chatRequest)+import Ollama.API.Embed (EmbedRequest, EmbedResponse, embedRequest)+import Ollama.API.Generate (GenerateRequest, GenerateResponse, generateRequest)+import Ollama.API.Models.Create (CreateRequest, defaultCreateRequest)+import Ollama.Testing (mockChatResponse, mockEmbedResponse, mockGenerateResponse)+import Ollama.Types.Common (ModelName (..))+import Ollama.Types.Message (userMessage)+import Test.Tasty.Bench (bench, bgroup, defaultMain, whnf)++main :: IO ()+main =+  defaultMain+    [ bgroup+        "JSON Encoding"+        [ bench "GenerateRequest" $ whnf encode sampleGenerateRequest+        , bench "ChatRequest" $ whnf encode sampleChatRequest+        , bench "EmbedRequest" $ whnf encode sampleEmbedRequest+        , bench "CreateRequest" $ whnf encode sampleCreateRequest+        ]+    , bgroup+        "JSON Decoding"+        [ bench "GenerateResponse" $ whnf (decode @GenerateResponse) sampleGenerateBytes+        , bench "ChatResponse" $ whnf (decode @ChatResponse) sampleChatBytes+        , bench "EmbedResponse" $ whnf (decode @EmbedResponse) sampleEmbedBytes+        ]+    ]++sampleGenerateRequest :: GenerateRequest+sampleGenerateRequest = generateRequest (ModelName "llama3.2") "Why is the sky blue?"++sampleChatRequest :: ChatRequest+sampleChatRequest = chatRequest (ModelName "llama3.2") (userMessage "Hello, world!" :| [])++sampleEmbedRequest :: EmbedRequest+sampleEmbedRequest = embedRequest (ModelName "nomic-embed-text") ["Hello", "World", "Vector"]++sampleCreateRequest :: CreateRequest+sampleCreateRequest = defaultCreateRequest (ModelName "custom-llama")++sampleGenerateBytes :: ByteString+sampleGenerateBytes = encode $ mockGenerateResponse (ModelName "llama3.2") "Sky is blue"++sampleChatBytes :: ByteString+sampleChatBytes = encode $ mockChatResponse (ModelName "llama3.2") "Hello there"++sampleEmbedBytes :: ByteString+sampleEmbedBytes = encode $ mockEmbedResponse (ModelName "nomic") [[0.1, 0.2]]

@@ -0,0 +1,66 @@+# SDK Feature & Architecture Comparison++This document provides a comprehensive technical comparison between **`ollama-haskell` (v0.3.0.0)**, official SDKs in other ecosystems (**Python**, **JavaScript/TypeScript**, **Go**), and existing Haskell LLM libraries.++---++## 1. Feature Support Matrix Across Language SDKs++| Feature / Endpoint | `ollama-haskell` (v0.3.0.0) | `ollama-python` | `ollama-js` | `ollama/ollama/api` (Go) |+| :--- | :---: | :---: | :---: | :---: |+| **Language Paradigm** | Pure Functional / Typed | Dynamic / Async | Dynamic / Promises | Imperative / Structs |+| **Response Streaming** | `conduit` Pipelines | Iterator / AsyncGenerator | AsyncIterable | Channel / Callback |+| **Chat Completions (`/api/chat`)** | ✅ | ✅ | ✅ | ✅ |+| **Text Generation (`/api/generate`)** | ✅ | ✅ | ✅ | ✅ |+| **Thinking / Reasoning Models** | ✅ `Think` ADT (`qwen3.5`, `deepseek-r1`) | ⚠️ Raw JSON parameter | ⚠️ Raw JSON parameter | ⚠️ Raw JSON parameter |+| **Structured Output Schema** | ✅ Type-safe `SchemaBuilder` DSL | ⚠️ Pydantic / Raw Dict | ⚠️ Zod / Raw Schema | ⚠️ Struct tag / Raw Schema |+| **Function / Tool Calling** | ✅ Strongly-typed `Tool` ADT | ✅ Dict / Callables | ✅ JSON schema objects | ✅ Go Structs |+| **Vector Embeddings (`/api/embed`)** | ✅ | ✅ | ✅ | ✅ |+| **Model Lifecycle (`copy`, `delete`, `show`, `ps`)** | ✅ | ✅ | ✅ | ✅ |+| **Blob Management (`checkBlob`, `pushBlob`)** | ✅ | ✅ | ✅ | ✅ |+| **Automatic Retry Policy** | ✅ `NoRetry`, `Constant`, `Exponential` | ❌ (User implementation) | ❌ (User implementation) | ❌ (User implementation) |+| **Connection Lifecycles** | ✅ Automatic GC & Bracket | ⚠️ Manual session | ⚠️ Fetch client | ⚠️ Manual `http.Client` |+| **STM Session Management** | ✅ `InMemoryStore` & `ConversationStore` | ❌ | ❌ | ❌ |+| **Mock Testing Harness** | ✅ `Ollama.Testing` (`withMockClient`) | ❌ | ❌ | ❌ |++---++## 2. Comparison with Other Haskell LLM Libraries++| Feature | `ollama-haskell` | `openai-hs` | `langchain-hs` |+| :--- | :--- | :--- | :--- |+| **Target Provider** | Local Ollama Engine | OpenAI Cloud API | Multi-provider Framework |+| **Streaming Abstraction** | First-class `conduit` streams | Lazy ByteString / SSE | Custom Stream types |+| **Retry & Resilience** | Integrated `retry` policy backoff | None | Basic |+| **Mocking & Testing** | Built-in `Ollama.Testing` module | None | Mock handlers |+| **Memory Persistence** | STM-backed `InMemoryStore` | Manual | Vector store abstractions |++---++## 3. Key Architectural Advantages of `ollama-haskell`++1. **Type Safety & Smart Constructors**:+   - String parameters are wrapped in domain-specific newtypes (`ModelName`, `Digest`, `Base64Image`, `Duration`, `Version`).+   - `mkModelName` validates model name invariants at runtime.++2. **First-Class Streaming via `conduit`**:+   - `chatStream` and `generateStream` stream line-delimited JSON objects over constant memory pipelines without buffering entire responses in memory.+   - Stream combinators `collectStream` and `foldStream` simplify consumption.++3. **Domain-Specific Schema Builder (`SchemaBuilder`)**:+   - Construct complex JSON Schemas using readable infix operators:+     ```haskell+     userSchema = buildSchema $+       emptyObject+         |+ ("name", JString)+         |+ ("age", JInteger)+         |! "name"+     ```++4. **Built-In Resilient Transport**:+   - Exponential backoff retry strategies (`ExponentialRetry 3 1.0`).+   - Lifecycle callbacks (`configOnStart`, `configOnSuccess`, `configOnError`).+   - Customizable logger thresholds (`Debug`, `Info`, `Warn`, `Error`).++5. **Mock Infrastructure (`Ollama.Testing`)**:+   - Test application code deterministically offline using `withMockClient` without needing a running Ollama server during CI unit testing.

@@ -0,0 +1,187 @@+{-# LANGUAGE OverloadedStrings #-}++{- |+Module      : Main+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Comprehensive example demonstrating all v1.0 features of ollama-haskell:+  * Client builder with env resolution, custom headers, & retry policies+  * Conduit-based response streaming+  * Thinking / reasoning model integration+  * Function / tool calling+  * Structured JSON schema output+  * Vector embeddings & token throughput metrics+  * Transactional STM conversation storage++@since 1.0.0.0+-}+module Main (main) where++import Data.List.NonEmpty (NonEmpty ((:|)))+import Data.Text qualified as T+import Data.Time (getCurrentTime)+import Ollama++fastOptions :: Maybe ModelOptions+fastOptions = Just (defaultOptions {optNumPredict = Just 20})++main :: IO ()+main = do+  putStrLn "=========================================================="+  putStrLn "   ollama-haskell v1.0 — All Features Showcase Example"+  putStrLn "=========================================================="++  -- 1. Client Builder with env vars, custom headers, & Exponential Retry Policy+  putStrLn "\n[1] Initializing client..."+  let customConfig =+        defaultConfig+          { configRetry = ExponentialRetry 3 1+          , configHeaders = [("X-Custom-Client", "ollama-haskell-v1.0")]+          }+  client <- newClient customConfig+  putStrLn "Client initialized with ExponentialRetry policy."++  -- 2. System Inspection+  putStrLn "\n[2] System Engine Version..."+  verRes <- getVersion client+  case verRes of+    Left err -> putStrLn $ "Error fetching version: " <> show err+    Right ver -> putStrLn $ "Ollama Engine Version: " <> T.unpack (unVersion ver)++  putStrLn "\n[3] Listing Local Models..."+  modelsRes <- listModels client+  case modelsRes of+    Left err -> putStrLn $ "Error listing models: " <> show err+    Right (ListResponse ms) -> do+      putStrLn $ "Found " <> show (length ms) <> " installed models:"+      mapM_ (\m -> putStrLn $ "  - " <> T.unpack (unModelName (miName m))) ms++  let model = "qwen3.5:2b"++  -- 4. Conduit-Based Streaming Chat+  putStrLn $ "\n[4] Streaming Chat with Conduit (" <> T.unpack (unModelName model) <> ")..."+  let streamReq =+        (chatRequest model (userMessage "Count from 1 to 5." :| []))+          { chatOptions = fastOptions+          , chatThink = Just ThinkDisabled+          }+  putStr "Response stream: "+  chunks <- collectStream (chatStream client streamReq)+  mapM_+    ( \c -> case crMessage c of+        Just msg -> putStr (T.unpack (messageContent msg))+        Nothing -> pure ()+    )+    chunks+  putStrLn ""++  -- 5. Non-Streaming Chat with Token Throughput Metrics+  putStrLn "\n[5] Non-Streaming Chat & Token Metrics..."+  let chatReq =+        ( chatRequest+            model+            (systemMessage "You are a concise assistant." :| [userMessage "Explain gravity in one sentence."])+        )+          { chatOptions = fastOptions+          , chatThink = Just ThinkDisabled+          }+  chatRes <- chat client chatReq+  case chatRes of+    Left err -> putStrLn $ "Chat error: " <> show err+    Right resp -> do+      case crMessage resp of+        Just msg -> putStrLn $ "Answer: " <> T.unpack (messageContent msg)+        Nothing -> putStrLn "No message returned."+      case chatEvalTokensPerSecond resp of+        Just tps -> putStrLn $ "Generation Speed: " <> show tps <> " tokens/sec"+        Nothing -> pure ()++  -- 6. Thinking / Reasoning Model Integration+  putStrLn "\n[6] Generation with Thinking Mode..."+  let thinkReq =+        (generateRequest model "What is 15 * 14?")+          { genThink = Just (ThinkLevel ThinkMedium)+          , genOptions = fastOptions+          }+  thinkRes <- generate client thinkReq+  case thinkRes of+    Left err -> putStrLn $ "Generate error: " <> show err+    Right resp -> putStrLn $ "Result: " <> T.unpack (grResponse resp)++  -- 7. Tool / Function Calling+  putStrLn "\n[7] Tool / Function Calling..."+  let calcTool =+        Tool+          { toolType = "function"+          , toolFunction =+              FunctionDef+                { fnName = "calculator"+                , fnDescription = Just "Perform basic math calculations"+                , fnParameters =+                    Just+                      FunctionParameters+                        { fpType = "object"+                        , fpProperties = Nothing+                        , fpRequired = Just ["expression"]+                        , fpAdditionalProperties = Nothing+                        , fpDescription = Nothing+                        , fpEnum = Nothing+                        }+                , fnStrict = Just True+                }+          }+      toolReq =+        (chatRequest model (userMessage "Calculate 42 * 8" :| []))+          { chatTools = Just [calcTool]+          , chatOptions = fastOptions+          , chatThink = Just ThinkDisabled+          }+  toolRes <- chat client toolReq+  case toolRes of+    Left err -> putStrLn $ "Tool chat error: " <> show err+    Right resp -> case crMessage resp of+      Just msg -> case messageToolCalls msg of+        Just calls -> putStrLn $ "Model requested tool execution: " <> show calls+        Nothing -> putStrLn $ "Response: " <> T.unpack (messageContent msg)+      Nothing -> putStrLn "No message returned."++  -- 8. Vector Embeddings+  putStrLn "\n[8] Vector Embeddings..."+  let embReq = embedRequest model ["Haskell AI development", "Ollama LLM client"]+  embRes <- embed client embReq+  case embRes of+    Left err -> putStrLn $ "Embed error: " <> show err+    Right resp -> putStrLn $ "Generated " <> show (length (erEmbeddings resp)) <> " embedding vectors."++  -- 9. Transactional Conversation Store+  putStrLn "\n[9] STM Conversation Store..."+  store <- initInMemoryStore+  now <- getCurrentTime+  let convId = "demo-session-42"+      session =+        Conversation+          convId+          [systemMessage "Context saved.", userMessage "Favorite language is Haskell."]+          model+          now+          now+  saveConversationInMemory store session+  retrieved <- loadConversationInMemory store convId+  case retrieved of+    Just c ->+      putStrLn $+        "Successfully loaded conversation ["+          <> T.unpack (conversationId c)+          <> "] with "+          <> show (length (messages c))+          <> " messages."+    Nothing -> putStrLn "Failed to load conversation."++  closeClient client+  putStrLn "\n=========================================================="+  putStrLn "   Showcase Completed Successfully!"+  putStrLn "=========================================================="

@@ -0,0 +1,21 @@+module Main (main) where++import Data.List.NonEmpty (NonEmpty ((:|)))+import Data.Text.IO qualified as TIO+import Ollama++main :: IO ()+main = do+  client <- defaultClient+  let opts = Just (defaultOptions {optNumPredict = Just 20})+      req =+        (chatRequest "qwen3.5:2b" (userMessage "Why is the sky blue?" :| []))+          { chatOptions = opts+          , chatThink = Just ThinkDisabled+          }+  res <- chat client req+  case res of+    Left err -> putStrLn $ "Error: " <> show err+    Right resp -> case crMessage resp of+      Just msg -> TIO.putStrLn $ "Response: " <> messageContent msg+      Nothing -> putStrLn "No content returned"

@@ -0,0 +1,12 @@+module Main (main) where++import Ollama++main :: IO ()+main = do+  client <- defaultClient+  let req = embedRequest "qwen3.5:2b" ["Hello world", "Haskell LLM integration"]+  res <- embed client req+  case res of+    Left err -> putStrLn $ "Error: " <> show err+    Right resp -> putStrLn $ "Generated " <> show (length $ erEmbeddings resp) <> " embeddings."

@@ -0,0 +1,13 @@+module Main (main) where++import Ollama++main :: IO ()+main = do+  client <- defaultClient+  res <- listModels client+  case res of+    Left err -> putStrLn $ "Error listing models: " <> show err+    Right (ListResponse ms) -> do+      putStrLn "Installed Models:"+      mapM_ (print . miName) ms

@@ -0,0 +1,18 @@+module Main (main) where++import Data.List.NonEmpty (NonEmpty ((:|)))+import Data.Text.IO qualified as TIO+import Ollama++main :: IO ()+main = do+  client <- defaultClient+  let opts = Just (defaultOptions {optNumPredict = Just 20})+      req =+        (chatRequest "qwen3.5:2b" (userMessage "Count from 1 to 5." :| []))+          { chatOptions = opts+          , chatThink = Just ThinkDisabled+          }+  chunks <- collectStream (chatStream client req)+  mapM_ (TIO.putStr . maybe "" messageContent . crMessage) chunks+  putStrLn ""

@@ -0,0 +1,28 @@+module Main (main) where++import Data.Text.IO qualified as TIO+import Ollama+import Ollama.Types.Format.SchemaBuilder++personSchema :: Schema+personSchema =+  buildSchema $+    emptyObject+      |+ ("name", JString)+      |+ ("age", JInteger)+      |! "name"++main :: IO ()+main = do+  client <- defaultClient+  let opts = Just (defaultOptions {optNumPredict = Just 20})+      req =+        (generateRequest "qwen3.5:2b" "Generate a person profile.")+          { genFormat = Just (SchemaFormat personSchema)+          , genOptions = opts+          , genThink = Just ThinkDisabled+          }+  res <- generate client req+  case res of+    Left err -> putStrLn $ "Error: " <> show err+    Right resp -> TIO.putStrLn $ "Structured Response:\n" <> grResponse resp

@@ -0,0 +1,41 @@+module Main (main) where++import Data.List.NonEmpty (NonEmpty ((:|)))+import Ollama++calculatorTool :: Tool+calculatorTool =+  Tool+    { toolType = "function"+    , toolFunction =+        FunctionDef+          { fnName = "add"+          , fnDescription = Just "Add two numbers"+          , fnParameters =+              Just+                FunctionParameters+                  { fpType = "object"+                  , fpProperties = Nothing+                  , fpRequired = Just ["a", "b"]+                  , fpAdditionalProperties = Nothing+                  , fpDescription = Nothing+                  , fpEnum = Nothing+                  }+          , fnStrict = Just True+          }+    }++main :: IO ()+main = do+  client <- defaultClient+  let opts = Just (defaultOptions {optNumPredict = Just 20})+      req =+        (chatRequest "qwen3.5:2b" (userMessage "What is 25 + 17?" :| []))+          { chatTools = Just [calculatorTool]+          , chatOptions = opts+          , chatThink = Just ThinkDisabled+          }+  res <- chat client req+  case res of+    Left err -> putStrLn $ "Error: " <> show err+    Right resp -> print (crMessage resp)

@@ -1,115 +1,241 @@-cabal-version: 1.12---- This file has been generated from package.yaml by hpack version 0.38.1.------ see: https://github.com/sol/hpack--name:           ollama-haskell-version:        0.2.1.0-synopsis:       Haskell client for ollama.-description:    Ollama client for Haskell-category:       Web-homepage:       https://github.com/tusharad/ollama-haskell#readme-bug-reports:    https://github.com/tusharad/ollama-haskell/issues-author:         tushar-maintainer:     tusharadhatrao@gmail.com-copyright:      2024 tushar-license:        MIT-license-file:   LICENSE-build-type:     Simple-extra-source-files:-    README.md-    CHANGELOG.md+cabal-version: 3.0+name:          ollama-haskell+version:       0.3.0.0+synopsis:      Industry-grade Haskell client for the Ollama API+description:+  A type-safe, well-tested Haskell client for interacting with+  locally-running LLMs via the Ollama HTTP API. Supports chat,+  text generation, embeddings, model management, streaming via+  conduit, structured outputs, tool calling, and more.+category:      Web, AI, Network+license:       MIT+license-file:  LICENSE+author:        Tushar Adhatrao+maintainer:    tusharadhatrao@gmail.com+copyright:     2024-2026 Tushar Adhatrao+homepage:      https://github.com/tusharad/ollama-haskell+bug-reports:   https://github.com/tusharad/ollama-haskell/issues+tested-with:   GHC == 9.4.8, GHC == 9.6.7, GHC == 9.8.4, GHC == 9.10.3, GHC == 9.12.4+stability:     stable+extra-doc-files:+  README.md+  CHANGELOG.md+  doc/COMPARISON.md  source-repository head   type: git   location: https://github.com/tusharad/ollama-haskell +flag integration-tests+  description: Build and run integration tests (requires running Ollama server)+  default: False+  manual: True++common warnings+  ghc-options:+    -Wall+    -Wcompat+    -Widentities+    -Wincomplete-record-updates+    -Wincomplete-uni-patterns+    -Wmissing-export-lists+    -Wmissing-home-modules+    -Wpartial-fields+    -Wredundant-constraints++common lang+  default-language: GHC2021+  default-extensions:+    StrictData+    DerivingStrategies+    DeriveGeneric+    DeriveAnyClass+    GeneralizedNewtypeDeriving+    OverloadedStrings+    ImportQualifiedPost+    TypeApplications+    RecordWildCards+    NamedFieldPuns+    LambdaCase+    MultiWayIf+    ScopedTypeVariables+    BangPatterns+ library+  import: warnings, lang+  hs-source-dirs: src   exposed-modules:-      Data.Ollama.Blob-      Data.Ollama.Chat-      Data.Ollama.Common.Config-      Data.Ollama.Common.Error-      Data.Ollama.Common.SchemaBuilder-      Data.Ollama.Common.Types-      Data.Ollama.Common.Utils-      Data.Ollama.Conversation-      Data.Ollama.Copy-      Data.Ollama.Create-      Data.Ollama.Delete-      Data.Ollama.Embeddings-      Data.Ollama.Generate-      Data.Ollama.List-      Data.Ollama.Load-      Data.Ollama.Ps-      Data.Ollama.Pull-      Data.Ollama.Push-      Data.Ollama.Show-      Ollama+    Ollama+    Ollama.Client+    Ollama.Client.Config+    Ollama.API.Generate+    Ollama.API.Chat+    Ollama.API.Embed+    Ollama.API.Models+    Ollama.API.Models.Create+    Ollama.API.Models.Pull+    Ollama.API.Models.Push+    Ollama.API.Blobs+    Ollama.API.Ps+    Ollama.API.Version+    Ollama.Types+    Ollama.Types.Message+    Ollama.Types.Tool+    Ollama.Types.Model+    Ollama.Types.Options+    Ollama.Types.Format+    Ollama.Types.Format.SchemaBuilder+    Ollama.Types.Common+    Ollama.Error+    Ollama.Streaming+    Ollama.Testing+    Ollama.Conversation   other-modules:-      Paths_ollama_haskell-  hs-source-dirs:-      src-  default-extensions:-      ImportQualifiedPost-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints+    Ollama.Client.Internal   build-depends:-      aeson ==2.*-    , base >=4.7 && <5-    , base64-bytestring ==1.*-    , bytestring >=0.10 && <0.13-    , containers >=0.6 && <0.9-    , directory >=1 && <1.4-    , filepath >=1 && <1.6-    , http-client >=0.6 && <0.8-    , http-client-tls >=0.2 && <0.4-    , http-types >=0.7 && <0.13-    , mtl ==2.*-    , stm ==2.*-    , text >=1 && <3-    , time ==1.*-  default-language: Haskell2010+      aeson            >= 2.0 && < 3+    , base             >= 4.17 && < 5+    , bytestring       >= 0.10 && < 0.13+    , case-insensitive >= 1.2 && < 1.3+    , conduit          >= 1.3 && < 1.4+    , conduit-extra    >= 1.3 && < 1.4+    , containers       >= 0.6 && < 0.9+    , hashable         >= 1.4 && < 1.6+    , http-client      >= 0.6 && < 0.8+    , http-client-tls  >= 0.2 && < 0.5+    , http-types       >= 0.7 && < 0.13+    , mtl              >= 2.2 && < 3+    , retry            >= 0.9 && < 0.10+    , resourcet        >= 1.3 && < 1.4+    , stm              >= 2.5 && < 3+    , text             >= 2.0 && < 3+    , time             >= 1.11 && < 2+    , unliftio-core    >= 0.2 && < 0.3  test-suite ollama-haskell-test+  import: warnings, lang   type: exitcode-stdio-1.0+  hs-source-dirs: test   main-is: Main.hs   other-modules:-      Test.Ollama.Blob-      Test.Ollama.Chat-      Test.Ollama.Common-      Test.Ollama.Copy-      Test.Ollama.Create-      Test.Ollama.Delete-      Test.Ollama.Embedding-      Test.Ollama.Generate-      Test.Ollama.List-      Test.Ollama.Load-      Test.Ollama.Show-      Paths_ollama_haskell-  hs-source-dirs:-      test-  default-extensions:-      ImportQualifiedPost-  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-N+    Test.Ollama.Unit.Types+    Test.Ollama.Unit.Error+    Test.Ollama.Unit.Config+    Test.Ollama.Unit.SchemaBuilder+    Test.Ollama.Unit.Testing+    Test.Ollama.Property.Arbitrary+    Test.Ollama.Property.Roundtrip+    Test.Ollama.Golden.Chat+    Test.Ollama.Golden.Generate+    Test.Ollama.Golden.Embed+    Test.Ollama.Golden.Models   build-depends:-      aeson-    , base >=4.7 && <5-    , base64-bytestring ==1.*-    , bytestring >=0.10 && <0.13-    , containers >=0.6 && <0.9-    , directory >=1 && <1.4-    , filepath >=1 && <1.6-    , http-client >=0.6 && <0.8-    , http-client-tls >=0.2 && <0.4-    , http-types >=0.7 && <0.13-    , mtl ==2.*+      base     , ollama-haskell-    , scientific-    , silently-    , stm ==2.*-    , tasty >=1.5+    , aeson+    , bytestring+    , containers+    , QuickCheck       >= 2.14+    , tasty          >= 1.5+    , tasty-golden   >= 2.3     , tasty-hunit+    , tasty-quickcheck >= 0.10     , text-    , time ==1.*-  default-language: Haskell2010+    , time+    , conduit++test-suite ollama-haskell-integration+  import: warnings, lang+  type: exitcode-stdio-1.0+  hs-source-dirs: test-integration+  main-is: Main.hs+  if !flag(integration-tests)+    buildable: False+  build-depends:+      base+    , ollama-haskell+    , aeson+    , tasty+    , tasty-hunit+    , text+    , time++benchmark ollama-haskell-bench+  import: warnings, lang+  type: exitcode-stdio-1.0+  hs-source-dirs: bench+  main-is: Main.hs+  build-depends:+      base+    , ollama-haskell+    , aeson+    , bytestring+    , tasty          >= 1.5+    , tasty-bench    >= 0.3+    , text++executable ollama-example-basic-chat+  import: warnings, lang+  main-is: BasicChat.hs+  hs-source-dirs: examples+  build-depends:+      base+    , ollama-haskell+    , text++executable ollama-example-streaming-chat+  import: warnings, lang+  main-is: StreamingChat.hs+  hs-source-dirs: examples+  build-depends:+      base+    , ollama-haskell+    , text++executable ollama-example-tool-calling+  import: warnings, lang+  main-is: ToolCalling.hs+  hs-source-dirs: examples+  build-depends:+      base+    , ollama-haskell+    , text++executable ollama-example-structured-output+  import: warnings, lang+  main-is: StructuredOutput.hs+  hs-source-dirs: examples+  build-depends:+      base+    , ollama-haskell+    , text++executable ollama-example-embeddings+  import: warnings, lang+  main-is: Embeddings.hs+  hs-source-dirs: examples+  build-depends:+      base+    , ollama-haskell+    , text++executable ollama-example-model-management+  import: warnings, lang+  main-is: ModelManagement.hs+  hs-source-dirs: examples+  build-depends:+      base+    , ollama-haskell+    , text++executable ollama-example-all-features+  import: warnings, lang+  main-is: AllFeatures.hs+  hs-source-dirs: examples+  build-depends:+      base+    , ollama-haskell+    , aeson+    , text+    , time+

@@ -1,176 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE RecordWildCards #-}--{- |-Module      : Data.Ollama.Blob-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functions for managing binary large objects (blobs) in the Ollama API.--This module provides functionality for checking the existence of blobs and uploading-files as blobs to the Ollama server. Blobs are used when creating models from-GGUF files or safetensors directories.--The blob operations interact with the @\/api\/blobs@ endpoints:--- 'checkBlobExists' sends a HEAD request to check if a blob exists-- 'createBlob' uploads a file as a blob using streaming POST--Example usage:-->>> let digest = "sha256:29fdb92e57cf0827ded04ae6461b5931d01fa595843f55d36f5b275a52087dd2"->>> exists <- checkBlobExists digest Nothing->>> case exists of->>>   Right True -> putStrLn "Blob exists"->>>   Right False -> putStrLn "Blob not found"->>>   Left err -> putStrLn $ "Error: " ++ show err-->>> result <- createBlob "model.gguf" digest Nothing->>> case result of->>>   Right () -> putStrLn "Blob uploaded successfully"->>>   Left err -> putStrLn $ "Upload failed: " ++ show err--}-module Data.Ollama.Blob-  ( -- * Blob Operations-    checkBlobExists-  , createBlob-  ) where--import Control.Exception (try)-import Data.ByteString qualified as BS-import Data.Maybe (fromMaybe)-import Data.Ollama.Common.Config (OllamaConfig (..), defaultOllamaConfig)-import Data.Ollama.Common.Error-import Data.Ollama.Common.Error qualified as Error-import Data.Text (Text)-import Data.Text qualified as T-import Data.Text.Encoding qualified as TE-import Network.HTTP.Client-import Network.HTTP.Client.TLS-import Network.HTTP.Types (Status (statusCode))-import System.Directory (doesFileExist)--{- | Check if a blob exists on the Ollama server.--Sends a HEAD request to @\/api\/blobs\/sha256:\<digest\>@ to check if a blob-with the given SHA256 digest exists on the server.--Returns:-- 'Right' 'True' if the blob exists (HTTP 200 OK)-- 'Right' 'False' if the blob does not exist (HTTP 404 Not Found)-- 'Left' 'OllamaError' for other errors (network issues, invalid digest, etc.)--The digest should be a SHA256 hash string without the "sha256:" prefix.--}-checkBlobExists ::-  -- | SHA256 digest of the blob (without "sha256:" prefix)-  Text ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError Bool)-checkBlobExists digest mbOllamaConfig = do-  let OllamaConfig {..} = fromMaybe defaultOllamaConfig mbOllamaConfig-      endpoint = "/api/blobs/sha256:" <> digest-      fullUrl = T.unpack $ hostUrl <> endpoint-      timeoutMicros = timeout * 1000000--  manager <- case commonManager of-    Nothing ->-      newTlsManagerWith-        tlsManagerSettings {managerResponseTimeout = responseTimeoutMicro timeoutMicros}-    Just m -> pure m--  eRequest <- try $ parseRequest fullUrl-  case eRequest of-    Left ex -> return $ Left $ Error.HttpError ex-    Right req -> do-      let request = req {method = "HEAD"}-      eResponse <- try $ httpNoBody request manager-      case eResponse of-        Left ex -> return $ Left $ Error.HttpError ex-        Right response -> do-          let status = statusCode $ responseStatus response-          case status of-            200 -> return $ Right True-            404 -> return $ Right False-            _ ->-              return $-                Left $-                  Error.ApiError $-                    "Unexpected status code: " <> T.pack (show status)--{- | Upload a file as a blob to the Ollama server.--Streams the contents of the file at the given 'FilePath' to the Ollama server-via a POST request to @\/api\/blobs\/sha256:\<digest\>@. The server will verify-that the uploaded file matches the expected SHA256 digest.--Returns:-- 'Right' @()@ if the blob was uploaded successfully (HTTP 201 Created)-- 'Left' 'OllamaError' if the upload failed--The digest should be the expected SHA256 hash of the file without the "sha256:" prefix.-If the file content doesn't match the digest, the server will return an error.--Note: This function streams the file content, so it can handle large files efficiently-without loading them entirely into memory.--}-createBlob ::-  -- | Path to the file to upload-  FilePath ->-  -- | Expected SHA256 digest of the file (without "sha256:" prefix)-  Text ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError ())-createBlob filePath digest mbOllamaConfig = do-  let OllamaConfig {..} = fromMaybe defaultOllamaConfig mbOllamaConfig-      endpoint = "/api/blobs/sha256:" <> digest-      fullUrl = T.unpack $ hostUrl <> endpoint-      timeoutMicros = timeout * 1000000--  manager <- case commonManager of-    Nothing ->-      newTlsManagerWith-        tlsManagerSettings {managerResponseTimeout = responseTimeoutMicro timeoutMicros}-    Just m -> pure m--  eRequest <- try $ parseRequest fullUrl-  case eRequest of-    Left ex -> return $ Left $ Error.HttpError ex-    Right req -> do-      -- check if file exists-      fileExists <- doesFileExist filePath-      if not fileExists-        then return $ Left $ Error.ApiError "File does not exist"-        else do-          -- Create a request body from the file-          fileContent <- BS.readFile filePath-          let request =-                req-                  { method = "POST"-                  , requestBody = RequestBodyBS fileContent-                  }--          eResponse <- try $ withResponse request manager $ \response -> do-            let status = statusCode $ responseStatus response-            case status of-              201 -> return $ Right ()-              400 -> do-                bodyReader <- brRead $ responseBody response-                return $-                  Left $-                    Error.ApiError $-                      "Bad request - digest mismatch: " <> TE.decodeUtf8 bodyReader-              _ -> do-                bodyReader <- brRead $ responseBody response-                return $-                  Left $-                    Error.ApiError $-                      "Unexpected status code " <> T.pack (show status) <> ": " <> TE.decodeUtf8 bodyReader--          case eResponse of-            Left ex -> return $ Left $ Error.HttpError ex-            Right result -> return result

@@ -1,295 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Chat-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Chat functionality for interacting with the Ollama API.--This module provides functions and types for initiating and managing chat interactions with an Ollama model.-It includes APIs for sending chat requests, constructing messages with different roles, and configuring chat-operations. The module supports both streaming and non-streaming responses, as well as optional tools and-structured output formats.--The primary functions are 'chat' and 'chatM' for sending chat requests, and helper functions like-'systemMessage', 'userMessage', 'assistantMessage', and 'toolMessage' for constructing messages.-The 'ChatOps' type allows customization of chat parameters, and 'defaultChatOps' provides a convenient-starting point for configuration.--Example:-->>> let ops = defaultChatOps { chatModelName = "customModel", messages = userMessage "Hello!" :| [] }->>> chat ops Nothing-Either OllamaError ChatResponse--}-module Data.Ollama.Chat-  ( -- * Chat APIs-    chat-  , chatM--    -- * Message Types-  , Message (..)-  , Role (..)-  , systemMessage-  , userMessage-  , assistantMessage-  , toolMessage-  , genMessage--    -- * Chat Configuration-  , defaultChatOps-  , ChatOps (..)--    -- * Response Types-  , ChatResponse (..)-  , Format (..)--    -- * Configuration and Error Types-  , OllamaConfig (..)-  , defaultOllamaConfig-  , OllamaError (..)-  , ModelOptions (..)-  , defaultModelOptions--    -- * Tool and Function Types-  , InputTool (..)-  , FunctionDef (..)-  , FunctionParameters (..)-  , OutputFunction (..)-  , ToolCall (..)-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.List.NonEmpty as NonEmpty-import Data.Maybe (isNothing)-import Data.Ollama.Common.Config-import Data.Ollama.Common.Error (OllamaError (..))-import Data.Ollama.Common.Types-  ( ChatResponse (..)-  , Format (..)-  , FunctionDef (..)-  , FunctionParameters (..)-  , InputTool (..)-  , Message (..)-  , ModelOptions (..)-  , OutputFunction (..)-  , Role (..)-  , ToolCall (..)-  )-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)-import Data.Text qualified as T--{- | Constructs a 'Message' with the specified role and content.--Creates a 'Message' with the given 'Role' and textual content, setting optional fields-('images', 'tool_calls', 'thinking') to 'Nothing'.--Example:-->>> genMessage User "What's the weather like?"-Message {role = User, content = "What's the weather like?", images = Nothing, tool_calls = Nothing, thinking = Nothing}--}-genMessage :: Role -> Text -> Message-genMessage r c =-  Message-    { role = r-    , content = c-    , images = Nothing-    , tool_calls = Nothing-    , thinking = Nothing-    }--{- | Creates a 'Message' with the 'System' role.--Example:-->>> systemMessage "You are a helpful assistant."-Message {role = System, content = "You are a helpful assistant.", images = Nothing, tool_calls = Nothing, thinking = Nothing}--}-systemMessage :: Text -> Message-systemMessage = genMessage System--{- | Creates a 'Message' with the 'User' role.--Example:-->>> userMessage "What's 2+2?"-Message {role = User, content = "What's 2+2?", images = Nothing, tool_calls = Nothing, thinking = Nothing}--}-userMessage :: Text -> Message-userMessage = genMessage User--{- | Creates a 'Message' with the 'Assistant' role.--Example:-->>> assistantMessage "2+2 equals 4."-Message {role = Assistant, content = "2+2 equals 4.", images = Nothing, tool_calls = Nothing, thinking = Nothing}--}-assistantMessage :: Text -> Message-assistantMessage = genMessage Assistant--{- | Creates a 'Message' with the 'Tool' role.--Example:-->>> toolMessage "Tool output: success"-Message {role = Tool, content = "Tool output: success", images = Nothing, tool_calls = Nothing, thinking = Nothing}--}-toolMessage :: Text -> Message-toolMessage = genMessage Tool--{- | Validates 'ChatOps' to ensure required fields are non-empty.--Checks that the 'chatModelName' is not empty and that no 'Message' in 'messages' has empty content.-Returns 'Right' with the validated 'ChatOps' or 'Left' with an 'OllamaError' if validation fails.--@since 0.2.0.0--}-validateChatOps :: ChatOps -> Either OllamaError ChatOps-validateChatOps ops-  | T.null (modelName ops) = Left $ InvalidRequest "Chat model name cannot be empty"-  | any (T.null . content) (messages ops) =-      Left $ InvalidRequest "Messages cannot have empty content"-  | otherwise = Right ops--{- | Configuration for initiating a chat with an Ollama model.--Defines the parameters for a chat request, including the model name, messages, and optional settings-for tools, response format, streaming, timeout, and model options.--}-data ChatOps = ChatOps-  { modelName :: !Text-  -- ^ The name of the chat model to be used (e.g., "gemma3").-  , messages :: !(NonEmpty Message)-  -- ^ A non-empty list of messages forming the conversation context.-  , tools :: !(Maybe [InputTool])-  -- ^ Optional tools that may be used in the chat.-  , format :: !(Maybe Format)-  -- ^ Optional format for the chat response (e.g., JSON or JSON schema).-  ---  -- @since 0.1.3.0-  , stream :: !(Maybe (ChatResponse -> IO (), IO ()))-  -- ^ Optional callback function to be called with each incoming response.-  , keepAlive :: !(Maybe Int)-  -- ^ Optional override for the response timeout in minutes (default: 15 minutes).-  , options :: !(Maybe ModelOptions)-  -- ^ Optional model parameters (e.g., temperature) as specified in the Modelfile.-  ---  -- @since 0.1.3.0-  , think :: !(Maybe Bool)-  -- ^ Optional flag to enable thinking mode.-  ---  -- @since 0.2.0.0-  }--instance Show ChatOps where-  show-    ( ChatOps-        { modelName = m-        , messages = ms-        , tools = t-        , format = f-        , keepAlive = ka-        , think = th-        }-      ) =-      let messagesStr = show (toList ms)-          toolsStr = show t-          formatStr = show f-          keepAliveStr = show ka-          thinkStr = show th-       in T.unpack m-            ++ "\nMessages:\n"-            ++ messagesStr-            ++ "\n"-            ++ toolsStr-            ++ "\n"-            ++ formatStr-            ++ "\n"-            ++ keepAliveStr-            ++ "\n"-            ++ thinkStr--instance Eq ChatOps where-  (==) a b =-    modelName a == modelName b-      && messages a == messages b-      && tools a == tools b-      && format a == format b-      && keepAlive a == keepAlive b--instance ToJSON ChatOps where-  toJSON (ChatOps model_ messages_ tools_ format_ stream_ keepAlive_ options_ think_) =-    object-      [ "model" .= model_-      , "messages" .= messages_-      , "tools" .= tools_-      , "format" .= format_-      , "stream" .= if isNothing stream_ then Just False else Just True-      , "keep_alive" .= keepAlive_-      , "options" .= options_-      , "think" .= think_-      ]--{- | Default configuration for initiating a chat.--Provides a default 'ChatOps' with the "gemma3" model and a sample user message ("What is 2+2?").-Can be customized by modifying fields as needed.--Example:-->>> let ops = defaultChatOps { chatModelName = "customModel", messages = userMessage "Hello!" :| [] }->>> chat ops Nothing-Either OllamaError ChatResponse--}-defaultChatOps :: ChatOps-defaultChatOps =-  ChatOps-    { modelName = "gemma3"-    , messages = userMessage "What is 2+2?" :| []-    , tools = Nothing-    , format = Nothing-    , stream = Nothing-    , keepAlive = Nothing-    , options = Nothing-    , think = Nothing-    }--{- | Sends a chat request to the Ollama API.--Validates the 'ChatOps' configuration and sends a POST request to the @\/api\/chat@ endpoint.-Supports both streaming and non-streaming responses based on the 'stream' field in 'ChatOps'.-Returns an 'Either' containing an 'OllamaError' on failure or a 'ChatResponse' on success.--Example:-->>> let ops = defaultChatOps { chatModelName = "gemma3", messages = userMessage "What's the capital of France?" :| [] }->>> chat ops Nothing-Either OllamaError ChatResponse--}-chat :: ChatOps -> Maybe OllamaConfig -> IO (Either OllamaError ChatResponse)-chat ops mbConfig =-  case validateChatOps ops of-    Left err -> return $ Left err-    Right _ -> withOllamaRequest "/api/chat" "POST" (Just ops) mbConfig handler-  where-    handler = maybe commonNonStreamingHandler commonStreamHandler (stream ops)--{- | MonadIO version of 'chat' for use in monadic contexts.--Lifts the 'chat' function into a 'MonadIO' context, allowing it to be used in monadic computations.--Example:-->>> import Control.Monad.IO.Class->>> let ops = defaultChatOps { chatModelName = "gemma3", messages = userMessage "Hello!" :| [] }->>> runReaderT (chatM ops Nothing) someContext-Either OllamaError ChatResponse--}-chatM :: MonadIO m => ChatOps -> Maybe OllamaConfig -> m (Either OllamaError ChatResponse)-chatM ops mbCfg = liftIO $ chat ops mbCfg

@@ -1,90 +0,0 @@-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Common.Config-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : A unified configuration type for controlling Ollama client behavior.--== Overview--This module defines the core configuration record used throughout the Ollama Haskell client.--Use 'defaultOllamaConfig' as a starting point and customize it with helper functions-like 'withOnModelStart', 'withOnModelFinish', or 'withOnModelError'.--Includes settings for base URL, timeout, retry logic, and custom HTTP managers.--}-module Data.Ollama.Common.Config-  ( -- * Configuration Type-    OllamaConfig (..)--    -- * Default Config-  , defaultOllamaConfig--    -- * Hook Helpers-  , withOnModelStart-  , withOnModelFinish-  , withOnModelError-  ) where--import Data.Text (Text)-import GHC.Generics-import Network.HTTP.Client--{- | Configuration for the Ollama client.-Used across all requests to customize behavior such as timeouts, retries,-custom HTTP manager, and lifecycle hooks.--@since 0.2.0.0--}-data OllamaConfig = OllamaConfig-  { hostUrl :: Text-  -- ^ Base URL for the Ollama server (default: @http://127.0.0.1:11434@)-  , timeout :: Int-  -- ^ Timeout in seconds for API requests (ignored if 'commonManager' is set)-  , onModelStart :: Maybe (IO ())-  -- ^ Callback executed when a model starts-  , onModelError :: Maybe (IO ())-  -- ^ Callback executed if a model encounters an error-  , onModelFinish :: Maybe (IO ())-  -- ^ Callback executed when a model finishes (not called on error)-  , retryCount :: Maybe Int-  -- ^ Number of retries on failure (default: @0@ if 'Nothing')-  , retryDelay :: Maybe Int-  -- ^ Delay between retries in seconds (if applicable)-  , commonManager :: Maybe Manager-  -- ^ Shared HTTP manager; disables timeout and retry settings-  }-  deriving (Generic)--{- | A default configuration pointing to @localhost:11434@ with 90s timeout-and no hooks or retry logic.--}-defaultOllamaConfig :: OllamaConfig-defaultOllamaConfig =-  OllamaConfig-    { hostUrl = "http://127.0.0.1:11434"-    , timeout = 90-    , onModelStart = Nothing-    , onModelError = Nothing-    , onModelFinish = Nothing-    , retryCount = Nothing-    , retryDelay = Nothing-    , commonManager = Nothing-    }---- | Add a callback to be executed when a model starts.-withOnModelStart :: IO () -> OllamaConfig -> OllamaConfig-withOnModelStart f cfg = cfg {onModelStart = Just f}---- | Add a callback to be executed when a model errors.-withOnModelError :: IO () -> OllamaConfig -> OllamaConfig-withOnModelError f cfg = cfg {onModelError = Just f}---- | Add a callback to be executed when a model finishes successfully.-withOnModelFinish :: IO () -> OllamaConfig -> OllamaConfig-withOnModelFinish f cfg = cfg {onModelFinish = Just f}

@@ -1,65 +0,0 @@-{-# LANGUAGE DeriveGeneric #-}--{- |-Module      : Data.Ollama.Common.Error-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Unified error type for handling failures across the Ollama client.--== Overview--Defines the core 'OllamaError' type that wraps all potential errors-encountered while interacting with the Ollama API, including HTTP errors,-JSON decoding failures, API-specific errors, file I/O errors, and timeouts.--}-module Data.Ollama.Common.Error-  ( -- * Error Types-    OllamaError (..)--    -- * Decoding Utilities-  , DecodingErrorMessage-  , DecodingFailedValue-  ) where--import Control.Exception (Exception, IOException)-import Data.Text (Text)-import GHC.Generics-import Network.HTTP.Client (HttpException)---- | Type alias for a decoding error message string.-type DecodingErrorMessage = String---- | Type alias for the value that failed to decode.-type DecodingFailedValue = String--{- | Represents all possible errors that may occur when using the Ollama client.--@since 0.2.0.0--}-data OllamaError-  = -- | Low-level HTTP exception (connection failure, etc.)-    HttpError HttpException-  | -- | Failure to decode a JSON response, includes message and raw value-    DecodeError DecodingErrorMessage DecodingFailedValue-  | -- | Error returned from Ollama's HTTP API-    ApiError Text-  | -- | Error during file operations (e.g., loading an image)-    FileError IOException-  | -- | Mismatch in expected JSON schema or structure-    JsonSchemaError String-  | -- | Request timed out-    TimeoutError String-  | -- | Request is malformed or violates input constraints-    InvalidRequest String-  deriving (Show, Generic)--instance Eq OllamaError where-  (HttpError _) == (HttpError _) = True-  x == y = eqOllamaError x y-    where-      eqOllamaError :: OllamaError -> OllamaError -> Bool-      eqOllamaError = (==)--instance Exception OllamaError

@@ -1,191 +0,0 @@-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Common.SchemaBuilder-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : DSL for constructing structured JSON Schemas for Ollama's structured output API.--== Overview--This module defines a simple schema builder DSL for programmatically constructing-JSON Schemas compatible with the structured output features in the Ollama API.--It supports nested objects, arrays, required fields, and custom types, and-provides infix operators for a fluent and expressive syntax.--== Example--@-import Data.Ollama.Common.SchemaBuilder--let schema =-      emptyObject-        |+ ("name", JString)-        |+ ("age", JInteger)-        |++ ("address", buildSchema $-              emptyObject-                |+ ("city", JString)-                |+ ("zip", JInteger)-                |! "city"-            )-        |!! ["name", "age"]-        & buildSchema--printSchema schema-@--}-module Data.Ollama.Common.SchemaBuilder-  ( -- * Core Types-    JsonType (..)-  , Property (..)-  , Schema (..)--    -- * Schema Construction-  , emptyObject-  , addProperty-  , addObjectProperty-  , requireField-  , requireFields-  , buildSchema--    -- * Schema Utilities-  , objectOf-  , arrayOf-  , toOllamaFormat-  , printSchema--    -- * Infix Schema DSL-  , (|+)-  , (|++)-  , (|!)-  , (|!!)-  ) where--import Data.Aeson-import Data.Map.Strict qualified as HM-import Data.Text (Text)-import Data.Text qualified as T-import Data.Text.Lazy qualified as TL-import Data.Text.Lazy.Encoding qualified as T-import GHC.Generics---- | Supported JSON types for schema generation.-data JsonType-  = JString-  | JNumber-  | JInteger-  | JBoolean-  | JNull-  | -- | Array of a specific type-    JArray JsonType-  | -- | Nested object schema-    JObject Schema-  deriving (Show, Eq, Generic)--instance ToJSON JsonType where-  toJSON JString = "string"-  toJSON JNumber = "number"-  toJSON JInteger = "integer"-  toJSON JBoolean = "boolean"-  toJSON JNull = "null"-  toJSON (JArray _) = "array"-  toJSON (JObject _) = "object"---- | A named property with a given type (supports nested values).-newtype Property = Property JsonType-  deriving (Show, Eq, Generic)--instance ToJSON Property where-  toJSON (Property (JArray itemType)) =-    object ["type" .= ("array" :: Text), "items" .= Property itemType]-  toJSON (Property (JObject schema)) = toJSON schema-  toJSON (Property typ) = object ["type" .= typ]--{- | Complete schema representation.--@since 0.2.0.0--}-data Schema = Schema-  { schemaProperties :: HM.Map Text Property-  , schemaRequired :: [Text]-  }-  deriving (Show, Eq, Generic)--instance ToJSON Schema where-  toJSON (Schema props req) =-    object-      [ "type" .= ("object" :: Text)-      , "properties" .= props-      , "required" .= req-      ]---- | Internal builder for schema DSL.-newtype SchemaBuilder = SchemaBuilder Schema-  deriving (Show, Eq)---- | Create an empty schema object.-emptyObject :: SchemaBuilder-emptyObject = SchemaBuilder $ Schema HM.empty []---- | Add a simple field with a given name and type.-addProperty :: Text -> JsonType -> SchemaBuilder -> SchemaBuilder-addProperty name typ (SchemaBuilder s) =-  SchemaBuilder $ s {schemaProperties = HM.insert name (Property typ) (schemaProperties s)}---- | Add a nested object field with its own schema.-addObjectProperty :: Text -> Schema -> SchemaBuilder -> SchemaBuilder-addObjectProperty name nestedSchema (SchemaBuilder s) =-  SchemaBuilder $-    s {schemaProperties = HM.insert name (Property (JObject nestedSchema)) (schemaProperties s)}---- | Mark a field as required.-requireField :: Text -> SchemaBuilder -> SchemaBuilder-requireField name (SchemaBuilder s) =-  SchemaBuilder $ s {schemaRequired = name : schemaRequired s}---- | Mark multiple fields as required.-requireFields :: [Text] -> SchemaBuilder -> SchemaBuilder-requireFields names builder = foldr requireField builder names---- | Finalize the schema from a builder.-buildSchema :: SchemaBuilder -> Schema-buildSchema (SchemaBuilder s) = s---- | Wrap a 'SchemaBuilder' as a nested object type.-objectOf :: SchemaBuilder -> JsonType-objectOf builder = JObject (buildSchema builder)---- | Create an array of a given JSON type.-arrayOf :: JsonType -> JsonType-arrayOf = JArray---- | Convert schema into a JSON 'Value' suitable for API submission.-toOllamaFormat :: Schema -> Value-toOllamaFormat = toJSON---- | Pretty print a schema as formatted JSON.-printSchema :: Schema -> IO ()-printSchema = putStrLn . T.unpack . TL.toStrict . T.decodeUtf8 . encode---- | Infix alias for 'addProperty'.-(|+) :: SchemaBuilder -> (Text, JsonType) -> SchemaBuilder-builder |+ (name, typ) = addProperty name typ builder---- | Infix alias for 'addObjectProperty'.-(|++) :: SchemaBuilder -> (Text, Schema) -> SchemaBuilder-builder |++ (name, schema) = addObjectProperty name schema builder---- | Infix alias for 'requireField'.-(|!) :: SchemaBuilder -> Text -> SchemaBuilder-builder |! name = requireField name builder---- | Infix alias for 'requireFields'.-(|!!) :: SchemaBuilder -> [Text] -> SchemaBuilder-builder |!! names = requireFields names builder--infixl 7 |+, |++-infixl 6 |!, |!!

@@ -1,464 +0,0 @@-{-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE RecordWildCards #-}--{- |-Module      : Data.Ollama.Common.Types-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Shared data types for request and response structures used throughout the Ollama client.--== 📋 Overview--This module defines common types for working with Ollama's API, including:--- Chat messages and roles-- Text generation responses-- Structured function/tool calling-- Model metadata-- Streaming handling-- Custom model parameters--These types are consumed and returned by higher-level modules-like `Data.Ollama.Chat`, `Data.Ollama.Generate`, and others.--== Includes--- Chat message structure and roles-- Generate and chat response records-- ModelOptions and advanced config-- Structured function/tool call interfaces-- JSON format hints and schema wrapping-- Helper class 'HasDone' for streaming termination--Most types implement `ToJSON`/`FromJSON` for direct API interaction.--}-module Data.Ollama.Common.Types-  ( ModelDetails (..)-  , Format (..)-  , GenerateResponse (..)-  , Message (..)-  , Role (..)-  , ChatResponse (..)-  , HasDone (..)-  , ModelOptions (..)-  , InputTool (..)-  , FunctionDef (..)-  , FunctionParameters (..)-  , ToolCall (..)-  , OutputFunction (..)-  , Version (..)-  ) where--import Data.Aeson-import Data.Map qualified as HM-import Data.Maybe (catMaybes)-import Data.Ollama.Common.SchemaBuilder-import Data.Text (Text)-import Data.Time (UTCTime)-import GHC.Generics-import GHC.Int (Int64)---- | Metadata describing a specific model's identity and configuration.-data ModelDetails = ModelDetails-  { parentModel :: !(Maybe Text)-  -- ^ The parent model from which this model was derived, if any.-  , format :: !Text-  -- ^ The format used for the model (e.g., "gguf").-  , family :: !Text-  -- ^ The family name of the model (e.g., "llama", "mistral").-  , families :: ![Text]-  -- ^ Alternative or related family identifiers.-  , parameterSize :: !Text-  -- ^ The size of the model's parameters, typically expressed as a string (e.g., "7B").-  , quantizationLevel :: Text-  -- ^ The quantization level used (e.g., "Q4", "Q8").-  }-  deriving (Eq, Show)--instance FromJSON ModelDetails where-  parseJSON = withObject "ModelDetails" $ \v ->-    ModelDetails-      <$> v .: "parent_model"-      <*> v .: "format"-      <*> v .: "family"-      <*> v .:? "families" .!= []-      <*> v .: "parameter_size"-      <*> v .: "quantization_level"--{- | Format specification for the chat output.--@since 0.1.3.0--}-data Format = JsonFormat | SchemaFormat Schema-  deriving (Show, Eq)--instance ToJSON Format where-  toJSON JsonFormat = String "json"-  toJSON (SchemaFormat schema) = toJSON schema--{- |-Result type for 'generate' function containing the model's response and meta-information.--}-data GenerateResponse = GenerateResponse-  { model :: !Text-  -- ^ The name of the model that generated the response.-  , createdAt :: !UTCTime-  -- ^ The timestamp when the response was created.-  , genResponse :: !Text-  -- ^ The generated response from the model.-  , done :: !Bool-  -- ^ A flag indicating whether the generation process is complete.-  , totalDuration :: !(Maybe Int64)-  -- ^ Optional total duration in milliseconds for the generation process.-  , loadDuration :: !(Maybe Int64)-  -- ^ Optional load duration in milliseconds for loading the model.-  , promptEvalCount :: !(Maybe Int64)-  -- ^ Optional count of prompt evaluations during the generation process.-  , promptEvalDuration :: !(Maybe Int64)-  -- ^ Optional duration in milliseconds for evaluating the prompt.-  , evalCount :: !(Maybe Int64)-  -- ^ Optional count of evaluations during the generation process.-  , evalDuration :: !(Maybe Int64)-  -- ^ Optional duration in milliseconds for evaluations during the generation process.-  , thinking :: !(Maybe Text)-  -- ^ Thinking of reasoning models; if think is set to true-  ---  -- @since 0.2.0.0-  , doneReason :: !(Maybe Text)-  -- ^ Reason why the generation process completed (e.g., "stop", "length", "cancel").-  -- Available when the Ollama server provides completion reason information.-  ---  -- @since 0.2.1.0-  }-  deriving (Show, Eq)--instance FromJSON GenerateResponse where-  parseJSON = withObject "GenerateResponse" $ \v ->-    GenerateResponse-      <$> v .: "model"-      <*> v .: "created_at"-      <*> v .: "response"-      <*> v .: "done"-      <*> v .:? "total_duration"-      <*> v .:? "load_duration"-      <*> v .:? "prompt_eval_count"-      <*> v .:? "prompt_eval_duration"-      <*> v .:? "eval_count"-      <*> v .:? "eval_duration"-      <*> v .:? "thinking"-      <*> v .:? "done_reason"---- | Enumerated roles that can participate in a chat.-data Role = System | User | Assistant | Tool-  deriving (Show, Eq)--instance ToJSON Role where-  toJSON System = String "system"-  toJSON User = String "user"-  toJSON Assistant = String "assistant"-  toJSON Tool = String "tool"--instance FromJSON Role where-  parseJSON = withText "Role" $ \t ->-    case t of-      "system" -> pure System-      "user" -> pure User-      "assistant" -> pure Assistant-      "tool" -> pure Tool-      _ -> fail $ "Invalid Role value: " <> show t---- | Represents a message within a chat, including its role and content.-data Message = Message-  { role :: !Role-  -- ^ The role of the entity sending the message (e.g., 'User', 'Assistant').-  , content :: !Text-  -- ^ The textual content of the message.-  , images :: !(Maybe [Text])-  -- ^ Optional list of base64 encoded images that accompany the message.-  , tool_calls :: !(Maybe [ToolCall])-  -- ^ a list of tools in JSON that the model wants to use-  ---  -- @since 0.1.3.0-  , thinking :: !(Maybe Text)-  ---  -- @since 0.2.0.0-  }-  deriving (Show, Eq, Generic, ToJSON, FromJSON)--data ChatResponse = ChatResponse-  { model :: !Text-  -- ^ The name of the model that generated this response.-  , createdAt :: !UTCTime-  -- ^ The timestamp when the response was created.-  , message :: !(Maybe Message)-  -- ^ The message content of the response, if any.-  , done :: !Bool-  -- ^ Indicates whether the chat process has completed.-  , totalDuration :: !(Maybe Int64)-  -- ^ Optional total duration in milliseconds for the chat process.-  , loadDuration :: !(Maybe Int64)-  -- ^ Optional load duration in milliseconds for loading the model.-  , promptEvalCount :: !(Maybe Int64)-  -- ^ Optional count of prompt evaluations during the chat process.-  , promptEvalDuration :: !(Maybe Int64)-  -- ^ Optional duration in milliseconds for evaluating the prompt.-  , evalCount :: !(Maybe Int64)-  -- ^ Optional count of evaluations during the chat process.-  , evalDuration :: !(Maybe Int64)-  -- ^ Optional duration in milliseconds for evaluations during the chat process.-  , doneReason :: !(Maybe Text)-  -- ^ Reason why the chat process completed (e.g., "stop", "length", "cancel").-  -- Available when the Ollama server provides completion reason information.-  ---  -- @since 0.2.1.0-  }-  deriving (Show, Eq)--instance FromJSON ChatResponse where-  parseJSON = withObject "ChatResponse" $ \v ->-    ChatResponse-      <$> v .: "model"-      <*> v .: "created_at"-      <*> v .: "message"-      <*> v .: "done"-      <*> v .:? "total_duration"-      <*> v .:? "load_duration"-      <*> v .:? "prompt_eval_count"-      <*> v .:? "prompt_eval_duration"-      <*> v .:? "eval_count"-      <*> v .:? "eval_duration"-      <*> v .:? "done_reason"---- | A workaround to use done field within commonStreamHandler-class HasDone a where-  getDone :: a -> Bool--instance HasDone GenerateResponse where-  getDone GenerateResponse {..} = done--instance HasDone ChatResponse where-  getDone ChatResponse {..} = done--{- | Optional model tuning parameters that influence generation behavior.--@since 0.2.0.0--}-data ModelOptions = ModelOptions-  { numKeep :: Maybe Int-  -- ^ Number of tokens to keep from the previous context.-  , seed :: Maybe Int-  -- ^ Random seed for reproducibility.-  , numPredict :: Maybe Int-  -- ^ Maximum number of tokens to predict.-  , topK :: Maybe Int-  -- ^ Top-K sampling parameter.-  , topP :: Maybe Double-  -- ^ Top-P (nucleus) sampling parameter.-  , minP :: Maybe Double-  -- ^ Minimum probability for nucleus sampling.-  , typicalP :: Maybe Double-  -- ^ Typical sampling probability.-  , repeatLastN :: Maybe Int-  -- ^ Number of tokens to consider for repetition penalty.-  , temperature :: Maybe Double-  -- ^ Sampling temperature. Higher = more randomness.-  , repeatPenalty :: Maybe Double-  -- ^ Penalty for repeating the same tokens.-  , presencePenalty :: Maybe Double-  -- ^ Penalty for introducing new tokens.-  , frequencyPenalty :: Maybe Double-  -- ^ Penalty for frequent tokens.-  , penalizeNewline :: Maybe Bool-  -- ^ Whether to penalize newline tokens.-  , stop :: Maybe [Text]-  -- ^ List of stop sequences to end generation.-  , numa :: Maybe Bool-  -- ^ Whether to enable NUMA-aware optimizations.-  , numCtx :: Maybe Int-  -- ^ Number of context tokens.-  , numBatch :: Maybe Int-  -- ^ Batch size used during generation.-  , numGpu :: Maybe Int-  -- ^ Number of GPUs to use.-  , mainGpu :: Maybe Int-  -- ^ Index of the primary GPU to use.-  , useMmap :: Maybe Bool-  -- ^ Whether to memory-map the model.-  , numThread :: Maybe Int-  -- ^ Number of threads to use for inference.-  }-  deriving (Show, Eq)---- | Custom ToJSON instance for Options-instance ToJSON ModelOptions where-  toJSON opts =-    object $-      catMaybes-        [ ("num_keep" .=) <$> numKeep opts-        , ("seed" .=) <$> seed opts-        , ("num_predict" .=) <$> numPredict opts-        , ("top_k" .=) <$> topK opts-        , ("top_p" .=) <$> topP opts-        , ("min_p" .=) <$> minP opts-        , ("typical_p" .=) <$> typicalP opts-        , ("repeat_last_n" .=) <$> repeatLastN opts-        , ("temperature" .=) <$> temperature opts-        , ("repeat_penalty" .=) <$> repeatPenalty opts-        , ("presence_penalty" .=) <$> presencePenalty opts-        , ("frequency_penalty" .=) <$> frequencyPenalty opts-        , ("penalize_newline" .=) <$> penalizeNewline opts-        , ("stop" .=) <$> stop opts-        , ("numa" .=) <$> numa opts-        , ("num_ctx" .=) <$> numCtx opts-        , ("num_batch" .=) <$> numBatch opts-        , ("num_gpu" .=) <$> numGpu opts-        , ("main_gpu" .=) <$> mainGpu opts-        , ("use_mmap" .=) <$> useMmap opts-        , ("num_thread" .=) <$> numThread opts-        ]---- | A wrapper for the Ollama engine version string.-newtype Version = Version Text-  deriving (Eq, Show)--instance FromJSON Version where-  parseJSON = withObject "version" $ \v -> do-    Version <$> v .: "version"--{- | Represents a tool that can be used in the conversation.--@since 0.2.0.0--}-data InputTool = InputTool-  { toolType :: Text-  -- ^ The type of the tool-  , function :: FunctionDef-  -- ^ The function associated with the tool-  }-  deriving (Show, Eq, Generic)--instance ToJSON InputTool where-  toJSON InputTool {..} =-    object-      [ "type" .= toolType-      , "function" .= function-      ]--instance FromJSON InputTool where-  parseJSON = withObject "Tool" $ \v ->-    InputTool-      <$> v .: "type"-      <*> v .: "function"--{- | Represents a function that can be called by the model.--@since 0.2.0.0--}-data FunctionDef = FunctionDef-  { functionName :: Text-  -- ^ The name of the function-  , functionDescription :: Maybe Text-  -- ^ Optional description of the function-  , functionParameters :: Maybe FunctionParameters-  -- ^ Optional parameters for the function-  , functionStrict :: Maybe Bool-  -- ^ Optional strictness flag-  }-  deriving (Show, Eq, Generic)--instance ToJSON FunctionDef where-  toJSON FunctionDef {..} =-    object $-      [ "name" .= functionName-      ]-        ++ maybe [] (\d -> ["description" .= d]) functionDescription-        ++ maybe [] (\p -> ["parameters" .= p]) functionParameters-        ++ maybe [] (\s -> ["strict" .= s]) functionStrict--instance FromJSON FunctionDef where-  parseJSON = withObject "Function" $ \v ->-    FunctionDef-      <$> v .: "name"-      <*> v .:? "description"-      <*> v .:? "parameters"-      <*> v .:? "strict"--{- | Parameters definition for a function call used in structured output or tool calls.--@since 0.2.0.0--}-data FunctionParameters = FunctionParameters-  { parameterType :: Text-  -- ^ Type of the parameter (usually "object").-  , parameterProperties :: Maybe (HM.Map Text FunctionParameters)-  -- ^ Optional nested parameters as a property map.-  , requiredParams :: Maybe [Text]-  -- ^ List of required parameter names.-  , additionalProperties :: Maybe Bool-  -- ^ Whether additional (unspecified) parameters are allowed.-  }-  deriving (Show, Eq)--instance ToJSON FunctionParameters where-  toJSON FunctionParameters {..} =-    object-      [ "type" .= parameterType-      , "properties" .= parameterProperties-      , "required" .= requiredParams-      , "additionalProperties" .= additionalProperties-      ]--instance FromJSON FunctionParameters where-  parseJSON = withObject "parameters" $ \v ->-    FunctionParameters-      <$> v .: "type"-      <*> v .: "properties"-      <*> v .: "required"-      <*> v .: "additionalProperties"--{- | A single tool call returned from the model, containing the function to be invoked.--@since 0.2.0.0--}-newtype ToolCall = ToolCall-  { outputFunction :: OutputFunction-  -- ^ The function the model intends to call, with arguments.-  }-  deriving (Show, Eq)--{- | Output representation of a function to be called, including its name and arguments.--@since 0.2.0.0--}-data OutputFunction = OutputFunction-  { outputFunctionName :: Text-  -- ^ The name of the function to invoke.-  , arguments :: HM.Map Text Value-  -- ^ A key-value map of argument names to values (JSON values).-  }-  deriving (Eq, Show)--instance ToJSON OutputFunction where-  toJSON OutputFunction {..} =-    object-      [ "name" .= outputFunctionName-      , "arguments" .= arguments-      ]--instance FromJSON OutputFunction where-  parseJSON = withObject "function" $ \v ->-    OutputFunction-      <$> v .: "name"-      <*> v .: "arguments"--instance ToJSON ToolCall where-  toJSON ToolCall {..} = object ["function" .= outputFunction]--instance FromJSON ToolCall where-  parseJSON = withObject "tool_calls" $ \v ->-    ToolCall <$> v .: "function"

@@ -1,303 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE RecordWildCards #-}--{- |-Module      : Data.Ollama.Common.Utils-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Utility functions for interacting with the Ollama API, including image encoding, HTTP request handling, and retry logic.--This module provides helper functions for common tasks in the Ollama client, such as encoding images to Base64,-sending HTTP requests to the Ollama API, handling streaming and non-streaming responses, and managing retries for failed requests.-It also includes a default model options configuration and a function to retrieve the Ollama server version.--The functions in this module are used internally by other modules like 'Data.Ollama.Chat' and 'Data.Ollama.Generate' but can also be used directly for custom API interactions.--}-module Data.Ollama.Common.Utils-  ( -- * Image Encoding-    encodeImage--    -- * HTTP Request Handling-  , withOllamaRequest-  , commonNonStreamingHandler-  , commonStreamHandler-  , nonJsonHandler--    -- * Model Options-  , defaultModelOptions--    -- * Retry Logic-  , withRetry--    -- * Version Retrieval-  , getVersion-  ) where--import Control.Concurrent (threadDelay)-import Control.Exception (IOException, try)-import Data.Aeson-import Data.ByteString qualified as BS-import Data.ByteString.Base64 qualified as Base64-import Data.ByteString.Lazy qualified as BSL-import Data.Char (toLower)-import Data.Maybe (fromMaybe)-import Data.Ollama.Common.Config-import Data.Ollama.Common.Error-import Data.Ollama.Common.Error qualified as Error-import Data.Ollama.Common.Types-import Data.Text (Text)-import Data.Text qualified as T-import Data.Text.Encoding qualified as TE-import Network.HTTP.Client-import Network.HTTP.Client.TLS-import Network.HTTP.Types (Status (statusCode))-import System.Directory-import System.FilePath---- | List of supported image file extensions for 'encodeImage'.-supportedExtensions :: [String]-supportedExtensions = [".jpg", ".jpeg", ".png"]---- | Safely read a file, returning an 'Either' with an 'IOException' on failure.-safeReadFile :: FilePath -> IO (Either IOException BS.ByteString)-safeReadFile = try . BS.readFile---- | Read a file if it exists, returning 'Nothing' if it does not.-asPath :: FilePath -> IO (Maybe BS.ByteString)-asPath filePath = do-  exists <- doesFileExist filePath-  if exists-    then either (const Nothing) Just <$> safeReadFile filePath-    else return Nothing---- | Check if a file has a supported image extension.-isSupportedExtension :: FilePath -> Bool-isSupportedExtension p = map toLower (takeExtension p) `elem` supportedExtensions--{- | Encodes an image file to Base64 format.--Takes a file path to an image (jpg, jpeg, or png) and returns its data encoded as a Base64 'Text'.-Returns 'Nothing' if the file extension is unsupported or the file cannot be read.-This is useful for including images in API requests that expect Base64-encoded data, such as 'GenerateOps' images field.--}-encodeImage :: FilePath -> IO (Maybe Text)-encodeImage filePath = do-  if not (isSupportedExtension filePath)-    then return Nothing-    else do-      maybeContent <- asPath filePath-      return $ fmap (TE.decodeUtf8 . Base64.encode) maybeContent--{- | Executes an action with retry logic for recoverable errors.--Retries the given action up to the specified number of times with a delay (in seconds) between attempts.-Only retries on recoverable errors such as HTTP errors, timeouts, JSON schema errors, or decoding errors.--}-withRetry ::-  -- | Number of retries-  Int ->-  -- | Delay between retries in seconds-  Int ->-  -- | Action to execute, returning 'Either' 'OllamaError' or a result-  IO (Either OllamaError a) ->-  IO (Either OllamaError a)-withRetry 0 _ action = action-withRetry retries delaySeconds action = do-  result <- action-  case result of-    Left err | isRetryableError err -> do-      threadDelay (delaySeconds * 1000000) -- Convert to microseconds-      withRetry (retries - 1) delaySeconds action-    _ -> return result-  where-    isRetryableError (HttpError _) = True-    isRetryableError (TimeoutError _) = True-    isRetryableError (JsonSchemaError _) = True-    isRetryableError (DecodeError _ _) = True-    isRetryableError _ = False--{- | Sends an HTTP request to the Ollama API.--A unified function for making API requests to the Ollama server. Supports both GET and POST methods,-customizable payloads, and optional configuration. The response is processed by the provided handler.--}-withOllamaRequest ::-  forall payload response.-  (ToJSON payload) =>-  -- | API endpoint-  Text ->-  -- | HTTP method ("GET" or "POST")-  BS.ByteString ->-  -- | Optional request payload (must implement 'ToJSON')-  Maybe payload ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig')-  Maybe OllamaConfig ->-  -- | Response handler to process the HTTP response-  (Response BodyReader -> IO (Either OllamaError response)) ->-  IO (Either OllamaError response)-withOllamaRequest endpoint reqMethod mbPayload mbOllamaConfig handler = do-  let OllamaConfig {..} = fromMaybe defaultOllamaConfig mbOllamaConfig-      fullUrl = T.unpack $ hostUrl <> endpoint-      timeoutMicros = timeout * 1000000-  manager <- case commonManager of-    Nothing ->-      newTlsManagerWith-        tlsManagerSettings {managerResponseTimeout = responseTimeoutMicro timeoutMicros}-    Just m -> pure m-  eRequest <- try $ parseRequest fullUrl-  case eRequest of-    Left ex -> return $ Left $ Error.HttpError ex-    Right req -> do-      let request =-            req-              { method = reqMethod-              , requestBody =-                  maybe mempty (RequestBodyLBS . encode) mbPayload-              }-          retryCnt = fromMaybe 0 retryCount-          retryDelay_ = fromMaybe 1 retryDelay-      withRetry retryCnt retryDelay_ $ do-        fromMaybe (pure ()) onModelStart-        eResponse <- try $ withResponse request manager handler-        case eResponse of-          Left ex -> do-            fromMaybe (pure ()) onModelError-            case ex of-              (HttpExceptionRequest _ ResponseTimeout) ->-                return $ Left $ Error.TimeoutError "No response from LLM yet"-              _ -> return $ Left $ Error.HttpError ex-          Right result -> do-            fromMaybe (pure ()) onModelFinish-            return result--{- | Handles non-streaming API responses.--Processes an HTTP response, accumulating all chunks until EOF and decoding the result as JSON.-Returns an 'Either' with an 'OllamaError' on failure or the decoded response on success.-Suitable for APIs that return a single JSON response.--}-commonNonStreamingHandler ::-  FromJSON a =>-  Response BodyReader ->-  IO (Either OllamaError a)-commonNonStreamingHandler resp = do-  let bodyReader = responseBody resp-      respStatus = statusCode $ responseStatus resp-  if respStatus >= 200 && respStatus < 300-    then do-      finalBs <- readFullBuff BS.empty bodyReader-      case eitherDecode (BSL.fromStrict finalBs) of-        Left err -> pure . Left $ Error.DecodeError err (show finalBs)-        Right decoded -> pure . Right $ decoded-    else Left . ApiError . TE.decodeUtf8 <$> brRead bodyReader--{- | Accumulates response chunks into a single ByteString.--Internal helper function to read all chunks from a 'BodyReader' until EOF.--}-readFullBuff :: BS.ByteString -> BodyReader -> IO BS.ByteString-readFullBuff acc reader = do-  chunk <- brRead reader-  if BS.null chunk-    then pure acc-    else readFullBuff (acc `BS.append` chunk) reader--{- | Handles streaming API responses.--Processes a streaming HTTP response, decoding each chunk as JSON and passing it to the provided-'sendChunk' function. The 'flush' function is called after each chunk. Stops when the response-indicates completion (via 'HasDone'). Returns the final decoded response or an error.--}-commonStreamHandler ::-  (HasDone a, FromJSON a) =>-  -- | Function to handle each decoded chunk-  (a -> IO (), IO ()) ->-  Response BodyReader ->-  IO (Either OllamaError a)-commonStreamHandler (sendChunk, onComplete) resp = go mempty-  where-    go acc = do-      bs <- brRead $ responseBody resp-      if BS.null bs-        then do-          case eitherDecode (BSL.fromStrict acc) of-            Left err -> pure $ Left $ Error.DecodeError err (show acc)-            Right decoded -> pure $ Right decoded-        else do-          let chunk = BSL.fromStrict bs-          case eitherDecode chunk of-            Left err -> return $ Left $ Error.DecodeError err (show acc)-            Right res -> do-              sendChunk res-              if getDone res then onComplete >> return (Right res) else go (acc <> bs)--{- | Handles non-JSON API responses.--Processes an HTTP response, accumulating all chunks into a 'ByteString'. Returns the accumulated-data on success (HTTP status 2xx) or an 'ApiError' on failure.--}-nonJsonHandler :: Response BodyReader -> IO (Either OllamaError BS.ByteString)-nonJsonHandler resp = do-  let bodyReader = responseBody resp-      respStatus = statusCode $ responseStatus resp-  if respStatus >= 200 && respStatus < 300-    then Right <$> readFullBuff BS.empty bodyReader-    else Left . ApiError . TE.decodeUtf8 <$> brRead bodyReader--{- | Default model options for API requests.--Provides a default 'ModelOptions' configuration with all fields set to 'Nothing',-suitable as a starting point for customizing model parameters like temperature or token limits.--Example:-->>> let opts = defaultModelOptions { temperature = Just 0.7 }--}-defaultModelOptions :: ModelOptions-defaultModelOptions =-  ModelOptions-    { numKeep = Nothing-    , seed = Nothing-    , numPredict = Nothing-    , topK = Nothing-    , topP = Nothing-    , minP = Nothing-    , typicalP = Nothing-    , repeatLastN = Nothing-    , temperature = Nothing-    , repeatPenalty = Nothing-    , presencePenalty = Nothing-    , frequencyPenalty = Nothing-    , penalizeNewline = Nothing-    , stop = Nothing-    , numa = Nothing-    , numCtx = Nothing-    , numBatch = Nothing-    , numGpu = Nothing-    , mainGpu = Nothing-    , useMmap = Nothing-    , numThread = Nothing-    }--{- | Retrieves the Ollama server version.--Sends a GET request to the @\/api\/version@ endpoint and returns the server version-as a 'Version' wrapped in an 'Either' 'OllamaError'.--Example:-->>> getVersion--@since 0.2.0.0--}-getVersion :: IO (Either OllamaError Version)-getVersion = do-  withOllamaRequest-    "/api/version"-    "GET"-    (Nothing :: Maybe Value)-    Nothing-    commonNonStreamingHandler

@@ -1,186 +0,0 @@-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Conversation-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Conversation management for the Ollama client, including storage and retrieval of chat sessions.--This module provides types and functions for managing conversations in the Ollama client. It defines-a 'Conversation' type to represent a chat session, a 'ConversationStore' typeclass for storage operations,-and an in-memory implementation using 'InMemoryStore' and 'ConvoM'. The module supports saving, loading,-listing, and deleting conversations, with thread-safe operations using STM (Software Transactional Memory).--The 'Conversation' type includes metadata such as a unique ID, messages, model name, and timestamps.-The 'ConversationStore' typeclass defines a generic interface for conversation storage, while 'InMemoryStore'-provides a concrete in-memory implementation. The 'ConvoM' monad integrates with 'InMemoryStore' for-monadic operations.--Example:-->>> store <- initInMemoryStore->>> let conv = Conversation "conv1" [userMessage "Hello!"] "gemma3" <$> getCurrentTime <*> getCurrentTime->>> runInMemoryConvo store $ saveConversation conv->>> runInMemoryConvo store $ loadConversation "conv1"-Just (Conversation ...)--}-module Data.Ollama.Conversation-  ( -- * Conversation Types-    Conversation (..)-  , ConversationStore (..)--    -- * In-Memory Store-  , InMemoryStore (..)-  , ConvoM (..)-  , initInMemoryStore-  , runInMemoryConvo--    -- * Validation-  , validateConversation-  ) where--import Control.Concurrent.STM-import Control.Monad.Reader-import Data.Aeson (FromJSON, ToJSON)-import Data.Map.Strict (Map)-import Data.Map.Strict qualified as Map-import Data.Ollama.Common.Types-import Data.Text (Text)-import Data.Text qualified as T-import Data.Time (UTCTime, getCurrentTime)-import GHC.Generics (Generic)--{- | Represents a chat session with metadata and messages.--Stores a conversation's unique identifier, list of messages, model name, creation time, and last updated time.--}-data Conversation = Conversation-  { conversationId :: !Text-  -- ^ Unique identifier for the conversation.-  , messages :: ![Message]-  -- ^ List of messages in the conversation.-  , model :: !Text-  -- ^ Name of the model used in the conversation (e.g., "gemma3").-  , createdAt :: !UTCTime-  -- ^ Timestamp when the conversation was created.-  , lastUpdated :: !UTCTime-  -- ^ Timestamp when the conversation was last updated.-  }-  deriving (Show, Eq, Generic)--instance ToJSON Conversation-instance FromJSON Conversation--{- | Typeclass defining operations for storing and managing conversations.--Provides methods for saving, loading, listing, and deleting conversations in a monadic context.--@since 0.2.0.0--}-class Monad m => ConversationStore m where-  -- | Saves a conversation to the store.-  ---  -- Validates the conversation and updates its 'lastUpdated' timestamp before saving.-  saveConversation :: Conversation -> m ()--  -- | Loads a conversation by its ID.-  ---  -- Returns 'Just' the conversation if found, or 'Nothing' if not.-  loadConversation :: Text -> m (Maybe Conversation)--  -- | Lists all conversations in the store.-  listConversations :: m [Conversation]--  -- | Deletes a conversation by its ID.-  ---  -- Returns 'True' if the conversation was found and deleted, 'False' otherwise.-  deleteConversation :: Text -> m Bool--{- | In-memory conversation store using a 'TVar' for thread-safe operations.--Stores conversations in a 'Map' keyed by conversation IDs, wrapped in a 'TVar' for concurrent access.--}-newtype InMemoryStore = InMemoryStore (TVar (Map Text Conversation))--{- | Monad for operations with 'InMemoryStore'.--A wrapper around 'ReaderT' that provides access to an 'InMemoryStore' in a monadic context.--}-newtype ConvoM a = ConvoM {runConvoM :: ReaderT InMemoryStore IO a}-  deriving (Functor, Applicative, Monad, MonadIO, MonadReader InMemoryStore)--{- | Runs a 'ConvoM' action with the given 'InMemoryStore'.--Executes a monadic computation in the context of an in-memory store.--Example:-->>> store <- initInMemoryStore->>> runInMemoryConvo store $ saveConversation conv--}-runInMemoryConvo :: InMemoryStore -> ConvoM a -> IO a-runInMemoryConvo store = flip runReaderT store . runConvoM--instance ConversationStore ConvoM where-  saveConversation conv = do-    case validateConversation conv of-      Left err -> liftIO $ putStrLn ("Validation error: " <> T.unpack err)-      Right validConv -> do-        now <- liftIO getCurrentTime-        let updatedConv = validConv {lastUpdated = now}-        InMemoryStore ref <- ask-        liftIO . atomically $ modifyTVar' ref (Map.insert (conversationId updatedConv) updatedConv)--  loadConversation cid = do-    InMemoryStore ref <- ask-    convs <- liftIO $ readTVarIO ref-    return $ Map.lookup cid convs--  listConversations = do-    InMemoryStore ref <- ask-    convs <- liftIO $ readTVarIO ref-    return $ Map.elems convs--  deleteConversation cid = do-    InMemoryStore ref <- ask-    liftIO . atomically $ do-      convs <- readTVar ref-      if Map.member cid convs-        then do-          writeTVar ref (Map.delete cid convs)-          return True-        else return False--{- | Validates a 'Conversation' to ensure required fields are non-empty.--Checks that the 'conversationId' is not empty and that the 'messages' list contains at least one message.-Returns 'Right' with the validated conversation or 'Left' with an error message.--Example:-->>> let conv = Conversation "" [] "gemma3" time time->>> validateConversation conv-Left "Conversation ID cannot be empty"--}-validateConversation :: Conversation -> Either Text Conversation-validateConversation conv-  | T.null (conversationId conv) = Left "Conversation ID cannot be empty"-  | null (messages conv) = Left "Conversation must have at least one message"-  | otherwise = Right conv--{- | Creates a new empty in-memory conversation store.--Initializes an 'InMemoryStore' with an empty 'Map' wrapped in a 'TVar' for thread-safe operations.--Example:-->>> store <- initInMemoryStore->>> runInMemoryConvo store $ listConversations-[]--}-initInMemoryStore :: IO InMemoryStore-initInMemoryStore = InMemoryStore <$> newTVarIO Map.empty

@@ -1,86 +0,0 @@-{-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Copy-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for copying models in the Ollama client.--This module provides functions to copy a model from a source name to a destination name using the Ollama API.-It includes both an IO-based function ('copyModel') and a monadic version ('copyModelM') for use in-'MonadIO' contexts. The copy operation is performed via a POST request to the @\/api\/copy@ endpoint.--Example:-->>> copyModel "gemma3" "gemma3-copy" Nothing-Right ()--}-module Data.Ollama.Copy-  ( -- * Copy Model API-    copyModel-  , copyModelM-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Ollama.Common.Config (OllamaConfig (..))-import Data.Ollama.Common.Error (OllamaError)-import Data.Ollama.Common.Utils (nonJsonHandler, withOllamaRequest)-import Data.Text (Text)-import GHC.Generics---- | Configuration for copying a model.-data CopyModelOps = CopyModelOps-  { source :: !Text-  -- ^ The name of the source model to copy.-  , destination :: !Text-  -- ^ The name of the destination model.-  }-  deriving (Show, Eq, Generic, ToJSON)--{- | Copies a model from a source name to a destination name.--Sends a POST request to the @\/api\/copy@ endpoint with the source and destination model names.-Returns 'Right ()' on success or 'Left' with an 'OllamaError' on failure.-Example:-->>> copyModel "gemma3" "gemma3-copy" Nothing-Right ()--}-copyModel ::-  -- | Source model name-  Text ->-  -- | Destination model name-  Text ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError ())-copyModel-  source_-  destination_-  mbConfig = do-    let reqBody = CopyModelOps {source = source_, destination = destination_}-    withOllamaRequest-      "/api/copy"-      "POST"-      (Just reqBody)-      mbConfig-      (fmap (const () <$>) . nonJsonHandler)--{- | MonadIO version of 'copyModel' for use in monadic contexts.--Lifts the 'copyModel' function into a 'MonadIO' context, allowing it to be used in monadic computations.--Example:-->>> import Control.Monad.IO.Class->>> runReaderT (copyModelM "gemma3" "gemma3-copy" Nothing) someContext-Right ()--}-copyModelM :: MonadIO m => Text -> Text -> Maybe OllamaConfig -> m (Either OllamaError ())-copyModelM s d mbCfg = liftIO $ copyModel s d mbCfg

@@ -1,214 +0,0 @@-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE RecordWildCards #-}--{- |-Module      : Data.Ollama.Create-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for creating new models in the Ollama client.--This module provides functions to create new models in the Ollama API. Models can be created from:--- Another existing model (using 'from' parameter)-- A safetensors directory (using 'files' parameter)-- A GGUF file (using 'files' parameter)--The create operation is performed via a POST request to the @\/api\/create@ endpoint, with streaming-support for progress updates. The module supports model quantization, custom templates, system prompts,-parameters, and LORA adapters.--Example creating from existing model:-->>> let ops = defaultCreateOps { modelName = "mario", fromModel = Just "llama3.2", systemPrompt = Just "You are Mario from Super Mario Bros." }->>> createModel ops Nothing-Creating model...-Success--Example quantizing a model:-->>> let ops = defaultCreateOps { modelName = "llama3.2:quantized", fromModel = Just "llama3.2:3b-instruct-fp16", quantizeType = Just Q4_K_M }->>> createModel ops Nothing-Quantizing model...-Success--}-module Data.Ollama.Create-  ( -- * Create Model API-    createModel-  , createModelM--    -- * Configuration Types-  , CreateOps (..)-  , defaultCreateOps--    -- * Response Types-  , CreateResp (..)--    -- * Quantization Types-  , QuantizationType (..)-  ) where--import Control.Monad (void)-import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Map.Strict (Map)-import Data.Maybe (catMaybes)-import Data.Ollama.Common.Config (OllamaConfig)-import Data.Ollama.Common.Types (HasDone (getDone), Message, ModelOptions)-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)-import GHC.Generics (Generic)-import GHC.Int (Int64)---- | Quantization types supported by Ollama.-data QuantizationType-  = -- | Recommended quantization type-    Q4_K_M-  | -- | Alternative quantization type-    Q4_K_S-  | -- | Recommended quantization type-    Q8_0-  deriving (Show, Eq, Generic)--instance ToJSON QuantizationType where-  toJSON Q4_K_M = String "q4_K_M"-  toJSON Q4_K_S = String "q4_K_S"-  toJSON Q8_0 = String "q8_0"--instance FromJSON QuantizationType where-  parseJSON = withText "QuantizationType" $ \t ->-    case t of-      "q4_K_M" -> pure Q4_K_M-      "q4_K_S" -> pure Q4_K_S-      "q8_0" -> pure Q8_0-      _ -> fail $ "Invalid QuantizationType: " <> show t---- | Configuration for creating a new model.-data CreateOps = CreateOps-  { modelName :: !Text-  -- ^ The name of the model to create.-  , fromModel :: !(Maybe Text)-  -- ^ Optional name of an existing model to create the new model from.-  , files :: !(Maybe (Map Text Text))-  -- ^ Optional dictionary of file names to SHA256 digests of blobs to create the model from.-  , adapters :: !(Maybe (Map Text Text))-  -- ^ Optional dictionary of file names to SHA256 digests of blobs for LORA adapters.-  , template :: !(Maybe Text)-  -- ^ Optional prompt template for the model.-  , license :: !(Maybe [Text])-  -- ^ Optional list of strings containing the license(s) for the model.-  , systemPrompt :: !(Maybe Text)-  -- ^ Optional system prompt for the model.-  , parameters :: !(Maybe ModelOptions)-  -- ^ Optional parameters for the model.-  , messages :: !(Maybe [Message])-  -- ^ Optional list of message objects used to create a conversation.-  , stream :: !(Maybe Bool)-  -- ^ Optional flag to enable streaming progress updates.-  , quantizeType :: !(Maybe QuantizationType)-  -- ^ Optional quantization type for quantizing a non-quantized model.-  }-  deriving (Show, Eq, Generic)---- | Default configuration for creating a model.-defaultCreateOps :: Text -> CreateOps-defaultCreateOps name =-  CreateOps-    { modelName = name-    , fromModel = Nothing-    , files = Nothing-    , adapters = Nothing-    , template = Nothing-    , license = Nothing-    , systemPrompt = Nothing-    , parameters = Nothing-    , messages = Nothing-    , stream = Nothing-    , quantizeType = Nothing-    }---- | Response type for model creation operations.-data CreateResp = CreateResp-  { status :: !Text-  -- ^ The status of the create operation (e.g., "success", "reading model metadata").-  , digest :: !(Maybe Text)-  -- ^ Optional digest (hash) of the model layer being processed.-  , total :: !(Maybe Int64)-  -- ^ Optional total size in bytes for quantization operations.-  , completed :: !(Maybe Int64)-  -- ^ Optional number of bytes completed for quantization operations.-  }-  deriving (Show, Eq, Generic)--instance HasDone CreateResp where-  getDone CreateResp {..} = status == "success"--instance ToJSON CreateOps where-  toJSON CreateOps {..} =-    object $-      catMaybes-        [ Just ("model" .= modelName)-        , ("from" .=) <$> fromModel-        , ("files" .=) <$> files-        , ("adapters" .=) <$> adapters-        , ("template" .=) <$> template-        , ("license" .=) <$> license-        , ("system" .=) <$> systemPrompt-        , ("parameters" .=) <$> parameters-        , ("messages" .=) <$> messages-        , ("stream" .=) <$> stream-        , ("quantize" .=) <$> quantizeType-        ]--instance FromJSON CreateResp where-  parseJSON = withObject "CreateResp" $ \v ->-    CreateResp-      <$> v .: "status"-      <*> v .:? "digest"-      <*> v .:? "total"-      <*> v .:? "completed"--{- | Creates a new model according to the provided configuration.--Sends a POST request to the @\/api\/create@ endpoint to create a model. The model can be created from:--- Another existing model (specify 'fromModel')-- A safetensors directory (specify 'files' with file name to SHA256 digest mappings)-- A GGUF file (specify 'files' with file name to SHA256 digest mapping)--Supports quantization, custom templates, system prompts, parameters, and LORA adapters.-Prints progress messages to the console during creation.--}-createModel ::-  -- | Model creation configuration-  CreateOps ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO ()-createModel createOps mbConfig =-  void $-    withOllamaRequest-      "/api/create"-      "POST"-      (Just createOps)-      mbConfig-      (commonStreamHandler (onToken, pure ()))-  where-    onToken :: CreateResp -> IO ()-    onToken CreateResp {..} = case (total, completed) of-      (Just t, Just c) -> putStrLn $ "Progress: " <> show c <> "/" <> show t <> " bytes"-      _ -> putStrLn $ "Status: " <> show status--{- | MonadIO version of 'createModel' for use in monadic contexts.--Lifts the 'createModel' function into a 'MonadIO' context, allowing it to be used in monadic computations.--}-createModelM ::-  MonadIO m =>-  CreateOps ->-  Maybe OllamaConfig ->-  m ()-createModelM createOps mbCfg = liftIO $ createModel createOps mbCfg

@@ -1,71 +0,0 @@-{-# LANGUAGE DerivingStrategies #-}-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Delete-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for deleting models in the Ollama client.--This module provides functions to delete a model from the Ollama server using its name. It includes-both an IO-based function ('deleteModel') and a monadic version ('deleteModelM') for use in-'MonadIO' contexts. The delete operation is performed via a DELETE request to the @\/api\/delete@ endpoint.--Example:-->>> deleteModel "gemma3" Nothing-Right ()--}-module Data.Ollama.Delete-  ( -- * Delete Model API-    deleteModel-  , deleteModelM-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Ollama.Common.Config (OllamaConfig (..))-import Data.Ollama.Common.Error (OllamaError)-import Data.Ollama.Common.Utils (nonJsonHandler, withOllamaRequest)-import Data.Text (Text)---- | Request payload for deleting a model.-newtype DeleteModelReq-  = -- | The name of the model to delete.-    DeleteModelReq {name :: Text}-  deriving newtype (Show, Eq)--instance ToJSON DeleteModelReq where-  toJSON (DeleteModelReq name_) = object ["name" .= name_]--{- | Deletes a model from the Ollama server.--Sends a DELETE request to the "/api/delete" endpoint with the specified model name.-Returns 'Right ()' on success or 'Left' with an 'OllamaError' on failure.--}-deleteModel ::-  -- | Model name to delete-  Text ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError ())-deleteModel modelName mbConfig = do-  let reqBody = DeleteModelReq {name = modelName}-  withOllamaRequest-    "/api/delete"-    "DELETE"-    (Just reqBody)-    mbConfig-    (fmap (const () <$>) . nonJsonHandler)--{- | MonadIO version of 'deleteModel' for use in monadic contexts.--Lifts the 'deleteModel' function into a  context,-allowing it to be used in monadic computations.--}-deleteModelM :: MonadIO m => Text -> Maybe OllamaConfig -> m (Either OllamaError ())-deleteModelM t mbCfg = liftIO $ deleteModel t mbCfg

@@ -1,189 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Embeddings-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for generating text embeddings using the Ollama API.--This module provides functions to generate text embeddings from an Ollama model. It includes both-high-level ('embedding', 'embeddingM') and low-level ('embeddingOps', 'embeddingOpsM') APIs for-generating embeddings, with support for customizing model options, truncation, and keep-alive settings.-The embeddings are returned as a list of float vectors, suitable for tasks like semantic search or-text similarity analysis.--The 'EmbeddingOps' type configures the embedding request, and 'EmbeddingResp' represents the response-containing the model name and the generated embeddings. The 'defaultEmbeddingOps' provides a default-configuration for convenience.--Example:-->>> embedding "llama3.2" ["Hello, world!"]-Right (EmbeddingResp "llama3.2" [[0.1, 0.2, ...]])--}-module Data.Ollama.Embeddings-  ( -- * Embedding API-    embedding-  , embeddingOps-  , embeddingM-  , embeddingOpsM--    -- * Configuration and Response Types-  , defaultEmbeddingOps-  , EmbeddingOps (..)-  , EmbeddingResp (..)--    -- * Model Options-  , ModelOptions (..)-  , defaultModelOptions-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Ollama.Common.Config (OllamaConfig)-import Data.Ollama.Common.Error (OllamaError)-import Data.Ollama.Common.Types (ModelOptions (..))-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)--{- | Default configuration for embedding requests.--Provides a default 'EmbeddingOps' with the "llama3.2" model, an empty input list, and no additional options.-Can be customized by modifying fields as needed.--}-defaultEmbeddingOps :: EmbeddingOps-defaultEmbeddingOps =-  EmbeddingOps-    { modelName = "nomic-embed-text"-    , input = []-    , truncateInput = Nothing-    , keepAlive = Nothing-    , modelOptions = Nothing-    , dimensions = Nothing-    }---- | Configuration for an embedding request.-data EmbeddingOps = EmbeddingOps-  { modelName :: !Text-  -- ^ The name of the model to use for generating embeddings (e.g., "llama3.2").-  , input :: ![Text]-  -- ^ List of input texts to generate embeddings for.-  , truncateInput :: !(Maybe Bool)-  -- ^ Optional flag to truncate input if it exceeds model limits.-  , keepAlive :: !(Maybe Int)-  -- ^ Optional override for the keep-alive timeout in minutes.-  , modelOptions :: !(Maybe ModelOptions)-  -- ^ Optional model parameters (e.g., temperature) as specified in the Modelfile.-  ---  -- @since 0.2.0.0-  , dimensions :: !(Maybe Int)-  -- ^ number of dimensions for the embedding-  ---  -- @since 0.2.1.0-  }-  deriving (Show, Eq)---- | Response type for an embedding request.-data EmbeddingResp = EmbeddingResp-  { respondedModel :: !Text-  -- ^ The name of the model that generated the embeddings.-  , respondedEmbeddings :: ![[Float]]-  -- ^ List of embedding vectors, one for each input text.-  }-  deriving (Show, Eq)--instance FromJSON EmbeddingResp where-  parseJSON = withObject "EmbeddingResp" $ \v ->-    EmbeddingResp-      <$> v .: "model"-      <*> v .: "embeddings"--instance ToJSON EmbeddingOps where-  toJSON (EmbeddingOps model_ input_ truncate' keepAlive_ ops dimensions_) =-    object-      [ "model" .= model_-      , "input" .= input_-      , "truncate" .= truncate'-      , "keep_alive" .= keepAlive_-      , "options" .= ops-      , "dimensions" .= dimensions_-      ]--{- | Generates embeddings for a list of input texts with full configuration.--Sends a POST request to the @\/api\/embed@ endpoint to generate embeddings for the provided inputs.-Allows customization of truncation, keep-alive settings, model options, and Ollama configuration.-Returns 'Right' with an 'EmbeddingResp' on success or 'Left' with an 'OllamaError' on failure.--}-embeddingOps ::-  -- | Model name-  Text ->-  -- | List of input texts-  [Text] ->-  -- | Optional truncation flag-  Maybe Bool ->-  -- | Optional keep-alive timeout in minutes-  Maybe Int ->-  -- | Optional model options-  Maybe ModelOptions ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe Int ->-  Maybe OllamaConfig ->-  IO (Either OllamaError EmbeddingResp)-embeddingOps modelName_ input_ mTruncate mKeepAlive mbOptions mbDimensions mbConfig = do-  withOllamaRequest-    "/api/embed"-    "POST"-    ( Just $-        EmbeddingOps-          { modelName = modelName_-          , input = input_-          , truncateInput = mTruncate-          , keepAlive = mKeepAlive-          , modelOptions = mbOptions-          , dimensions = mbDimensions-          }-    )-    mbConfig-    commonNonStreamingHandler--{- | Simplified API for generating embeddings.--A higher-level function that generates embeddings using default settings for truncation, keep-alive,-model options, and Ollama configuration. Suitable for basic use cases.--}-embedding ::-  -- | Model name-  Text ->-  -- | List of input texts-  [Text] ->-  IO (Either OllamaError EmbeddingResp)-embedding modelName_ input_ =-  embeddingOps modelName_ input_ Nothing Nothing Nothing Nothing Nothing--{- | MonadIO version of 'embedding' for use in monadic contexts.--Lifts the 'embedding' function into a 'MonadIO' context, allowing it to be used in monadic computations.--}-embeddingM :: MonadIO m => Text -> [Text] -> m (Either OllamaError EmbeddingResp)-embeddingM m ip = liftIO $ embedding m ip--{- | MonadIO version of 'embeddingOps' for use in monadic contexts.--Lifts the 'embeddingOps' function into a 'MonadIO' context, allowing it to be used in monadic computations-with full configuration options.--}-embeddingOpsM ::-  MonadIO m =>-  Text ->-  [Text] ->-  Maybe Bool ->-  Maybe Int ->-  Maybe ModelOptions ->-  Maybe Int ->-  Maybe OllamaConfig ->-  m (Either OllamaError EmbeddingResp)-embeddingOpsM m ip mbTruncate mbKeepAlive mbOptions mbDimensions mbCfg =-  liftIO $ embeddingOps m ip mbTruncate mbKeepAlive mbOptions mbDimensions mbCfg

@@ -1,248 +0,0 @@-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE RecordWildCards #-}--{- |-Module      : Data.Ollama.Generate-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Text generation functionality for the Ollama client.--This module provides functions and types for generating text using an Ollama model. It includes APIs-for sending generation requests, both in IO ('generate') and monadic ('generateM') contexts, with-support for streaming and non-streaming responses. The 'GenerateOps' type configures the generation-request, allowing customization of the model, prompt, images, format, and other parameters. The-'defaultGenerateOps' provides a convenient starting point for configuration.--The module supports advanced features like Base64-encoded images, custom templates, and model-specific-options (e.g., temperature). It also includes validation to ensure required fields are non-empty.--Example:-->>> let ops = defaultGenerateOps { modelName = "gemma3", prompt = "Write a poem." }->>> generate ops Nothing-Right (GenerateResponse ...)--}-module Data.Ollama.Generate-  ( -- * Generate Texts-    generate-  , generateM--    -- * Configuration-  , defaultGenerateOps-  , GenerateOps (..)-  , validateGenerateOps--    -- * Response and Configuration Types-  , GenerateResponse (..)-  , Format (..)-  , OllamaConfig (..)-  , defaultOllamaConfig-  , ModelOptions (..)-  , defaultModelOptions--    -- * Error Types-  , OllamaError (..)-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Maybe-import Data.Ollama.Common.Config (OllamaConfig (..), defaultOllamaConfig)-import Data.Ollama.Common.Error (OllamaError (..))-import Data.Ollama.Common.Types (Format (..), GenerateResponse (..), ModelOptions (..))-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)-import Data.Text qualified as T--{- | Validates 'GenerateOps' to ensure required fields are non-empty.--Checks that the 'modelName' and 'prompt' fields are not empty. Returns 'Right' with the validated-'GenerateOps' or 'Left' with an 'OllamaError' if validation fails.--Example:-->>> validateGenerateOps defaultGenerateOps-Left (InvalidRequest "Prompt cannot be empty")--@since 0.2.0.0--}-validateGenerateOps :: GenerateOps -> Either OllamaError GenerateOps-validateGenerateOps ops-  | T.null (modelName ops) = Left $ InvalidRequest "Model name cannot be empty"-  | T.null (prompt ops) = Left $ InvalidRequest "Prompt cannot be empty"-  | otherwise = Right ops---- | Configuration for a text generation request.-data GenerateOps = GenerateOps-  { modelName :: !Text-  -- ^ The name of the model to use for generation (e.g., "gemma3").-  , prompt :: !Text-  -- ^ The prompt text to provide to the model for generating a response.-  , suffix :: Maybe Text-  -- ^ Optional suffix to append to the generated text (not supported by all models).-  , images :: !(Maybe [Text])-  -- ^ Optional list of Base64-encoded images to include with the request.-  , format :: !(Maybe Format)-  -- ^ Optional format specifier for the response (e.g., JSON).-  ---  -- @since 0.1.3.0-  , system :: !(Maybe Text)-  -- ^ Optional system text to include in the generation context.-  , template :: !(Maybe Text)-  -- ^ Optional template to format the response.-  , stream :: !(Maybe (GenerateResponse -> IO (), IO ()))-  -- ^ Optional callback function to be called with each incoming response.-  , raw :: !(Maybe Bool)-  -- ^ Optional flag to return the raw response.-  , keepAlive :: !(Maybe Int)-  -- ^ Optional override for how long (in minutes) the model stays loaded in memory (default: 5 minutes).-  , options :: !(Maybe ModelOptions)-  -- ^ Optional model parameters (e.g., temperature) as specified in the Modelfile.-  ---  -- @since 0.1.3.0-  , think :: !(Maybe Bool)-  -- ^ Optional flag to enable thinking mode.-  ---  -- @since 0.2.0.0-  }--instance Show GenerateOps where-  show GenerateOps {..} =-    "GenerateOps { "-      <> "model : "-      <> T.unpack modelName-      <> ", prompt : "-      <> T.unpack prompt-      <> ", suffix : "-      <> show suffix-      <> ", images : "-      <> show images-      <> ", format : "-      <> show format-      <> ", system : "-      <> show system-      <> ", template : "-      <> show template-      <> ", stream : "-      <> "Stream functions"-      <> ", raw : "-      <> show raw-      <> ", keepAlive : "-      <> show keepAlive-      <> ", options : "-      <> show options-      <> ", think: "-      <> show think--instance Eq GenerateOps where-  (==) a b =-    modelName a == modelName b-      && prompt a == prompt b-      && suffix a == suffix b-      && images a == images b-      && format a == format b-      && system a == system b-      && template a == template b-      && raw a == raw b-      && keepAlive a == keepAlive b-      && options a == options b-      && think a == think b--instance ToJSON GenerateOps where-  toJSON-    ( GenerateOps-        model-        prompt-        suffix-        images-        format-        system-        template-        stream-        raw-        keepAlive-        options-        think-      ) =-      object-        [ "model" .= model-        , "prompt" .= prompt-        , "suffix" .= suffix-        , "images" .= images-        , "format" .= format-        , "system" .= system-        , "template" .= template-        , "stream" .= if isNothing stream then Just False else Just True-        , "raw" .= raw-        , "keep_alive" .= keepAlive-        , "options" .= options-        , "think" .= think-        ]--{- | Default configuration for text generation.--Provides a default 'GenerateOps' with the "gemma3" model and an empty prompt. Other fields are set-to 'Nothing' or default values. Can be customized by modifying fields as needed.--Example:-->>> let ops = defaultGenerateOps { modelName = "customModel", prompt = "Hello!" }->>> generate ops Nothing--}-defaultGenerateOps :: GenerateOps-defaultGenerateOps =-  GenerateOps-    { modelName = "gemma3"-    , prompt = ""-    , suffix = Nothing-    , images = Nothing-    , format = Nothing-    , system = Nothing-    , template = Nothing-    , stream = Nothing-    , raw = Nothing-    , keepAlive = Nothing-    , options = Nothing-    , think = Nothing-    }--{- | Generates text using the specified model and configuration.--Validates the 'GenerateOps' configuration and sends a POST request to the @\/api\/generate@ endpoint.-Supports both streaming and non-streaming responses based on the 'stream' field in 'GenerateOps'.-Returns 'Right' with a 'GenerateResponse' on success or 'Left' with an 'OllamaError' on failure.--Example:-->>> let ops = defaultGenerateOps { modelName = "gemma3", prompt = "Write a short poem." }->>> generate ops Nothing-Right (GenerateResponse ...)--}-generate :: GenerateOps -> Maybe OllamaConfig -> IO (Either OllamaError GenerateResponse)-generate ops mbConfig =-  case validateGenerateOps ops of-    Left err -> pure $ Left err-    Right _ -> withOllamaRequest "/api/generate" "POST" (Just ops) mbConfig handler-  where-    handler = maybe commonNonStreamingHandler commonStreamHandler (stream ops)--{- | MonadIO version of 'generate' for use in monadic contexts.--Lifts the 'generate' function into a 'MonadIO' context, allowing it to be used in monadic computations.--Example:-->>> import Control.Monad.IO.Class->>> let ops = defaultGenerateOps { modelName = "gemma3", prompt = "Hello!" }->>> runReaderT (generateM ops Nothing) someContext-Right (GenerateResponse ...)--}-generateM ::-  MonadIO m =>-  GenerateOps ->-  Maybe OllamaConfig ->-  m (Either OllamaError GenerateResponse)-generateM ops mbCfg = liftIO $ generate ops mbCfg

@@ -1,105 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.List-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for listing available models in the Ollama client.--This module provides functions to retrieve a list of models available on the Ollama server.-It includes both an IO-based function ('list') and a monadic version ('listM') for use in-'MonadIO' contexts. The list operation is performed via a GET request to the @\/api\/tags@ endpoint,-returning a 'Models' type containing a list of 'ModelInfo' records with details about each model.--Example:-->>> list Nothing-Right (Models [ModelInfo ...])--}-module Data.Ollama.List-  ( -- * List Models API-    list-  , listM--    -- * Model Types-  , Models (..)-  , ModelInfo (..)-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Ollama.Common.Config (OllamaConfig)-import Data.Ollama.Common.Error (OllamaError)-import Data.Ollama.Common.Types as CT-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)-import Data.Time-import GHC.Int (Int64)---- | A wrapper type containing a list of available models.-newtype Models-  = -- | List of 'ModelInfo' records describing available models.-    Models [ModelInfo]-  deriving (Eq, Show)---- | Details about a specific model.-data ModelInfo = ModelInfo-  { name :: !Text-  -- ^ The name of the model.-  , modifiedAt :: !UTCTime-  -- ^ The timestamp when the model was last modified.-  , size :: !Int64-  -- ^ The size of the model in bytes.-  , digest :: !Text-  -- ^ The digest (hash) of the model.-  , details :: !ModelDetails-  -- ^ Additional details about the model (e.g., format, family, parameters).-  }-  deriving (Eq, Show)---- | JSON parsing instance for 'Models'.-instance FromJSON Models where-  parseJSON = withObject "Models" $ \v -> Models <$> v .: "models"---- | JSON parsing instance for 'ModelInfo'.-instance FromJSON ModelInfo where-  parseJSON = withObject "ModelInfo" $ \v ->-    ModelInfo-      <$> v .: "name"-      <*> v .: "modified_at"-      <*> v .: "size"-      <*> v .: "digest"-      <*> v .: "details"--{- | Retrieves a list of available models from the Ollama server.--Sends a GET request to the @\/api\/tags@ endpoint to fetch the list of models.-Returns 'Right' with a 'Models' containing the list of 'ModelInfo' on success,-or 'Left' with an 'OllamaError' on failure.--}-list ::-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError Models)-list mbConfig = do-  withOllamaRequest-    "/api/tags"-    "GET"-    (Nothing :: Maybe Value)-    mbConfig-    commonNonStreamingHandler--{- | MonadIO version of 'list' for use in monadic contexts.--Lifts the 'list' function into a 'MonadIO' context, allowing it to be used in monadic computations.--Example:-->>> import Control.Monad.IO.Class->>> runReaderT (listM Nothing) someContext-Right (Models [ModelInfo ...])--}-listM :: MonadIO m => Maybe OllamaConfig -> m (Either OllamaError Models)-listM mbCfg = liftIO $ list mbCfg

@@ -1,103 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Load-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : High-level functions for loading and unloading models in the Ollama client.--This module provides functions to load and unload generative models in the Ollama server.-It includes both IO-based functions ('loadGenModel', 'unloadGenModel') and monadic versions-('loadGenModelM', 'unloadGenModelM') for use in 'MonadIO' contexts. The operations are-performed via POST requests to the @\/api\/generate@ endpoint, leveraging the 'GenerateOps'-configuration from the 'Data.Ollama.Generate' module.--Loading a model keeps it in memory for faster subsequent requests, while unloading frees-up memory by setting the keep-alive duration to zero.--Example:-->>> loadGenModel "gemma3"-Right ()->>> unloadGenModel "gemma3"-Right ()--}-module Data.Ollama.Load-  ( -- * Load and Unload Model APIs-    loadGenModel-  , unloadGenModel-  , loadGenModelM-  , unloadGenModelM-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Ollama.Common.Error-import Data.Ollama.Common.Utils (commonNonStreamingHandler, withOllamaRequest)-import Data.Ollama.Generate qualified as Gen-import Data.Text (Text)--{- | Loads a generative model into memory.--Sends a POST request to the @\/api\/generate@ endpoint to load the specified model into-memory, ensuring faster response times for subsequent requests. Returns 'Right ()' on-success or 'Left' with an 'OllamaError' on failure.--@since 0.2.0.0--}-loadGenModel ::-  -- |  Model name (e.g., "gemma3")-  Text ->-  IO (Either OllamaError ())-loadGenModel m = do-  let ops = Gen.defaultGenerateOps {Gen.modelName = m}-  withOllamaRequest "/api/generate" "POST" (Just ops) Nothing commonNonStreamingHandler--{- | Unloads a generative model from memory.--Sends a POST request to the @\/api\/generate@ endpoint with a keep-alive duration of zero-to unload the specified model from memory, freeing up resources. Returns 'Right ()' on-success or 'Left' with an 'OllamaError' on failure.--@since 0.2.0.0--}-unloadGenModel ::-  -- | Model name (e.g., "gemma3")-  Text ->-  IO (Either OllamaError ())-unloadGenModel m = do-  let ops = Gen.defaultGenerateOps {Gen.modelName = m, Gen.keepAlive = Just 0}-  withOllamaRequest "/api/generate" "POST" (Just ops) Nothing commonNonStreamingHandler--{- | MonadIO version of 'loadGenModel' for use in monadic contexts.--Lifts the 'loadGenModel' function into a 'MonadIO' context, allowing it to be used in-monadic computations.--Example:-->>> import Control.Monad.IO.Class->>> runReaderT (loadGenModelM "gemma3") someContext-Right ()--@since 0.2.0.0--}-loadGenModelM :: MonadIO m => Text -> m (Either OllamaError ())-loadGenModelM t = liftIO $ loadGenModel t--{- | MonadIO version of 'unloadGenModel' for use in monadic contexts.--Lifts the 'unloadGenModel' function into a 'MonadIO' context, allowing it to be used in-monadic computations.--Example:-->>> import Control.Monad.IO.Class->>> runReaderT (unloadGenModelM "gemma3") someContext-Right ()--@since 0.2.0.0--}-unloadGenModelM :: MonadIO m => Text -> m (Either OllamaError ())-unloadGenModelM t = liftIO $ unloadGenModel t

@@ -1,109 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Ps-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for listing running models in the Ollama client.--This module provides functions to retrieve a list of models currently running on the Ollama server.-It includes both an IO-based function ('ps') and a monadic version ('psM') for use in 'MonadIO'-contexts. The operation is performed via a GET request to the @\/api\/ps@ endpoint, returning a-'RunningModels' type containing a list of 'RunningModel' records with details about each running model.--Example:-->>> ps Nothing-Right (RunningModels [RunningModel ...])--}-module Data.Ollama.Ps-  ( -- * List Running Models API-    ps-  , psM--    -- * Model Types-  , RunningModels (..)-  , RunningModel (..)-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Ollama.Common.Config (OllamaConfig)-import Data.Ollama.Common.Error (OllamaError)-import Data.Ollama.Common.Types as CT-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)-import Data.Time-import GHC.Int (Int64)---- | A wrapper type containing a list of running models.-newtype RunningModels-  = -- | List of 'RunningModel' records describing currently running models.-    RunningModels [RunningModel]-  deriving (Eq, Show)---- | Details about a specific running model.-data RunningModel = RunningModel-  { name_ :: !Text-  -- ^ The name of the running model instance.-  , modelName :: !Text-  -- ^ The base model name (e.g., "gemma3").-  , size_ :: !Int64-  -- ^ The size of the model in bytes.-  , modelDigest :: !Text-  -- ^ The digest (hash) of the model.-  , modelDetails :: !ModelDetails-  -- ^ Additional details about the model (e.g., format, family, parameters).-  , expiresAt :: !UTCTime-  -- ^ The timestamp when the model's memory allocation expires.-  , sizeVRam :: !Int64-  -- ^ The size of the model's VRAM usage in bytes.-  }-  deriving (Eq, Show)---- | JSON parsing instance for 'RunningModels'.-instance FromJSON RunningModels where-  parseJSON = withObject "Models" $ \v -> RunningModels <$> v .: "models"---- | JSON parsing instance for 'RunningModel'.-instance FromJSON RunningModel where-  parseJSON = withObject "RunningModel" $ \v ->-    RunningModel-      <$> v .: "name"-      <*> v .: "model"-      <*> v .: "size"-      <*> v .: "digest"-      <*> v .: "details"-      <*> v .: "expires_at"-      <*> v .: "size_vram"--{- | Retrieves a list of currently running models from the Ollama server.--Sends a GET request to the @\/api\/ps@ endpoint to fetch the list of running models.-Returns 'Right' with a 'RunningModels' containing the list of 'RunningModel' on success,-or 'Left' with an 'OllamaError' on failure.-Example:-->>> ps Nothing-Right (RunningModels [RunningModel {name_ = "gemma3:instance1", modelName = "gemma3", ...}])--}-ps ::-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError RunningModels)-ps mbConfig = do-  withOllamaRequest-    "/api/ps"-    "GET"-    (Nothing :: Maybe Value)-    mbConfig-    commonNonStreamingHandler--{- | MonadIO version of 'ps' for use in monadic contexts.--Lifts the 'ps' function into a 'MonadIO' context, allowing it to be used in monadic computations.--}-psM :: MonadIO m => Maybe OllamaConfig -> m (Either OllamaError RunningModels)-psM mbCfg = liftIO $ ps mbCfg

@@ -1,153 +0,0 @@-{-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE RecordWildCards #-}--{- |-Module      : Data.Ollama.Pull-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for pulling models in the Ollama client.--This module provides functions to pull (download) models from the Ollama server. It includes both-high-level ('pull', 'pullM') and low-level ('pullOps', 'pullOpsM') APIs for pulling models, with-support for streaming progress updates and insecure connections. The 'PullOps' type configures the-pull request, and 'PullResp' represents the response containing the status and progress details.--The pull operation is performed via a POST request to the @\/api\/pull@ endpoint. Streaming mode,-when enabled, provides real-time progress updates by printing the remaining bytes to the console.--Example:-->>> pull "gemma3"-Remaining bytes: 123456789-...-Completed-Right (PullResp {status = "success", ...})--}-module Data.Ollama.Pull-  ( -- * Pull Model API-    pull-  , pullOps-  , pullM-  , pullOpsM-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Maybe (fromMaybe)-import Data.Ollama.Common.Config (OllamaConfig)-import Data.Ollama.Common.Error (OllamaError)-import Data.Ollama.Common.Types (HasDone (..))-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)-import GHC.Generics-import GHC.Int (Int64)---- | Configuration options for pulling a model.-data PullOps = PullOps-  { name :: !Text-  -- ^ The name of the model to pull (e.g., "gemma3").-  , insecure :: !(Maybe Bool)-  -- ^ Optional flag to allow insecure connections. If 'Just True', insecure connections are permitted.-  , stream :: !(Maybe Bool)-  -- ^ Optional flag to enable streaming of the download. If 'Just True', progress updates are streamed.-  }-  deriving (Show, Eq, Generic, ToJSON)---- | Response data from a pull operation.-data PullResp = PullResp-  { status :: !Text-  -- ^ The status of the pull operation (e.g., "success" or "failure").-  , digest :: !(Maybe Text)-  -- ^ The digest (hash) of the model, if available.-  , total :: !(Maybe Int64)-  -- ^ The total size of the model in bytes, if available.-  , completed :: !(Maybe Int64)-  -- ^ The number of bytes downloaded, if available.-  }-  deriving (Show, Eq, Generic, FromJSON)--instance HasDone PullResp where-  getDone PullResp {..} = status /= "success"--{- | Pulls a model with full configuration.--Sends a POST request to the @\/api\/pull@ endpoint to download the specified model. Supports-streaming progress updates (if 'stream' is 'Just True') and insecure connections (if 'insecure'-is 'Just True'). Prints remaining bytes during streaming and "Completed" when finished.-Returns 'Right' with a 'PullResp' on success or 'Left' with an 'OllamaError' on failure.--}-pullOps ::-  -- | Model name-  Text ->-  -- | Optional insecure connection flag-  Maybe Bool ->-  -- | Optional streaming flag-  Maybe Bool ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError PullResp)-pullOps modelName mInsecure mStream mbConfig = do-  withOllamaRequest-    "/api/pull"-    "POST"-    (Just $ PullOps {name = modelName, insecure = mInsecure, stream = mStream})-    mbConfig-    (commonStreamHandler (onToken, pure ()))-  where-    onToken :: PullResp -> IO ()-    onToken res = do-      let completed' = fromMaybe 0 (completed res)-      let total' = fromMaybe 0 (total res)-      putStrLn $ "Remaining bytes: " <> show (total' - completed')--{- | Simplified API for pulling a model.--A higher-level function that pulls a model using default settings for insecure connections,-streaming, and Ollama configuration. Suitable for basic use cases.--}-pull ::-  -- | Model name-  Text ->-  IO (Either OllamaError PullResp)-pull modelName = pullOps modelName Nothing Nothing Nothing--{- | MonadIO version of 'pull' for use in monadic contexts.--Lifts the 'pull' function into a 'MonadIO' context, allowing it to be used in monadic computations.--Example:-->>> import Control.Monad.IO.Class->>> runReaderT (pullM "gemma3") someContext-Right (PullResp {status = "success", ...})--}-pullM :: MonadIO m => Text -> m (Either OllamaError PullResp)-pullM t = liftIO $ pull t--{- | MonadIO version of 'pullOps' for use in monadic contexts.--Lifts the 'pullOps' function into a 'MonadIO' context, allowing it to be used in monadic computations-with full configuration options.--Example:-->>> import Control.Monad.IO.Class->>> runReaderT (pullOpsM "gemma3" Nothing (Just True) Nothing) someContext-Remaining bytes: 123456789-...-Completed-Right (PullResp {status = "success", ...})--}-pullOpsM ::-  MonadIO m =>-  Text ->-  Maybe Bool ->-  Maybe Bool ->-  Maybe OllamaConfig ->-  m (Either OllamaError PullResp)-pullOpsM t mbInsecure mbStream mbCfg = liftIO $ pullOps t mbInsecure mbStream mbCfg

@@ -1,115 +0,0 @@-{-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE RecordWildCards #-}--{- |-Module      : Data.Ollama.Push-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for pushing models to the Ollama server.--This module provides functions to push (upload) a model to the Ollama server. It includes-both an IO-based function ('push') and a monadic version ('pushM') for use in 'MonadIO'-contexts. The push operation is performed via a POST request to the @\/api\/pull@ endpoint,-with support for streaming progress updates and insecure connections.--The 'PushOps' type configures the push request, and 'PushResp' represents the response-containing the status and progress details. Streaming mode, when enabled, provides-real-time progress updates by printing to the console.--Example:-->>> push "gemma3" Nothing (Just True) Nothing-Pushing...-Completed--}-module Data.Ollama.Push-  ( -- * Push Model API-    push-  , pushM-  ) where--import Control.Monad (void)-import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Ollama.Common.Config (OllamaConfig)-import Data.Ollama.Common.Types (HasDone (getDone))-import Data.Ollama.Common.Utils as CU-import Data.Text (Text)-import GHC.Generics-import GHC.Int (Int64)---- | Configuration options for pushing a model.-data PushOps = PushOps-  { name :: !Text-  -- ^ The name of the model to push (e.g., "gemma3").-  , insecure :: !(Maybe Bool)-  -- ^ Optional flag to allow insecure connections.-  -- If 'Just True', insecure connections are permitted.-  , stream :: !(Maybe Bool)-  -- ^ Optional flag to enable streaming of the upload.-  -- If 'Just True', progress updates are streamed.-  }-  deriving (Show, Eq, Generic, ToJSON)---- | Response data from a push operation.-data PushResp = PushResp-  { status :: !Text-  -- ^ The status of the push operation (e.g., "success" or "failure").-  , digest :: !(Maybe Text)-  -- ^ The digest (hash) of the model, if available.-  , total :: !(Maybe Int64)-  -- ^ The total size of the model in bytes, if available.-  }-  deriving (Show, Eq, Generic, FromJSON)--instance HasDone PushResp where-  getDone PushResp {..} = status /= "success"--{- | Pushes a model to the Ollama server with specified options.--Sends a POST request to the @\/api\/pull@ endpoint to upload the specified model. Supports-streaming progress updates (if 'stream' is 'Just True') and insecure connections (if-'insecure' is 'Just True'). Prints "Pushing..." during streaming and "Completed" when-finished. Returns '()' on completion.--}-push ::-  -- | Model name-  Text ->-  -- | Optional insecure connection flag-  Maybe Bool ->-  -- | Optional streaming flag-  Maybe Bool ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO ()-push modelName mInsecure mStream mbConfig = do-  void $-    withOllamaRequest-      "/api/push"-      "POST"-      (Just $ PushOps {name = modelName, insecure = mInsecure, stream = mStream})-      mbConfig-      (commonStreamHandler (onToken, pure ()))-  where-    onToken :: PushResp -> IO ()-    onToken _ = putStrLn "Pushing... "--{- | MonadIO version of 'push' for use in monadic contexts.--Lifts the 'push' function into a 'MonadIO' context, allowing it to be used in monadic-computations.--Example:-->>> import Control.Monad.IO.Class->>> runReaderT (pushM "gemma3" Nothing (Just True) Nothing) someContext-Pushing...-Completed--}-pushM :: MonadIO m => Text -> Maybe Bool -> Maybe Bool -> Maybe OllamaConfig -> m ()-pushM t insec s mbCfg = liftIO $ push t insec s mbCfg

@@ -1,230 +0,0 @@-{-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE DuplicateRecordFields #-}-{-# LANGUAGE OverloadedStrings #-}--{- |-Module      : Data.Ollama.Show-Copyright   : (c) 2025 Tushar Adhatrao-License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental-Description : Functionality for retrieving detailed information about models in the Ollama client.--This module provides functions to fetch detailed information about a specific model on the Ollama server.-It includes both high-level ('showModel', 'showModelM') and low-level ('showModelOps', 'showModelOpsM') APIs-for retrieving model details, with support for verbose output. The operation is performed via a POST request-to the @\/api\/show@ endpoint, returning a 'ShowModelResponse' containing comprehensive model metadata.--The 'ShowModelOps' type configures the request, and 'ShowModelResponse' and 'ShowModelInfo' represent the-response structure. The module also re-exports 'CT.ModelDetails' for completeness.--Note: Verbose mode parsing is currently not fully supported.--Example:-->>> showModel "gemma3"-Right (ShowModelResponse {modelFile = "...", ...})--@since 1.0.0.0--}-module Data.Ollama.Show-  ( -- * Show Model Info API-    showModel-  , showModelM-  , showModelOps-  , showModelOpsM--    -- * Response Types-  , ShowModelResponse (..)-  , ShowModelInfo (..)-  , CT.ModelDetails (..)-  ) where--import Control.Monad.IO.Class (MonadIO (liftIO))-import Data.Aeson-import Data.Ollama.Common.Config (OllamaConfig)-import Data.Ollama.Common.Error (OllamaError)-import Data.Ollama.Common.Types qualified as CT-import Data.Ollama.Common.Utils (commonNonStreamingHandler, withOllamaRequest)-import Data.Text (Text)-import GHC.Generics-import GHC.Int (Int64)---- | Configuration options for requesting model information.-data ShowModelOps = ShowModelOps-  { name :: !Text-  -- ^ The name of the model to query (e.g., "gemma3").-  , verbose :: !(Maybe Bool)-  -- ^ Optional flag to request verbose output. Note: Verbose mode parsing is currently incomplete.-  }-  deriving (Show, Eq, Generic, ToJSON)---- | Response structure for model information.-data ShowModelResponse = ShowModelResponse-  { modelFile :: !Text-  -- ^ The content of the model's Modelfile.-  , parameters :: !(Maybe Text)-  -- ^ Optional model parameters (e.g., temperature settings).-  , template :: !(Maybe Text)-  -- ^ Optional template used for the model.-  , details :: !CT.ModelDetails-  -- ^ General details about the model (e.g., format, family).-  , modelInfo :: !ShowModelInfo-  -- ^ Detailed technical information about the model.-  , license :: !(Maybe Text)-  -- ^ Optional license information for the model.-  ---  -- @since 0.2.0.0-  , capabilities :: Maybe [Text]-  -- ^ Optional list of model capabilities.-  ---  -- @since 0.2.0.0-  }-  deriving (Show, Eq)---- | Detailed technical information about a model.-data ShowModelInfo = ShowModelInfo-  { generalArchitecture :: !(Maybe Text)-  -- ^ The architecture of the model (e.g., "llama").-  , generalFileType :: !(Maybe Int)-  -- ^ The file type identifier for the model.-  , generalParameterCount :: !(Maybe Int64)-  -- ^ The number of parameters in the model.-  , generalQuantizationVersion :: !(Maybe Int)-  -- ^ The quantization version used by the model.-  , llamaAttentionHeadCount :: !(Maybe Int)-  -- ^ Number of attention heads in the LLaMA model.-  , llamaAttentionHeadCountKV :: !(Maybe Int)-  -- ^ Number of key-value attention heads in the LLaMA model.-  , llamaAttentionLayerNormRMSEpsilon :: !(Maybe Float)-  -- ^ RMS epsilon for layer normalization in the LLaMA model.-  , llamaBlockCount :: !(Maybe Int)-  -- ^ Number of blocks in the LLaMA model.-  , llamaContextLength :: !(Maybe Int)-  -- ^ Context length supported by the LLaMA model.-  , llamaEmbeddingLength :: !(Maybe Int)-  -- ^ Embedding length used by the LLaMA model.-  , llamaFeedForwardLength :: !(Maybe Int)-  -- ^ Feed-forward layer length in the LLaMA model.-  , llamaRopeDimensionCount :: !(Maybe Int)-  -- ^ RoPE dimension count in the LLaMA model.-  , llamaRopeFreqBase :: !(Maybe Int64)-  -- ^ Base frequency for RoPE in the LLaMA model.-  , llamaVocabSize :: !(Maybe Int64)-  -- ^ Vocabulary size of the LLaMA model.-  , tokenizerGgmlBosToken_id :: !(Maybe Int)-  -- ^ BOS (beginning of sequence) token ID for the GGML tokenizer.-  , tokenizerGgmlEosToken_id :: !(Maybe Int)-  -- ^ EOS (end of sequence) token ID for the GGML tokenizer.-  , tokenizerGgmlMerges :: !(Maybe [Text])-  -- ^ List of merges for the GGML tokenizer.-  , tokenizerGgmlMode :: !(Maybe Text)-  -- ^ Mode of the GGML tokenizer.-  , tokenizerGgmlPre :: !(Maybe Text)-  -- ^ Pre-tokenization configuration for the GGML tokenizer.-  , tokenizerGgmlTokenType :: !(Maybe [Text])-  -- ^ Token type information for the GGML tokenizer.-  , tokenizerGgmlTokens :: !(Maybe [Text])-  -- ^ List of tokens for the GGML tokenizer.-  }-  deriving (Show, Eq)---- | JSON parsing instance for 'ShowModelResponse'.-instance FromJSON ShowModelResponse where-  parseJSON = withObject "ShowModelResponse" $ \v ->-    ShowModelResponse-      <$> v .: "modelfile"-      <*> v .:? "parameters"-      <*> v .:? "template"-      <*> v .: "details"-      <*> v .: "model_info"-      <*> v .:? "license"-      <*> v .:? "capabilities"---- | JSON parsing instance for 'ShowModelInfo'.-instance FromJSON ShowModelInfo where-  parseJSON = withObject "ModelInfo" $ \v ->-    ShowModelInfo-      <$> v .:? "general.architecture"-      <*> v .:? "general.file_type"-      <*> v .:? "general.parameter_count"-      <*> v .:? "general.quantization_version"-      <*> v .:? "llama.attention.head_count"-      <*> v .:? "llama.attention.head_count_kv"-      <*> v .:? "llama.attention.layer_norm_rms_epsilon"-      <*> v .:? "llama.block_count"-      <*> v .:? "llama.context_length"-      <*> v .:? "llama.embedding_length"-      <*> v .:? "llama.feed_forward_length"-      <*> v .:? "llama.rope.dimension_count"-      <*> v .:? "llama.rope.freq_base"-      <*> v .:? "llama.vocab_size"-      <*> v .:? "tokenizer.ggml.bos_token_id"-      <*> v .:? "tokenizer.ggml.eos_token_id"-      <*> v .:? "tokenizer.ggml.merges"-      <*> v .:? "tokenizer.ggml.model"-      <*> v .:? "tokenizer.ggml.pre"-      <*> v .:? "tokenizer.ggml.token_type"-      <*> v .:? "tokenizer.ggml.tokens"--{- | Retrieves model information with configuration options.--Sends a POST request to the @\/api\/show@ endpoint to fetch detailed information about-the specified model. Supports verbose output if 'verbose' is 'Just True' (though verbose-mode parsing is currently incomplete). Returns 'Right' with a 'ShowModelResponse' on-success or 'Left' with an 'OllamaError' on failure.--}-showModelOps ::-  -- | Model name-  Text ->-  -- | Optional verbose flag-  Maybe Bool ->-  -- | Optional 'OllamaConfig' (defaults to 'defaultOllamaConfig' if 'Nothing')-  Maybe OllamaConfig ->-  IO (Either OllamaError ShowModelResponse)-showModelOps modelName verbose_ mbConfig = do-  withOllamaRequest-    "/api/show"-    "POST"-    ( Just $-        ShowModelOps-          { name = modelName-          , verbose = verbose_-          }-    )-    mbConfig-    commonNonStreamingHandler--{- | Simplified API for retrieving model information.--A higher-level function that fetches model information using default settings for-verbose output and Ollama configuration. Suitable for basic use cases.--}-showModel ::-  -- | Model name-  Text ->-  IO (Either OllamaError ShowModelResponse)-showModel modelName =-  showModelOps modelName Nothing Nothing--{- | MonadIO version of 'showModel' for use in monadic contexts.--Lifts the 'showModel' function into a 'MonadIO' context, allowing it to be used in-monadic computations.--}-showModelM :: MonadIO m => Text -> m (Either OllamaError ShowModelResponse)-showModelM t = liftIO $ showModel t--{- | MonadIO version of 'showModelOps' for use in monadic contexts.--Lifts the 'showModelOps' function into a 'MonadIO' context, allowing it to be used in-monadic computations with full configuration options.--}-showModelOpsM ::-  MonadIO m =>-  Text ->-  Maybe Bool ->-  Maybe OllamaConfig ->-  m (Either OllamaError ShowModelResponse)-showModelOpsM t v mbCfg = liftIO $ showModelOps t v mbCfg

@@ -1,199 +1,189 @@-{-# LANGUAGE DuplicateRecordFields #-}- {- |-Module      : Data.Ollama-Copyright   : (c) 2025 Tushar Adhatrao+Module      : Ollama+Copyright   : (c) 2024-2026 Tushar Adhatrao License     : MIT-Maintainer  : Tushar Adhatrao <tusharadhatrao@gmail.com>-Stability   : experimental+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable Portability : portable -== Ollama Haskell--This module provides a high-level Haskell interface to the [Ollama](https://ollama.com) API-    for interacting with local LLMs. It includes support for:--- Text generation (sync/streaming)-- Conversational chat (with tools and images)-- Embeddings-- Model management (pull, push, delete, list, show)-- Structured outputs-- Custom configuration and model options--Inspired by @ollama-python@, this library is built to offer idiomatic Haskell bindings-over Ollama’s HTTP API.--== 🔧 Usage+Top-level umbrella re-export module for the Ollama Haskell client library. -Import this module as a top-level interface:+== Quick Example  @ import Ollama-@ -All functions return @Either OllamaError a@ or can be used in a Monad stack using-their @\*M@ variants.--== 🔑 Main APIs--=== ✍️ Generate Text--- 'generate', 'generateM' – Generate text from a model-- 'defaultGenerateOps' – Default generation parameters-- 'GenerateOps', 'GenerateResponse' – Request and response types--=== 💬 Chat with LLMs--- 'chat', 'chatM' – Send chat messages to a model-- 'ChatOps', 'ChatResponse', 'Role', 'Message' – Chat input/output types-- Supports tools via 'InputTool', 'FunctionDef', 'OutputFunction', etc.--=== 🧠 Embeddings--- 'embedding', 'embeddingM' – Generate vector embeddings-- 'EmbeddingOps', 'EmbeddingResp' – Request/response types--=== 📦 Model Management--- 'copyModel', 'createModel', 'deleteModel'-- 'list' – List all installed models-- 'ps', 'psM' – Show running models-- 'showModel', 'showModelM' – Show model info-- 'pull', 'push' – Pull/push models (with progress support)--=== ⚙️ Configuration--- 'defaultOllamaConfig' – Modify host, retries, streaming, etc.-- 'withOnModelStart', 'withOnModelFinish', 'withOnModelError' – Hook support+main :: IO ()+main = do+  client <- defaultClient+  let req = chatRequest "llama3.2" (userMessage "Why is the sky blue?" :| [])+  result <- chat client req+  case result of+    Left err -> print err+    Right resp -> case crMessage resp of+      Just msg -> putStrLn (messageContent msg)+      Nothing  -> putStrLn "No message returned"+@ -=== 🧰 Utilities+@since 1.0.0.0+-}+module Ollama (+  -- * Client+  OllamaClient,+  newClient,+  defaultClient,+  clientFromEnv,+  closeClient,+  withClient, -- 'defaultModelOptions', 'encodeImage', 'withOllamaRequest'-- 'loadGenModel', 'unloadGenModel' – Load/unload generation models-- 'getVersion' – Ollama server version+  -- * Config & Retry+  OllamaClientConfig (..),+  defaultConfig,+  RetryPolicy (..),+  LogLevel (..), -== 🧾 Types+  -- * API Endpoints -All request/response payloads and enums are exposed, including:+  -- ** Chat+  chat,+  chatStream,+  ChatRequest (..),+  ChatResponse (..),+  chatRequest,+  chatEvalTokensPerSecond,+  chatPromptEvalTokensPerSecond, -- 'ModelOptions', 'OllamaConfig', 'OllamaError', 'Format'-- 'Models', 'ModelInfo', 'ModelDetails', 'ShowModelResponse'-- 'RunningModels', 'RunningModel', 'Version'--}-module Ollama-  ( -- * Main APIs+  -- ** Generate+  generate,+  generateStream,+  GenerateRequest (..),+  GenerateResponse (..),+  generateRequest,+  evalTokensPerSecond,+  promptEvalTokensPerSecond, -    -- ** Generate Texts-    generate-  , generateM-  , defaultGenerateOps-  , GenerateOps (..)-  , GenerateResponse (..)+  -- ** Embeddings+  embed,+  EmbedRequest (..),+  EmbedResponse (..),+  embedRequest,+  embeddings,+  EmbeddingsRequest (..),+  EmbeddingsResponse (..), -    -- ** Chat with LLMs-  , chat-  , chatM-  , Role (..)-  , defaultChatOps-  , ChatResponse (..)-  , ChatOps (..)-  , InputTool (..)-  , FunctionDef (..)-  , FunctionParameters (..)-  , ToolCall (..)-  , OutputFunction (..)+  -- ** Model Management+  listModels,+  showModel,+  copyModel,+  deleteModel,+  ListResponse (..),+  ModelInfo (..),+  RunningModel (..),+  ShowResponse (..), -    -- ** Embeddings-  , embedding-  , embeddingOps-  , embeddingM-  , embeddingOpsM-  , EmbeddingOps (..)-  , EmbeddingResp (..)+  -- ** Create+  createModel,+  createModelStream,+  defaultCreateRequest,+  CreateRequest (..),+  CreateResponse (..),+  QuantizationType (..), -    -- ** Copy Models-  , copyModel-  , copyModelM+  -- ** Pull & Push+  pull,+  pullStream,+  push,+  pushStream,+  PullResponse (..),+  PushResponse (..), -    -- ** Create Models-  , createModel-  , createModelM+  -- ** Blobs+  checkBlob,+  pushBlob, -    -- ** Delete Models-  , deleteModel-  , deleteModelM+  -- ** System+  getVersion,+  listRunning,+  RunningModelsResponse (..), -    -- ** List Models-  , list+  -- * Types & Primitives+  ModelName (..),+  mkModelName,+  Digest (..),+  Base64Image (..),+  Duration (..),+  durationToSeconds,+  durationToMillis,+  tokensPerSecond,+  Version (..),+  Think (..),+  ThinkingLevel (..), -    -- ** List currently running models-  , ps-  , psM+  -- ** Messages+  Role (..),+  Message (..),+  userMessage,+  systemMessage,+  assistantMessage,+  toolMessage,+  toolResultMessage,+  imageMessage, -    -- ** Push and Pull-  , push-  , pushM-  , pull-  , pullM-  , pullOps-  , pullOpsM+  -- ** Tools & Functions+  Tool (..),+  FunctionDef (..),+  FunctionParameters (..),+  ToolCall (..),+  ToolCallFunction (..), -    -- ** Show Model Info-  , showModel-  , showModelOps-  , showModelM-  , showModelOpsM+  -- ** Options & Format+  ModelOptions (..),+  defaultOptions,+  Format (..), -    -- ** Blob Operations-  , checkBlobExists-  , createBlob+  -- * Error Handling+  OllamaError (..),+  isRetryable,+  throwOllama, -    -- * Ollama config-  , defaultOllamaConfig-  , withOnModelStart-  , withOnModelFinish-  , withOnModelError+  -- * Streaming+  HasDone (..),+  collectStream,+  foldStream, -    -- * Utils-  , defaultModelOptions-  , ModelOptions (..)-  , encodeImage-  , withOllamaRequest-  , getVersion-  , loadGenModel-  , unloadGenModel-  , loadGenModelM-  , unloadGenModelM+  -- * Testing Infrastructure+  newMockClient,+  withMockClient,+  mockGenerateResponse,+  mockChatResponse,+  mockEmbedResponse,+  mockListModelsResponse, -    -- * Types-  , ShowModelResponse (..)-  , Models (..)-  , ModelInfo (..)-  , ModelDetails (..)-  , ShowModelInfo (..)-  , RunningModels (..)-  , RunningModel (..)-  , Message (..)-  , Format (..)-  , OllamaError (..)-  , OllamaConfig (..)-  , Version (..)-  )-where+  -- * Conversation Store+  Conversation (..),+  ConversationStore (..),+  InMemoryStore (..),+  initInMemoryStore,+  saveConversationInMemory,+  loadConversationInMemory,+  listConversationsInMemory,+  deleteConversationInMemory,+) where -import Data.Ollama.Blob-import Data.Ollama.Chat-import Data.Ollama.Common.Config-import Data.Ollama.Common.Types-import Data.Ollama.Common.Utils-import Data.Ollama.Copy-import Data.Ollama.Create-import Data.Ollama.Delete-import Data.Ollama.Embeddings hiding (keepAlive, modelName)-import Data.Ollama.Generate-import Data.Ollama.List-import Data.Ollama.Load-import Data.Ollama.Ps hiding (modelName)-import Data.Ollama.Pull-import Data.Ollama.Push-import Data.Ollama.Show+import Ollama.API.Blobs+import Ollama.API.Chat+import Ollama.API.Embed+import Ollama.API.Generate+import Ollama.API.Models+import Ollama.API.Models.Create+import Ollama.API.Models.Pull+import Ollama.API.Models.Push+import Ollama.API.Ps+import Ollama.API.Version+import Ollama.Client+import Ollama.Client.Config+import Ollama.Conversation+import Ollama.Error+import Ollama.Streaming+import Ollama.Testing+import Ollama.Types

@@ -0,0 +1,45 @@+{- |+Module      : Ollama.API.Blobs+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Blob management endpoints (@/api/blobs/:digest@).++@since 1.0.0.0+-}+module Ollama.API.Blobs (+  checkBlob,+  pushBlob,+) where++import Control.Monad.IO.Class (MonadIO)+import Data.ByteString (ByteString)+import Data.Functor (void)+import Ollama.Client (OllamaClient)+import Ollama.Client.Internal (requestRaw)+import Ollama.Error (OllamaError (..))+import Ollama.Types.Common (Digest (..))++{- | Check if a blob exists on the server (@HEAD /api/blobs/:digest@).++@since 1.0.0.0+-}+checkBlob :: (MonadIO m) => OllamaClient -> Digest -> m (Either OllamaError Bool)+checkBlob client (Digest d) = do+  res <- requestRaw client "HEAD" ("/api/blobs/" <> d) Nothing+  pure $ case res of+    Right _ -> Right True+    Left (ApiError 404 _) -> Right False+    Left err -> Left err++{- | Push / upload a file blob to the server (@POST /api/blobs/:digest@).++@since 1.0.0.0+-}+pushBlob :: (MonadIO m) => OllamaClient -> Digest -> ByteString -> m (Either OllamaError ())+pushBlob client (Digest d) payload = do+  res <- requestRaw client "POST" ("/api/blobs/" <> d) (Just payload)+  pure $ void res

@@ -0,0 +1,170 @@+{- |+Module      : Ollama.API.Chat+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Chat completion API endpoint (@/api/chat@).++@since 1.0.0.0+-}+module Ollama.API.Chat (+  ChatRequest (..),+  ChatResponse (..),+  chatRequest,+  chat,+  chatStream,+  chatEvalTokensPerSecond,+  chatPromptEvalTokensPerSecond,+) where++import Conduit (ConduitT)+import Control.Monad.IO.Class (MonadIO)+import Control.Monad.IO.Unlift (MonadUnliftIO)+import Data.Aeson+import Data.List.NonEmpty (NonEmpty)+import Data.Maybe (catMaybes)+import Data.Text (Text)+import Data.Time (UTCTime)+import GHC.Generics (Generic)+import Ollama.Client (OllamaClient)+import Ollama.Client.Internal (request, requestStreaming)+import Ollama.Error (OllamaError)+import Ollama.Streaming (HasDone (..))+import Ollama.Types.Common (Duration, ModelName, Think, tokensPerSecond)+import Ollama.Types.Format (Format)+import Ollama.Types.Message (Message)+import Ollama.Types.Options (ModelOptions)+import Ollama.Types.Tool (Tool)++{- | Chat completion request payload.++@since 1.0.0.0+-}+data ChatRequest = ChatRequest+  { chatModel :: !ModelName+  , chatMessages :: !(NonEmpty Message)+  , chatTools :: !(Maybe [Tool])+  , chatFormat :: !(Maybe Format)+  , chatOptions :: !(Maybe ModelOptions)+  , chStream :: !(Maybe Bool)+  , chatKeepAlive :: !(Maybe Text)+  , chatThink :: !(Maybe Think)+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON ChatRequest where+  toJSON ChatRequest {..} =+    object $+      catMaybes+        [ Just $ "model" .= chatModel+        , Just $ "messages" .= chatMessages+        , ("tools" .=) <$> chatTools+        , ("format" .=) <$> chatFormat+        , ("options" .=) <$> chatOptions+        , ("stream" .=) <$> chStream+        , ("keep_alive" .=) <$> chatKeepAlive+        , ("think" .=) <$> chatThink+        ]++{- | Create a default 'ChatRequest' for a model and message history.++@since 1.0.0.0+-}+chatRequest :: ModelName -> NonEmpty Message -> ChatRequest+chatRequest model msgs =+  ChatRequest+    { chatModel = model+    , chatMessages = msgs+    , chatTools = Nothing+    , chatFormat = Nothing+    , chatOptions = Nothing+    , chStream = Just False+    , chatKeepAlive = Nothing+    , chatThink = Nothing+    }++{- | Chat completion response payload.++@since 1.0.0.0+-}+data ChatResponse = ChatResponse+  { crModel :: !ModelName+  , crCreatedAt :: !UTCTime+  , crMessage :: !(Maybe Message)+  , crDone :: !Bool+  , crDoneReason :: !(Maybe Text)+  , crTotalDuration :: !(Maybe Duration)+  , crLoadDuration :: !(Maybe Duration)+  , crPromptEvalCount :: !(Maybe Int)+  , crPromptEvalDuration :: !(Maybe Duration)+  , crEvalCount :: !(Maybe Int)+  , crEvalDuration :: !(Maybe Duration)+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON ChatResponse where+  parseJSON = withObject "ChatResponse" $ \v ->+    ChatResponse+      <$> v .: "model"+      <*> v .: "created_at"+      <*> v .:? "message"+      <*> v .: "done"+      <*> v .:? "done_reason"+      <*> v .:? "total_duration"+      <*> v .:? "load_duration"+      <*> v .:? "prompt_eval_count"+      <*> v .:? "prompt_eval_duration"+      <*> v .:? "eval_count"+      <*> v .:? "eval_duration"++instance ToJSON ChatResponse where+  toJSON ChatResponse {..} =+    object+      [ "model" .= crModel+      , "created_at" .= crCreatedAt+      , "message" .= crMessage+      , "done" .= crDone+      , "done_reason" .= crDoneReason+      , "total_duration" .= crTotalDuration+      , "load_duration" .= crLoadDuration+      , "prompt_eval_count" .= crPromptEvalCount+      , "prompt_eval_duration" .= crPromptEvalDuration+      , "eval_count" .= crEvalCount+      , "eval_duration" .= crEvalDuration+      ]++instance HasDone ChatResponse where+  isDone = crDone++{- | Non-streaming chat completion API.++@since 1.0.0.0+-}+chat :: (MonadIO m) => OllamaClient -> ChatRequest -> m (Either OllamaError ChatResponse)+chat client req = request client "POST" "/api/chat" (Just req {chStream = Just False})++{- | Streaming chat completion API yielding 'ChatResponse' chunks.++@since 1.0.0.0+-}+chatStream :: (MonadUnliftIO m) => OllamaClient -> ChatRequest -> ConduitT () ChatResponse m ()+chatStream client req = requestStreaming client "/api/chat" (req {chStream = Just True})++{- | Calculate generation throughput (eval tokens \/ second) from a 'ChatResponse'.++@since 1.0.0.0+-}+chatEvalTokensPerSecond :: ChatResponse -> Maybe Double+chatEvalTokensPerSecond ChatResponse {..} =+  tokensPerSecond <$> crEvalCount <*> crEvalDuration++{- | Calculate prompt evaluation throughput (prompt tokens \/ second) from a 'ChatResponse'.++@since 1.0.0.0+-}+chatPromptEvalTokensPerSecond :: ChatResponse -> Maybe Double+chatPromptEvalTokensPerSecond ChatResponse {..} =+  tokensPerSecond <$> crPromptEvalCount <*> crPromptEvalDuration

@@ -0,0 +1,175 @@+{- |+Module      : Ollama.API.Embed+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Vector embeddings API endpoint (@/api/embed@).++@since 1.0.0.0+-}+module Ollama.API.Embed (+  EmbedRequest (..),+  EmbedResponse (..),+  embedRequest,+  embed,++  -- * Deprecated Legacy API+  EmbeddingsRequest (..),+  EmbeddingsResponse (..),+  embeddings,+) where++import Control.Monad.IO.Class (MonadIO)+import Data.Aeson+import Data.Maybe (catMaybes)+import Data.Text (Text)+import GHC.Generics (Generic)+import Ollama.Client (OllamaClient)+import Ollama.Client.Internal (request)+import Ollama.Error (OllamaError)+import Ollama.Types.Common (Duration, ModelName)+import Ollama.Types.Options (ModelOptions)++{- | Embedding request payload for single text or batch list of texts.++@since 1.0.0.0+-}+data EmbedRequest = EmbedRequest+  { embModel :: !ModelName+  , embInput :: !(Either Text [Text])+  , embTruncate :: !(Maybe Bool)+  , embOptions :: !(Maybe ModelOptions)+  , embKeepAlive :: !(Maybe Text)+  , embDimensions :: !(Maybe Int)+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON EmbedRequest where+  toJSON EmbedRequest {..} =+    object $+      catMaybes+        [ Just $ "model" .= embModel+        , Just $ case embInput of+            Left single -> "input" .= single+            Right multiple -> "input" .= multiple+        , ("truncate" .=) <$> embTruncate+        , ("options" .=) <$> embOptions+        , ("keep_alive" .=) <$> embKeepAlive+        , ("dimensions" .=) <$> embDimensions+        ]++{- | Create an 'EmbedRequest' for a list of input texts.++@since 1.0.0.0+-}+embedRequest :: ModelName -> [Text] -> EmbedRequest+embedRequest model inputs =+  EmbedRequest+    { embModel = model+    , embInput = Right inputs+    , embTruncate = Nothing+    , embOptions = Nothing+    , embKeepAlive = Nothing+    , embDimensions = Nothing+    }++{- | Embedding response payload containing vector embeddings.++@since 1.0.0.0+-}+data EmbedResponse = EmbedResponse+  { erModel :: !ModelName+  , erEmbeddings :: ![[Double]]+  , erTotalDuration :: !(Maybe Duration)+  , erLoadDuration :: !(Maybe Duration)+  , erPromptEvalCount :: !(Maybe Int)+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON EmbedResponse where+  parseJSON = withObject "EmbedResponse" $ \v ->+    EmbedResponse+      <$> v .: "model"+      <*> v .: "embeddings"+      <*> v .:? "total_duration"+      <*> v .:? "load_duration"+      <*> v .:? "prompt_eval_count"++instance ToJSON EmbedResponse where+  toJSON EmbedResponse {..} =+    object+      [ "model" .= erModel+      , "embeddings" .= erEmbeddings+      , "total_duration" .= erTotalDuration+      , "load_duration" .= erLoadDuration+      , "prompt_eval_count" .= erPromptEvalCount+      ]++{- | Generate vector embeddings.++@since 1.0.0.0+-}+embed :: (MonadIO m) => OllamaClient -> EmbedRequest -> m (Either OllamaError EmbedResponse)+embed client req = request client "POST" "/api/embed" (Just req)++{- | Legacy request payload for deprecated @/api/embeddings@ endpoint.++@since 1.0.0.0+-}+data EmbeddingsRequest = EmbeddingsRequest+  { ebrModel :: !ModelName+  , ebrPrompt :: !Text+  , ebrOptions :: !(Maybe ModelOptions)+  , ebrKeepAlive :: !(Maybe Text)+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON EmbeddingsRequest where+  toJSON EmbeddingsRequest {..} =+    object $+      catMaybes+        [ Just $ "model" .= ebrModel+        , Just $ "prompt" .= ebrPrompt+        , ("options" .=) <$> ebrOptions+        , ("keep_alive" .=) <$> ebrKeepAlive+        ]++instance FromJSON EmbeddingsRequest where+  parseJSON = withObject "EmbeddingsRequest" $ \v ->+    EmbeddingsRequest+      <$> v .: "model"+      <*> v .: "prompt"+      <*> v .:? "options"+      <*> v .:? "keep_alive"++{- | Legacy response payload for deprecated @/api/embeddings@ endpoint.++@since 1.0.0.0+-}+newtype EmbeddingsResponse = EmbeddingsResponse+  { ebrEmbedding :: [Double]+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON EmbeddingsResponse where+  parseJSON = withObject "EmbeddingsResponse" $ \v ->+    EmbeddingsResponse <$> v .: "embedding"++instance ToJSON EmbeddingsResponse where+  toJSON EmbeddingsResponse {..} =+    object ["embedding" .= ebrEmbedding]++{- | Generate vector embeddings using the deprecated @/api/embeddings@ endpoint.++@since 1.0.0.0+-}+embeddings ::+  (MonadIO m) =>+  OllamaClient ->+  EmbeddingsRequest ->+  m (Either OllamaError EmbeddingsResponse)+embeddings client req = request client "POST" "/api/embeddings" (Just req)+{-# DEPRECATED embeddings "Use embed instead" #-}

@@ -0,0 +1,199 @@+{- |+Module      : Ollama.API.Generate+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Text completion API endpoint (@/api/generate@).++@since 1.0.0.0+-}+module Ollama.API.Generate (+  GenerateRequest (..),+  GenerateResponse (..),+  generateRequest,+  generate,+  generateStream,+  evalTokensPerSecond,+  promptEvalTokensPerSecond,+) where++import Conduit (ConduitT)+import Control.Monad.IO.Class (MonadIO)+import Control.Monad.IO.Unlift (MonadUnliftIO)+import Data.Aeson+import Data.Maybe (catMaybes)+import Data.Text (Text)+import Data.Time (UTCTime)+import GHC.Generics (Generic)+import Ollama.Client (OllamaClient)+import Ollama.Client.Internal (request, requestStreaming)+import Ollama.Error (OllamaError)+import Ollama.Streaming (HasDone (..))+import Ollama.Types.Common (Base64Image, Duration, ModelName, Think, tokensPerSecond)+import Ollama.Types.Format (Format)+import Ollama.Types.Options (ModelOptions)++{- | Request payload for text generation completion.++@since 1.0.0.0+-}+data GenerateRequest = GenerateRequest+  { genModel :: !ModelName+  , genPrompt :: !Text+  , genSuffix :: !(Maybe Text)+  , genImages :: !(Maybe [Base64Image])+  , genFormat :: !(Maybe Format)+  , genOptions :: !(Maybe ModelOptions)+  , genSystem :: !(Maybe Text)+  , genTemplate :: !(Maybe Text)+  , genStream :: !(Maybe Bool)+  , genRaw :: !(Maybe Bool)+  , genKeepAlive :: !(Maybe Text)+  , genThink :: !(Maybe Think)+  , genWidth :: !(Maybe Int)+  , genHeight :: !(Maybe Int)+  , genSteps :: !(Maybe Int)+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON GenerateRequest where+  toJSON GenerateRequest {..} =+    object $+      catMaybes+        [ Just $ "model" .= genModel+        , Just $ "prompt" .= genPrompt+        , ("suffix" .=) <$> genSuffix+        , ("images" .=) <$> genImages+        , ("format" .=) <$> genFormat+        , ("options" .=) <$> genOptions+        , ("system" .=) <$> genSystem+        , ("template" .=) <$> genTemplate+        , ("stream" .=) <$> genStream+        , ("raw" .=) <$> genRaw+        , ("keep_alive" .=) <$> genKeepAlive+        , ("think" .=) <$> genThink+        , ("width" .=) <$> genWidth+        , ("height" .=) <$> genHeight+        , ("steps" .=) <$> genSteps+        ]++{- | Create a default 'GenerateRequest' for a model and prompt.++@since 1.0.0.0+-}+generateRequest :: ModelName -> Text -> GenerateRequest+generateRequest model prompt =+  GenerateRequest+    { genModel = model+    , genPrompt = prompt+    , genSuffix = Nothing+    , genImages = Nothing+    , genFormat = Nothing+    , genOptions = Nothing+    , genSystem = Nothing+    , genTemplate = Nothing+    , genStream = Just False+    , genRaw = Nothing+    , genKeepAlive = Nothing+    , genThink = Nothing+    , genWidth = Nothing+    , genHeight = Nothing+    , genSteps = Nothing+    }++{- | Response payload returned by text generation.++@since 1.0.0.0+-}+data GenerateResponse = GenerateResponse+  { grModel :: !ModelName+  , grCreatedAt :: !UTCTime+  , grResponse :: !Text+  , grDone :: !Bool+  , grDoneReason :: !(Maybe Text)+  , grContext :: !(Maybe [Int])+  , grTotalDuration :: !(Maybe Duration)+  , grLoadDuration :: !(Maybe Duration)+  , grPromptEvalCount :: !(Maybe Int)+  , grPromptEvalDuration :: !(Maybe Duration)+  , grEvalCount :: !(Maybe Int)+  , grEvalDuration :: !(Maybe Duration)+  , grThinking :: !(Maybe Text)+  , grImage :: !(Maybe Base64Image)+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON GenerateResponse where+  parseJSON = withObject "GenerateResponse" $ \v ->+    GenerateResponse+      <$> v .: "model"+      <*> v .: "created_at"+      <*> v .: "response"+      <*> v .: "done"+      <*> v .:? "done_reason"+      <*> v .:? "context"+      <*> v .:? "total_duration"+      <*> v .:? "load_duration"+      <*> v .:? "prompt_eval_count"+      <*> v .:? "prompt_eval_duration"+      <*> v .:? "eval_count"+      <*> v .:? "eval_duration"+      <*> v .:? "thinking"+      <*> v .:? "image"++instance ToJSON GenerateResponse where+  toJSON GenerateResponse {..} =+    object+      [ "model" .= grModel+      , "created_at" .= grCreatedAt+      , "response" .= grResponse+      , "done" .= grDone+      , "done_reason" .= grDoneReason+      , "context" .= grContext+      , "total_duration" .= grTotalDuration+      , "load_duration" .= grLoadDuration+      , "prompt_eval_count" .= grPromptEvalCount+      , "prompt_eval_duration" .= grPromptEvalDuration+      , "eval_count" .= grEvalCount+      , "eval_duration" .= grEvalDuration+      , "thinking" .= grThinking+      , "image" .= grImage+      ]++instance HasDone GenerateResponse where+  isDone = grDone++{- | Non-streaming text completion API.++@since 1.0.0.0+-}+generate ::+  (MonadIO m) => OllamaClient -> GenerateRequest -> m (Either OllamaError GenerateResponse)+generate client req = request client "POST" "/api/generate" (Just req {genStream = Just False})++{- | Streaming text completion API yielding 'GenerateResponse' chunks.++@since 1.0.0.0+-}+generateStream ::+  (MonadUnliftIO m) => OllamaClient -> GenerateRequest -> ConduitT () GenerateResponse m ()+generateStream client req = requestStreaming client "/api/generate" (req {genStream = Just True})++{- | Calculate generation throughput (eval tokens \/ second) from a 'GenerateResponse'.++@since 1.0.0.0+-}+evalTokensPerSecond :: GenerateResponse -> Maybe Double+evalTokensPerSecond GenerateResponse {..} =+  tokensPerSecond <$> grEvalCount <*> grEvalDuration++{- | Calculate prompt evaluation throughput (prompt tokens \/ second) from a 'GenerateResponse'.++@since 1.0.0.0+-}+promptEvalTokensPerSecond :: GenerateResponse -> Maybe Double+promptEvalTokensPerSecond GenerateResponse {..} =+  tokensPerSecond <$> grPromptEvalCount <*> grPromptEvalDuration

@@ -0,0 +1,171 @@+{- |+Module      : Ollama.API.Models+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Model management endpoints (list, show, copy, delete).++@since 1.0.0.0+-}+module Ollama.API.Models (+  -- * Listing+  listModels,+  ListResponse (..),++  -- * Show Info+  showModel,+  ShowRequest (..),+  ShowResponse (..),+  ShowModelInfo (..),++  -- * Copy+  copyModel,+  CopyRequest (..),++  -- * Delete+  deleteModel,+  DeleteRequest (..),+) where++import Control.Monad.IO.Class (MonadIO)+import Data.Aeson+import Data.Map.Strict (Map)+import Data.Maybe (catMaybes)+import Data.Text (Text)+import GHC.Generics (Generic)+import Ollama.Client (OllamaClient)+import Ollama.Client.Internal (request)+import Ollama.Error (OllamaError)+import Ollama.Types.Common (ModelName)+import Ollama.Types.Model (ListResponse (..), ModelDetails (..))++{- | Show model info request payload.++@since 1.0.0.0+-}+data ShowRequest = ShowRequest+  { srqModel :: !ModelName+  , srqVerbose :: !(Maybe Bool)+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON ShowRequest where+  toJSON ShowRequest {..} =+    object $+      catMaybes+        [ Just $ "model" .= srqModel+        , ("verbose" .=) <$> srqVerbose+        ]++{- | Detailed technical parameters from model metadata.++@since 1.0.0.0+-}+newtype ShowModelInfo = ShowModelInfo+  { modelInfoMap :: Map Text Value+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON ShowModelInfo where+  parseJSON v = ShowModelInfo <$> parseJSON v++instance ToJSON ShowModelInfo where+  toJSON (ShowModelInfo m) = toJSON m++{- | Model inspection response payload.++@since 1.0.0.0+-}+data ShowResponse = ShowResponse+  { srsModelfile :: !Text+  , srsParameters :: !(Maybe Text)+  , srsTemplate :: !(Maybe Text)+  , srsDetails :: !ModelDetails+  , srsModelInfo :: !(Maybe ShowModelInfo)+  , srsLicense :: !(Maybe Text)+  , srsCapabilities :: !(Maybe [Text])+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON ShowResponse where+  parseJSON = withObject "ShowResponse" $ \v ->+    ShowResponse+      <$> v .:? "modelfile" .!= ""+      <*> v .:? "parameters"+      <*> v .:? "template"+      <*> v .:? "details" .!= ModelDetails Nothing "" "" [] "" ""+      <*> v .:? "model_info"+      <*> v .:? "license"+      <*> v .:? "capabilities"++instance ToJSON ShowResponse where+  toJSON ShowResponse {..} =+    object+      [ "modelfile" .= srsModelfile+      , "parameters" .= srsParameters+      , "template" .= srsTemplate+      , "details" .= srsDetails+      , "model_info" .= srsModelInfo+      , "license" .= srsLicense+      , "capabilities" .= srsCapabilities+      ]++{- | Copy model request payload.++@since 1.0.0.0+-}+data CopyRequest = CopyRequest+  { cpSource :: !ModelName+  , cpDestination :: !ModelName+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON CopyRequest where+  toJSON CopyRequest {..} =+    object+      [ "source" .= cpSource+      , "destination" .= cpDestination+      ]++{- | Delete model request payload.++@since 1.0.0.0+-}+newtype DeleteRequest = DeleteRequest+  { delModel :: ModelName+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON DeleteRequest where+  toJSON DeleteRequest {..} = object ["model" .= delModel]++{- | List installed local models (@GET /api/tags@).++@since 1.0.0.0+-}+listModels :: (MonadIO m) => OllamaClient -> m (Either OllamaError ListResponse)+listModels client = request client "GET" "/api/tags" (Nothing :: Maybe Value)++{- | Fetch information and Modelfile content for a model (@POST /api/show@).++@since 1.0.0.0+-}+showModel :: (MonadIO m) => OllamaClient -> ModelName -> m (Either OllamaError ShowResponse)+showModel client model = request client "POST" "/api/show" (Just $ ShowRequest model Nothing)++{- | Duplicate an existing model under a new tag (@POST /api/copy@).++@since 1.0.0.0+-}+copyModel :: (MonadIO m) => OllamaClient -> ModelName -> ModelName -> m (Either OllamaError ())+copyModel client src dst = request client "POST" "/api/copy" (Just $ CopyRequest src dst)++{- | Delete a local model (@DELETE /api/delete@).++@since 1.0.0.0+-}+deleteModel :: (MonadIO m) => OllamaClient -> ModelName -> m (Either OllamaError ())+deleteModel client model = request client "DELETE" "/api/delete" (Just $ DeleteRequest model)

@@ -0,0 +1,165 @@+{- |+Module      : Ollama.API.Models.Create+Copyright   : (c) 2024-2026 Tushar Adhatrao+License     : MIT+Maintainer  : tusharadhatrao@gmail.com+Stability   : stable+Portability : portable++Model creation endpoint (@/api/create@).++@since 1.0.0.0+-}+module Ollama.API.Models.Create (+  CreateRequest (..),+  CreateResponse (..),+  QuantizationType (..),+  createModel,+  createModelStream,+  defaultCreateRequest,+) where++import Conduit (ConduitT)+import Control.Monad.IO.Class (MonadIO)+import Control.Monad.IO.Unlift (MonadUnliftIO)+import Data.Aeson+import Data.Int (Int64)+import Data.Map.Strict (Map)+import Data.Maybe (catMaybes)+import Data.Text (Text)+import GHC.Generics (Generic)+import Ollama.Client (OllamaClient)+import Ollama.Client.Internal (request, requestStreaming)+import Ollama.Error (OllamaError)+import Ollama.Streaming (HasDone (..))+import Ollama.Types.Common (Digest, ModelName)+import Ollama.Types.Message (Message)+import Ollama.Types.Options (ModelOptions)++{- | Quantization precision options for model creation.++@since 1.0.0.0+-}+data QuantizationType = Q4_K_M | Q4_K_S | Q8_0+  deriving stock (Eq, Show, Bounded, Enum, Generic)++instance ToJSON QuantizationType where+  toJSON Q4_K_M = String "q4_K_M"+  toJSON Q4_K_S = String "q4_K_S"+  toJSON Q8_0 = String "q8_0"++instance FromJSON QuantizationType where+  parseJSON = withText "QuantizationType" $ \case+    "q4_K_M" -> pure Q4_K_M+    "q4_K_S" -> pure Q4_K_S+    "q8_0" -> pure Q8_0+    other -> fail $ "Invalid QuantizationType: " <> show other++{- | Model creation request configuration payload.++@since 1.0.0.0+-}+data CreateRequest = CreateRequest+  { crqModel :: !ModelName+  , crqFrom :: !(Maybe ModelName)+  , crqFiles :: !(Maybe (Map Text Digest))+  , crqAdapters :: !(Maybe (Map Text Digest))+  , crqTemplate :: !(Maybe Text)+  , crqRenderer :: !(Maybe Text)+  , crqParser :: !(Maybe Text)+  , crqLicense :: !(Maybe [Text])+  , crqSystem :: !(Maybe Text)+  , crqParameters :: !(Maybe ModelOptions)+  , crqMessages :: !(Maybe [Message])+  , crqStream :: !(Maybe Bool)+  , crqQuantize :: !(Maybe QuantizationType)+  }+  deriving stock (Eq, Show, Generic)++instance ToJSON CreateRequest where+  toJSON CreateRequest {..} =+    object $+      catMaybes+        [ Just $ "model" .= crqModel+        , ("from" .=) <$> crqFrom+        , ("files" .=) <$> crqFiles+        , ("adapters" .=) <$> crqAdapters+        , ("template" .=) <$> crqTemplate+        , ("renderer" .=) <$> crqRenderer+        , ("parser" .=) <$> crqParser+        , ("license" .=) <$> crqLicense+        , ("system" .=) <$> crqSystem+        , ("parameters" .=) <$> crqParameters+        , ("messages" .=) <$> crqMessages+        , ("stream" .=) <$> crqStream+        , ("quantize" .=) <$> crqQuantize+        ]++{- | Smart constructor for a basic 'CreateRequest'.++@since 1.0.0.0+-}+defaultCreateRequest :: ModelName -> CreateRequest+defaultCreateRequest name =+  CreateRequest+    { crqModel = name+    , crqFrom = Nothing+    , crqFiles = Nothing+    , crqAdapters = Nothing+    , crqTemplate = Nothing+    , crqRenderer = Nothing+    , crqParser = Nothing+    , crqLicense = Nothing+    , crqSystem = Nothing+    , crqParameters = Nothing+    , crqMessages = Nothing+    , crqStream = Just False+    , crqQuantize = Nothing+    }++{- | Progress / status response during model creation.++@since 1.0.0.0+-}+data CreateResponse = CreateResponse+  { crsStatus :: !Text+  , crsDigest :: !(Maybe Digest)+  , crsTotal :: !(Maybe Int64)+  , crsCompleted :: !(Maybe Int64)+  }+  deriving stock (Eq, Show, Generic)++instance FromJSON CreateResponse where+  parseJSON = withObject "CreateResponse" $ \v ->+    CreateResponse+      <$> v .: "status"+      <*> v .:? "digest"+      <*> v .:? "total"+      <*> v .:? "completed"++instance ToJSON CreateResponse where+  toJSON CreateResponse {..} =+    object+      [ "status" .= crsStatus+      , "digest" .= crsDigest+      , "total" .= crsTotal+      , "completed" .= crsCompleted+      ]++instance HasDone CreateResponse where+  isDone CreateResponse {..} = crsStatus == "success"++{- | Create a model non-streaming.++@since 1.0.0.0+-}+createModel :: (MonadIO m) => OllamaClient -> CreateRequest -> m (Either OllamaError CreateResponse)+createModel client req = request client "POST" "/api/create" (Just req {crqStream = Just False})++{- | Create a model streaming progress updates.++@since 1.0.0.0+-}+createModelStream ::+  (MonadUnliftIO m) => OllamaClient -> CreateRequest -> ConduitT () CreateResponse m ()+createModelStream client req = requestStreaming client "/api/create" (req {crqStream = Just True})