feat: Add comprehensive Ollama integration with chat and embedding support (#385)

## Summary
This PR adds comprehensive Ollama integration to AgentScope, enabling
users to leverage local Ollama models with full feature support.

## Features Implemented
### Core Chat Features:
- **OllamaOptions**: Complete configuration class supporting 40+ Ollama
parameters including advanced model loading options (GPU offloading,
memory management) and runtime generation parameters (sampling
strategies, penalties)
- **OllamaHttpClient**: HTTP client for Ollama API with sync/async and
streaming support, proper JSON serialization/deserialization and error
handling
- **OllamaChatModel**: Full ChatModel implementation with tool usage,
streaming, timeout/retry mechanisms, and seamless integration with
AgentScope framework

### Message Formatting System:
- **OllamaChatFormatter**: Standard chat formatting with proper role
mapping
- **OllamaMultiAgentFormatter**: Multi-agent conversation formatting
with history management
- **OllamaMessageConverter**: Message conversion between AgentScope and
Ollama formats
- **OllamaConversationMerger**: Multi-agent conversation merging with
history tags
- **OllamaToolsHelper**: Tool configuration and usage support
- **OllamaMediaConverter**: Media and image handling for multimodal
models

### Text Embedding Features:
- **OllamaTextEmbedding**: Complete text embedding implementation with
support for Ollama's embedding API
- Includes proper error handling, timeout/retry mechanisms, and
dimension validation
- Supports reactive programming with Project Reactor's Mono

### API DTOs:
- Complete set of data transfer objects for Ollama API requests and
responses
- Support for messages, tools, tool calls, embeddings, and complex
conversation structures

## Design Decisions
- Used adapter pattern instead of inheritance for OllamaOptions to avoid
coupling with generic options
- Implemented flexible message formatting system supporting both
standard and multi-agent scenarios
- Added Chain of Thought (CoT) support through thinking options
- Optimized single message handling to avoid unnecessary conversation
history wrapping
- Proper reactive programming support with timeout and retry mechanisms

## Testing
- Complete test coverage for all Ollama components
- Unit tests for message formatting, conversion, and API communication
- Integration tests for end-to-end functionality
- Tests for both chat and embedding functionality

## Additional Notes
This integration provides a complete solution for using Ollama models
within the AgentScope ecosystem with full feature parity.

Author: devnomad-byte

agentscope-core/src/main/java/io/agentscope/core/formatter/ollama/OllamaChatFormatter.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2024-2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.agentscope.core.formatter.ollama;
+
+import io.agentscope.core.formatter.ollama.dto.OllamaMessage;
+import io.agentscope.core.message.Base64Source;
+import io.agentscope.core.message.ContentBlock;
+import io.agentscope.core.message.ImageBlock;
+import io.agentscope.core.message.Msg;
+import io.agentscope.core.message.TextBlock;
+import io.agentscope.core.message.ToolResultBlock;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Merges multi-agent conversation messages for Ollama API.
+ *
+ */
+public class OllamaConversationMerger {
+    private static final Logger log = LoggerFactory.getLogger(OllamaConversationMerger.class);
+    private static final String HISTORY_START_TAG = "<history>";
+    private static final String HISTORY_END_TAG = "</history>";
+
+    private final String conversationHistoryPrompt;
+
+    public OllamaConversationMerger(String conversationHistoryPrompt) {
+        this.conversationHistoryPrompt = conversationHistoryPrompt;
+    }
+
+    public OllamaMessage mergeToMessage(
+            List<Msg> msgs,
+            Function<Msg, String> nameExtractor,
+            Function<List<ContentBlock>, String> toolResultConverter,
+            String historyPrompt) {
+
+        StringBuilder textAccumulator = new StringBuilder();
+        if (historyPrompt != null && !historyPrompt.isEmpty()) {
+            textAccumulator.append(historyPrompt);
+        }
+        textAccumulator.append(HISTORY_START_TAG).append("\n");
+
+        List<String> images = new ArrayList<>();
+
+        for (Msg msg : msgs) {
+            String name = nameExtractor.apply(msg);
+
+            for (ContentBlock block : msg.getContent()) {
+                if (block instanceof TextBlock) {
+                    textAccumulator
+                            .append(name)
+                            .append(": ")
+                            .append(((TextBlock) block).getText())
+                            .append("\n");
+                } else if (block instanceof ImageBlock) {
+                    ImageBlock imageBlock = (ImageBlock) block;
+                    if (imageBlock.getSource() instanceof Base64Source) {
+                        Base64Source source = (Base64Source) imageBlock.getSource();
+                        images.add(source.getData());
+                        textAccumulator.append(name).append(": [Image]\n");
+                    } else {
+                        log.warn(
+                                "URL image source not yet supported for Ollama, skipping image"
+                                        + " block in merger");
+                        textAccumulator.append(name).append(": [Image - processing failed]\n");
+                    }
+                } else if (block instanceof ToolResultBlock) {
+                    // Tool results in history are usually just appended as text
+                    ToolResultBlock toolResult = (ToolResultBlock) block;
+
+                    // Simplify: Just append tool result string.
+                    Object output = toolResult.getOutput();
+                    String resultText =
+                            output instanceof String ? (String) output : String.valueOf(output);
+
+                    textAccumulator
+                            .append(name)
+                            .append(" (")
+                            .append(toolResult.getName())
+                            .append("): ")
+                            .append(resultText)
+                            .append("\n");
+                }
+            }
+        }
+
+        textAccumulator.append(HISTORY_END_TAG);
+
+        OllamaMessage message = new OllamaMessage();
+        message.setRole("user"); // Merged history is typically treated as user input context
+        message.setContent(textAccumulator.toString());
+        if (!images.isEmpty()) {
+            message.setImages(images);
+        }
+
+        return message;
+    }
+}

agentscope-core/src/main/java/io/agentscope/core/formatter/ollama/OllamaConversationMerger.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2024-2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.agentscope.core.formatter.ollama;
+
+import io.agentscope.core.formatter.MediaUtils;
+import io.agentscope.core.message.Base64Source;
+import io.agentscope.core.message.ImageBlock;
+import io.agentscope.core.message.Source;
+import io.agentscope.core.message.URLSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handles media content conversion for Ollama API.
+ * Converts ImageBlock to Base64 strings as required by Ollama.
+ *
+ */
+public class OllamaMediaConverter {
+
+    private static final Logger log = LoggerFactory.getLogger(OllamaMediaConverter.class);
+
+    /**
+     * Convert ImageBlock to Base64 string for Ollama API.
+     *
+     * <p>Ollama API expects an array of base64-encoded strings for images.
+     * This method handles:
+     * <ul>
+     *   <li>Base64 sources → Returns raw base64 data</li>
+     *   <li>Local file URLs → Reads file and converts to base64</li>
+     *   <li>Remote URLs → Downloads content and converts to base64</li>
+     * </ul>
+     *
+     * @param imageBlock The image block to convert
+     * @return Base64 encoded string of the image
+     * @throws Exception If conversion, file reading, or download fails
+     */
+    public String convertImageBlockToBase64(ImageBlock imageBlock) throws Exception {
+        Source source = imageBlock.getSource();
+
+        if (source instanceof Base64Source base64Source) {
+            // Ollama expects raw base64 string without data URI prefix
+            return base64Source.getData();
+        } else if (source instanceof URLSource urlSource) {
+            String url = urlSource.getUrl();
+            MediaUtils.validateImageExtension(url);
+
+            if (MediaUtils.isLocalFile(url)) {
+                // Read local file to base64
+                // Remove file:// prefix if present for local path
+                String path = url.startsWith("file://") ? url.substring(7) : url;
+                return MediaUtils.fileToBase64(path);
+            } else {
+                // Download remote URL to base64
+                return MediaUtils.downloadUrlToBase64(url);
+            }
+        } else {
+            throw new IllegalArgumentException("Unsupported source type: " + source.getClass());
+        }
+    }
+}