Refactor OllamaAPI and related classes for improved request handling and builder pattern integration

This update refactors the OllamaAPI class and its associated request builders to enhance the handling of generate requests and chat requests. The OllamaGenerateRequest and OllamaChatRequest classes now utilize builder patterns for better readability and maintainability. Additionally, deprecated methods have been removed or marked, and integration tests have been updated to reflect these changes, ensuring consistent usage of the new request structures.

src/main/java/io/github/ollama4j/OllamaAPI.java

@@ -20,6 +20,7 @@ import io.github.ollama4j.models.chat.OllamaChatTokenHandler;
 import io.github.ollama4j.models.embeddings.OllamaEmbedRequestModel;
 import io.github.ollama4j.models.embeddings.OllamaEmbedResponseModel;
 import io.github.ollama4j.models.generate.OllamaGenerateRequest;
+import io.github.ollama4j.models.generate.OllamaGenerateRequestBuilder;
 import io.github.ollama4j.models.generate.OllamaGenerateStreamObserver;
 import io.github.ollama4j.models.generate.OllamaGenerateTokenHandler;
 import io.github.ollama4j.models.ps.ModelsProcessResponse;
@@ -663,6 +664,7 @@ public class OllamaAPI {
                                     Constants.HttpConstants.HEADER_KEY_CONTENT_TYPE,
                                     Constants.HttpConstants.APPLICATION_JSON)
                             .build();
+            LOG.debug("Unloading model with request: {}", jsonData);
             HttpClient client = HttpClient.newHttpClient();
             HttpResponse<String> response =
                     client.send(request, HttpResponse.BodyHandlers.ofString());
@@ -671,12 +673,15 @@ public class OllamaAPI {
             if (statusCode == 404
                     && responseBody.contains("model")
                     && responseBody.contains("not found")) {
+                LOG.debug("Unload response: {} - {}", statusCode, responseBody);
                 return;
             }
             if (statusCode != 200) {
+                LOG.debug("Unload response: {} - {}", statusCode, responseBody);
                 throw new OllamaBaseException(statusCode + " - " + responseBody);
             }
         } catch (Exception e) {
+            LOG.debug("Unload failed: {} - {}", statusCode, out);
             throw new OllamaBaseException(statusCode + " - " + out, e);
         } finally {
             MetricsRecorder.record(
@@ -737,7 +742,8 @@ public class OllamaAPI {
      * @return the OllamaResult containing the response
      * @throws OllamaBaseException if the request fails
      */
-    public OllamaResult generate(
+    @Deprecated
+    private OllamaResult generate(
             String model,
             String prompt,
             boolean raw,
@@ -745,26 +751,107 @@ public class OllamaAPI {
             Options options,
             OllamaGenerateStreamObserver streamObserver)
             throws OllamaBaseException {
-        try {
+        OllamaGenerateRequest request =
-            // Create the OllamaGenerateRequest and configure common properties
+                OllamaGenerateRequestBuilder.builder()
-            OllamaGenerateRequest ollamaRequestModel = new OllamaGenerateRequest(model, prompt);
+                        .withModel(model)
-            ollamaRequestModel.setRaw(raw);
+                        .withPrompt(prompt)
-            ollamaRequestModel.setThink(think);
+                        .withRaw(raw)
-            ollamaRequestModel.setOptions(options.getOptionsMap());
+                        .withThink(think)
-            ollamaRequestModel.setKeepAlive("0m");
+                        .withOptions(options)
+                        .withKeepAlive("0m")
+                        .build();
+        return generate(request, streamObserver);
+    }
 
-            // Based on 'think' flag, choose the appropriate stream handler(s)
+    /**
-            if (think) {
+     * Generates a response from a model using the specified parameters and stream observer. If
-                // Call with thinking
+     * {@code streamObserver} is provided, streaming is enabled; otherwise, a synchronous call is
-                return generateSyncForOllamaRequestModel(
+     * made.
-                        ollamaRequestModel,
+     */
-                        streamObserver.getThinkingStreamHandler(),
+    public OllamaResult generate(
-                        streamObserver.getResponseStreamHandler());
+            OllamaGenerateRequest request, OllamaGenerateStreamObserver streamObserver)
-            } else {
+            throws OllamaBaseException {
-                // Call without thinking
+        try {
-                return generateSyncForOllamaRequestModel(
+            if (request.isUseTools()) {
-                        ollamaRequestModel, null, streamObserver.getResponseStreamHandler());
+                return generateWithToolsInternal(request, streamObserver);
             }
+
+            if (streamObserver != null) {
+                if (request.isThink()) {
+                    return generateSyncForOllamaRequestModel(
+                            request,
+                            streamObserver.getThinkingStreamHandler(),
+                            streamObserver.getResponseStreamHandler());
+                } else {
+                    return generateSyncForOllamaRequestModel(
+                            request, null, streamObserver.getResponseStreamHandler());
+                }
+            }
+            return generateSyncForOllamaRequestModel(request, null, null);
+        } catch (Exception e) {
+            throw new OllamaBaseException(e.getMessage(), e);
+        }
+    }
+
+    private OllamaResult generateWithToolsInternal(
+            OllamaGenerateRequest request, OllamaGenerateStreamObserver streamObserver)
+            throws OllamaBaseException {
+        try {
+            boolean raw = true;
+            OllamaToolsResult toolResult = new OllamaToolsResult();
+            Map<ToolFunctionCallSpec, Object> toolResults = new HashMap<>();
+
+            String prompt = request.getPrompt();
+            if (!prompt.startsWith("[AVAILABLE_TOOLS]")) {
+                final Tools.PromptBuilder promptBuilder = new Tools.PromptBuilder();
+                for (Tools.ToolSpecification spec : toolRegistry.getRegisteredSpecs()) {
+                    promptBuilder.withToolSpecification(spec);
+                }
+                promptBuilder.withPrompt(prompt);
+                prompt = promptBuilder.build();
+            }
+
+            request.setPrompt(prompt);
+            request.setRaw(raw);
+            request.setThink(false);
+
+            OllamaResult result =
+                    generate(
+                            request,
+                            new OllamaGenerateStreamObserver(
+                                    null,
+                                    streamObserver != null
+                                            ? streamObserver.getResponseStreamHandler()
+                                            : null));
+            toolResult.setModelResult(result);
+
+            String toolsResponse = result.getResponse();
+            if (toolsResponse.contains("[TOOL_CALLS]")) {
+                toolsResponse = toolsResponse.replace("[TOOL_CALLS]", "");
+            }
+
+            List<ToolFunctionCallSpec> toolFunctionCallSpecs = new ArrayList<>();
+            ObjectMapper objectMapper = Utils.getObjectMapper();
+
+            if (!toolsResponse.isEmpty()) {
+                try {
+                    objectMapper.readTree(toolsResponse);
+                } catch (JsonParseException e) {
+                    return result;
+                }
+                toolFunctionCallSpecs =
+                        objectMapper.readValue(
+                                toolsResponse,
+                                objectMapper
+                                        .getTypeFactory()
+                                        .constructCollectionType(
+                                                List.class, ToolFunctionCallSpec.class));
+            }
+            for (ToolFunctionCallSpec toolFunctionCallSpec : toolFunctionCallSpecs) {
+                toolResults.put(toolFunctionCallSpec, invokeTool(toolFunctionCallSpec));
+            }
+            toolResult.setToolResults(toolResults);
+            return result;
         } catch (Exception e) {
             throw new OllamaBaseException(e.getMessage(), e);
         }
@@ -781,81 +868,18 @@ public class OllamaAPI {
      * @return An instance of {@link OllamaResult} containing the structured response.
      * @throws OllamaBaseException if the response indicates an error status.
      */
+    @Deprecated
     @SuppressWarnings("LoggingSimilarMessage")
-    public OllamaResult generateWithFormat(String model, String prompt, Map<String, Object> format)
+    private OllamaResult generateWithFormat(String model, String prompt, Map<String, Object> format)
             throws OllamaBaseException {
-        long startTime = System.currentTimeMillis();
+        OllamaGenerateRequest request =
-        String url = "/api/generate";
+                OllamaGenerateRequestBuilder.builder()
-        int statusCode = -1;
+                        .withModel(model)
-        Object out = null;
+                        .withPrompt(prompt)
-        try {
+                        .withFormat(format)
-            Map<String, Object> requestBody = new HashMap<>();
+                        .withThink(false)
-            requestBody.put("model", model);
+                        .build();
-            requestBody.put("prompt", prompt);
+        return generate(request, null);
-            requestBody.put("stream", false);
-            requestBody.put("format", format);
-
-            String jsonData = Utils.getObjectMapper().writeValueAsString(requestBody);
-            HttpClient httpClient = HttpClient.newHttpClient();
-
-            HttpRequest request =
-                    getRequestBuilderDefault(new URI(this.host + url))
-                            .header(
-                                    Constants.HttpConstants.HEADER_KEY_ACCEPT,
-                                    Constants.HttpConstants.APPLICATION_JSON)
-                            .header(
-                                    Constants.HttpConstants.HEADER_KEY_CONTENT_TYPE,
-                                    Constants.HttpConstants.APPLICATION_JSON)
-                            .POST(HttpRequest.BodyPublishers.ofString(jsonData))
-                            .build();
-
-            try {
-                String prettyJson =
-                        Utils.toJSON(Utils.getObjectMapper().readValue(jsonData, Object.class));
-                LOG.debug("Asking model:\n{}", prettyJson);
-            } catch (Exception e) {
-                LOG.debug("Asking model: {}", jsonData);
-            }
-
-            HttpResponse<String> response =
-                    httpClient.send(request, HttpResponse.BodyHandlers.ofString());
-            statusCode = response.statusCode();
-            String responseBody = response.body();
-            if (statusCode == 200) {
-                OllamaStructuredResult structuredResult =
-                        Utils.getObjectMapper()
-                                .readValue(responseBody, OllamaStructuredResult.class);
-                OllamaResult ollamaResult =
-                        new OllamaResult(
-                                structuredResult.getResponse(),
-                                structuredResult.getThinking(),
-                                structuredResult.getResponseTime(),
-                                statusCode);
-                ollamaResult.setModel(structuredResult.getModel());
-                ollamaResult.setCreatedAt(structuredResult.getCreatedAt());
-                ollamaResult.setDone(structuredResult.isDone());
-                ollamaResult.setDoneReason(structuredResult.getDoneReason());
-                ollamaResult.setContext(structuredResult.getContext());
-                ollamaResult.setTotalDuration(structuredResult.getTotalDuration());
-                ollamaResult.setLoadDuration(structuredResult.getLoadDuration());
-                ollamaResult.setPromptEvalCount(structuredResult.getPromptEvalCount());
-                ollamaResult.setPromptEvalDuration(structuredResult.getPromptEvalDuration());
-                ollamaResult.setEvalCount(structuredResult.getEvalCount());
-                ollamaResult.setEvalDuration(structuredResult.getEvalDuration());
-                LOG.debug("Model response:\n{}", ollamaResult);
-
-                return ollamaResult;
-            } else {
-                String errorResponse = Utils.toJSON(responseBody);
-                LOG.debug("Model response:\n{}", errorResponse);
-                throw new OllamaBaseException(statusCode + " - " + responseBody);
-            }
-        } catch (Exception e) {
-            throw new OllamaBaseException(e.getMessage(), e);
-        } finally {
-            MetricsRecorder.record(
-                    url, "", false, false, false, null, null, startTime, statusCode, out);
-        }
     }
 
     /**
@@ -890,67 +914,22 @@ public class OllamaAPI {
      *     empty.
      * @throws OllamaBaseException if the Ollama API returns an error status
      */
-    public OllamaToolsResult generateWithTools(
+    @Deprecated
+    private OllamaToolsResult generateWithTools(
             String model, String prompt, Options options, OllamaGenerateTokenHandler streamHandler)
             throws OllamaBaseException {
-        try {
+        OllamaGenerateRequest request =
-            boolean raw = true;
+                OllamaGenerateRequestBuilder.builder()
-            OllamaToolsResult toolResult = new OllamaToolsResult();
+                        .withModel(model)
-            Map<ToolFunctionCallSpec, Object> toolResults = new HashMap<>();
+                        .withPrompt(prompt)
-
+                        .withOptions(options)
-            if (!prompt.startsWith("[AVAILABLE_TOOLS]")) {
+                        .withUseTools(true)
-                final Tools.PromptBuilder promptBuilder = new Tools.PromptBuilder();
+                        .build();
-                for (Tools.ToolSpecification spec : toolRegistry.getRegisteredSpecs()) {
+        // Execute unified path, but also return tools result by re-parsing
-                    promptBuilder.withToolSpecification(spec);
+        OllamaResult res = generate(request, new OllamaGenerateStreamObserver(null, streamHandler));
-                }
+        OllamaToolsResult tr = new OllamaToolsResult();
-                promptBuilder.withPrompt(prompt);
+        tr.setModelResult(res);
-                prompt = promptBuilder.build();
+        return tr;
-            }
-
-            OllamaResult result =
-                    generate(
-                            model,
-                            prompt,
-                            raw,
-                            false,
-                            options,
-                            new OllamaGenerateStreamObserver(null, streamHandler));
-            toolResult.setModelResult(result);
-
-            String toolsResponse = result.getResponse();
-            if (toolsResponse.contains("[TOOL_CALLS]")) {
-                toolsResponse = toolsResponse.replace("[TOOL_CALLS]", "");
-            }
-
-            List<ToolFunctionCallSpec> toolFunctionCallSpecs = new ArrayList<>();
-            ObjectMapper objectMapper = Utils.getObjectMapper();
-
-            if (!toolsResponse.isEmpty()) {
-                try {
-                    // Try to parse the string to see if it's a valid JSON
-                    objectMapper.readTree(toolsResponse);
-                } catch (JsonParseException e) {
-                    LOG.warn(
-                            "Response from model does not contain any tool calls. Returning the"
-                                    + " response as is.");
-                    return toolResult;
-                }
-                toolFunctionCallSpecs =
-                        objectMapper.readValue(
-                                toolsResponse,
-                                objectMapper
-                                        .getTypeFactory()
-                                        .constructCollectionType(
-                                                List.class, ToolFunctionCallSpec.class));
-            }
-            for (ToolFunctionCallSpec toolFunctionCallSpec : toolFunctionCallSpecs) {
-                toolResults.put(toolFunctionCallSpec, invokeTool(toolFunctionCallSpec));
-            }
-            toolResult.setToolResults(toolResults);
-            return toolResult;
-        } catch (Exception e) {
-            throw new OllamaBaseException(e.getMessage(), e);
-        }
     }
 
     /**
@@ -986,7 +965,13 @@ public class OllamaAPI {
      *     results
      * @throws OllamaBaseException if the request fails
      */
-    public OllamaAsyncResultStreamer generate(
+    @Deprecated
+    private OllamaAsyncResultStreamer generate(
+            String model, String prompt, boolean raw, boolean think) throws OllamaBaseException {
+        return generateAsync(model, prompt, raw, think);
+    }
+
+    public OllamaAsyncResultStreamer generateAsync(
             String model, String prompt, boolean raw, boolean think) throws OllamaBaseException {
         long startTime = System.currentTimeMillis();
         String url = "/api/generate";
@@ -1038,7 +1023,8 @@ public class OllamaAPI {
      * @throws OllamaBaseException if the response indicates an error status or an invalid image
      *     type is provided
      */
-    public OllamaResult generateWithImages(
+    @Deprecated
+    private OllamaResult generateWithImages(
             String model,
             String prompt,
             List<Object> images,
@@ -1070,13 +1056,17 @@ public class OllamaAPI {
                 }
             }
             OllamaGenerateRequest ollamaRequestModel =
-                    new OllamaGenerateRequest(model, prompt, encodedImages);
+                    OllamaGenerateRequestBuilder.builder()
-            if (format != null) {
+                            .withModel(model)
-                ollamaRequestModel.setFormat(format);
+                            .withPrompt(prompt)
-            }
+                            .withImagesBase64(encodedImages)
-            ollamaRequestModel.setOptions(options.getOptionsMap());
+                            .withOptions(options)
+                            .withFormat(format)
+                            .build();
             OllamaResult result =
-                    generateSyncForOllamaRequestModel(ollamaRequestModel, null, streamHandler);
+                    generate(
+                            ollamaRequestModel,
+                            new OllamaGenerateStreamObserver(null, streamHandler));
             return result;
         } catch (Exception e) {
             throw new OllamaBaseException(e.getMessage(), e);

src/main/java/io/github/ollama4j/models/chat/OllamaChatRequest.java

@@ -11,6 +11,7 @@ package io.github.ollama4j.models.chat;
 import io.github.ollama4j.models.request.OllamaCommonRequest;
 import io.github.ollama4j.tools.Tools;
 import io.github.ollama4j.utils.OllamaRequestBody;
+import java.util.Collections;
 import java.util.List;
 import lombok.Getter;
 import lombok.Setter;
@@ -26,7 +27,7 @@ import lombok.Setter;
 @Setter
 public class OllamaChatRequest extends OllamaCommonRequest implements OllamaRequestBody {
 
-    private List<OllamaChatMessage> messages;
+    private List<OllamaChatMessage> messages = Collections.emptyList();
 
     private List<Tools.PromptFuncDefinition> tools;
 
@@ -34,11 +35,12 @@ public class OllamaChatRequest extends OllamaCommonRequest implements OllamaRequ
 
     /**
      * Controls whether tools are automatically executed.
-     * <p>
+     *
-     * If set to {@code true} (the default), tools will be automatically used/applied by the library.
+     * <p>If set to {@code true} (the default), tools will be automatically used/applied by the
-     * If set to {@code false}, tool calls will be returned to the client for manual handling.
+     * library. If set to {@code false}, tool calls will be returned to the client for manual
-     * <p>
+     * handling.
-     * Disabling this should be an explicit operation.
+     *
+     * <p>Disabling this should be an explicit operation.
      */
     private boolean useTools = true;
 

src/main/java/io/github/ollama4j/models/chat/OllamaChatRequestBuilder.java

@@ -28,9 +28,25 @@ public class OllamaChatRequestBuilder {
 
     private int imageURLConnectTimeoutSeconds = 10;
     private int imageURLReadTimeoutSeconds = 10;
-
+    private OllamaChatRequest request;
     @Setter private boolean useTools = true;
 
+    private OllamaChatRequestBuilder() {
+        request = new OllamaChatRequest();
+        request.setMessages(new ArrayList<>());
+    }
+
+    //    private OllamaChatRequestBuilder(String model, List<OllamaChatMessage> messages) {
+    //        request = new OllamaChatRequest(model, false, messages);
+    //    }
+    //    public static OllamaChatRequestBuilder builder(String model) {
+    //        return new OllamaChatRequestBuilder(model, new ArrayList<>());
+    //    }
+
+    public static OllamaChatRequestBuilder builder() {
+        return new OllamaChatRequestBuilder();
+    }
+
     public OllamaChatRequestBuilder withImageURLConnectTimeoutSeconds(
             int imageURLConnectTimeoutSeconds) {
         this.imageURLConnectTimeoutSeconds = imageURLConnectTimeoutSeconds;
@@ -42,19 +58,9 @@ public class OllamaChatRequestBuilder {
         return this;
     }
 
-    private OllamaChatRequestBuilder(String model, List<OllamaChatMessage> messages) {
+    public OllamaChatRequestBuilder withModel(String model) {
-        request = new OllamaChatRequest(model, false, messages);
+        request.setModel(model);
-    }
+        return this;
-
-    private OllamaChatRequest request;
-
-    public static OllamaChatRequestBuilder getInstance(String model) {
-        return new OllamaChatRequestBuilder(model, new ArrayList<>());
-    }
-
-    public OllamaChatRequest build() {
-        request.setUseTools(useTools);
-        return request;
     }
 
     public void reset() {
@@ -78,7 +84,6 @@ public class OllamaChatRequestBuilder {
             List<OllamaChatToolCalls> toolCalls,
             List<File> images) {
         List<OllamaChatMessage> messages = this.request.getMessages();
-
         List<byte[]> binaryImages =
                 images.stream()
                         .map(
@@ -95,7 +100,6 @@ public class OllamaChatRequestBuilder {
                                     }
                                 })
                         .collect(Collectors.toList());
-
         messages.add(new OllamaChatMessage(role, content, null, toolCalls, binaryImages));
         return this;
     }
@@ -133,13 +137,13 @@ public class OllamaChatRequestBuilder {
                 }
             }
         }
-
         messages.add(new OllamaChatMessage(role, content, null, toolCalls, binaryImages));
         return this;
     }
 
     public OllamaChatRequestBuilder withMessages(List<OllamaChatMessage> messages) {
-        return new OllamaChatRequestBuilder(request.getModel(), messages);
+        request.setMessages(messages);
+        return this;
     }
 
     public OllamaChatRequestBuilder withOptions(Options options) {
@@ -171,4 +175,9 @@ public class OllamaChatRequestBuilder {
         this.request.setThink(think);
         return this;
     }
+
+    public OllamaChatRequest build() {
+        request.setUseTools(useTools);
+        return request;
+    }
 }

src/main/java/io/github/ollama4j/models/generate/OllamaGenerateRequest.java

@@ -24,6 +24,7 @@ public class OllamaGenerateRequest extends OllamaCommonRequest implements Ollama
     private String context;
     private boolean raw;
     private boolean think;
+    private boolean useTools;
 
     public OllamaGenerateRequest() {}
 

src/main/java/io/github/ollama4j/models/generate/OllamaGenerateRequestBuilder.java

@@ -9,21 +9,23 @@
 package io.github.ollama4j.models.generate;
 
 import io.github.ollama4j.utils.Options;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Base64;
 
-/**
+/** Helper class for creating {@link OllamaGenerateRequest} objects using the builder-pattern. */
- * Helper class for creating {@link OllamaGenerateRequest}
- * objects using the builder-pattern.
- */
 public class OllamaGenerateRequestBuilder {
 
-    private OllamaGenerateRequestBuilder(String model, String prompt) {
+    private OllamaGenerateRequestBuilder() {
-        request = new OllamaGenerateRequest(model, prompt);
+        request = new OllamaGenerateRequest();
     }
 
     private OllamaGenerateRequest request;
 
-    public static OllamaGenerateRequestBuilder getInstance(String model) {
+    public static OllamaGenerateRequestBuilder builder() {
-        return new OllamaGenerateRequestBuilder(model, "");
+        return new OllamaGenerateRequestBuilder();
     }
 
     public OllamaGenerateRequest build() {
@@ -35,6 +37,11 @@ public class OllamaGenerateRequestBuilder {
         return this;
     }
 
+    public OllamaGenerateRequestBuilder withModel(String model) {
+        request.setModel(model);
+        return this;
+    }
+
     public OllamaGenerateRequestBuilder withGetJsonResponse() {
         this.request.setFormat("json");
         return this;
@@ -50,8 +57,8 @@ public class OllamaGenerateRequestBuilder {
         return this;
     }
 
-    public OllamaGenerateRequestBuilder withStreaming() {
+    public OllamaGenerateRequestBuilder withStreaming(boolean streaming) {
-        this.request.setStream(true);
+        this.request.setStream(streaming);
         return this;
     }
 
@@ -59,4 +66,49 @@ public class OllamaGenerateRequestBuilder {
         this.request.setKeepAlive(keepAlive);
         return this;
     }
+
+    public OllamaGenerateRequestBuilder withRaw(boolean raw) {
+        this.request.setRaw(raw);
+        return this;
+    }
+
+    public OllamaGenerateRequestBuilder withThink(boolean think) {
+        this.request.setThink(think);
+        return this;
+    }
+
+    public OllamaGenerateRequestBuilder withUseTools(boolean useTools) {
+        this.request.setUseTools(useTools);
+        return this;
+    }
+
+    public OllamaGenerateRequestBuilder withFormat(java.util.Map<String, Object> format) {
+        this.request.setFormat(format);
+        return this;
+    }
+
+    public OllamaGenerateRequestBuilder withSystem(String system) {
+        this.request.setSystem(system);
+        return this;
+    }
+
+    public OllamaGenerateRequestBuilder withContext(String context) {
+        this.request.setContext(context);
+        return this;
+    }
+
+    public OllamaGenerateRequestBuilder withImagesBase64(java.util.List<String> images) {
+        this.request.setImages(images);
+        return this;
+    }
+
+    public OllamaGenerateRequestBuilder withImages(java.util.List<File> imageFiles)
+            throws IOException {
+        java.util.List<String> images = new ArrayList<>();
+        for (File imageFile : imageFiles) {
+            images.add(Base64.getEncoder().encodeToString(Files.readAllBytes(imageFile.toPath())));
+        }
+        this.request.setImages(images);
+        return this;
+    }
 }

src/test/java/io/github/ollama4j/integrationtests/WithAuth.java

@@ -12,14 +12,19 @@ import static org.junit.jupiter.api.Assertions.*;
 
 import io.github.ollama4j.OllamaAPI;
 import io.github.ollama4j.exceptions.OllamaBaseException;
+import io.github.ollama4j.models.generate.OllamaGenerateRequest;
+import io.github.ollama4j.models.generate.OllamaGenerateRequestBuilder;
+import io.github.ollama4j.models.generate.OllamaGenerateStreamObserver;
 import io.github.ollama4j.models.response.OllamaResult;
 import io.github.ollama4j.samples.AnnotatedTool;
 import io.github.ollama4j.tools.annotations.OllamaToolService;
+import io.github.ollama4j.utils.OptionsBuilder;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.time.Duration;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -202,7 +207,19 @@ public class WithAuth {
                 });
         format.put("required", List.of("isNoon"));
 
-        OllamaResult result = api.generateWithFormat(model, prompt, format);
+        OllamaGenerateRequest request =
+                OllamaGenerateRequestBuilder.builder()
+                        .withModel(model)
+                        .withPrompt(prompt)
+                        .withRaw(false)
+                        .withThink(false)
+                        .withStreaming(false)
+                        .withImages(Collections.emptyList())
+                        .withOptions(new OptionsBuilder().build())
+                        .withFormat(format)
+                        .build();
+        OllamaGenerateStreamObserver handler = null;
+        OllamaResult result = api.generate(request, handler);
 
         assertNotNull(result);
         assertNotNull(result.getResponse());

src/test/java/io/github/ollama4j/unittests/TestMockedAPIs.java

@@ -18,6 +18,8 @@ import io.github.ollama4j.exceptions.RoleNotFoundException;
 import io.github.ollama4j.models.chat.OllamaChatMessageRole;
 import io.github.ollama4j.models.embeddings.OllamaEmbedRequestModel;
 import io.github.ollama4j.models.embeddings.OllamaEmbedResponseModel;
+import io.github.ollama4j.models.generate.OllamaGenerateRequest;
+import io.github.ollama4j.models.generate.OllamaGenerateRequestBuilder;
 import io.github.ollama4j.models.generate.OllamaGenerateStreamObserver;
 import io.github.ollama4j.models.request.CustomModelRequest;
 import io.github.ollama4j.models.response.ModelDetail;
@@ -26,6 +28,7 @@ import io.github.ollama4j.models.response.OllamaResult;
 import io.github.ollama4j.tools.Tools;
 import io.github.ollama4j.tools.sampletools.WeatherTool;
 import io.github.ollama4j.utils.OptionsBuilder;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -171,11 +174,18 @@ class TestMockedAPIs {
         OptionsBuilder optionsBuilder = new OptionsBuilder();
         OllamaGenerateStreamObserver observer = new OllamaGenerateStreamObserver(null, null);
         try {
-            when(ollamaAPI.generate(model, prompt, false, false, optionsBuilder.build(), observer))
+            OllamaGenerateRequest request =
+                    OllamaGenerateRequestBuilder.builder()
+                            .withModel(model)
+                            .withPrompt(prompt)
+                            .withRaw(false)
+                            .withThink(false)
+                            .withStreaming(false)
+                            .build();
+            when(ollamaAPI.generate(request, observer))
                     .thenReturn(new OllamaResult("", "", 0, 200));
-            ollamaAPI.generate(model, prompt, false, false, optionsBuilder.build(), observer);
+            ollamaAPI.generate(request, observer);
-            verify(ollamaAPI, times(1))
+            verify(ollamaAPI, times(1)).generate(request, observer);
-                    .generate(model, prompt, false, false, optionsBuilder.build(), observer);
         } catch (OllamaBaseException e) {
             throw new RuntimeException(e);
         }
@@ -187,29 +197,21 @@ class TestMockedAPIs {
         String model = "llama2";
         String prompt = "some prompt text";
         try {
-            when(ollamaAPI.generateWithImages(
+            OllamaGenerateRequest request =
-                            model,
+                    OllamaGenerateRequestBuilder.builder()
-                            prompt,
+                            .withModel(model)
-                            Collections.emptyList(),
+                            .withPrompt(prompt)
-                            new OptionsBuilder().build(),
+                            .withRaw(false)
-                            null,
+                            .withThink(false)
-                            null))
+                            .withStreaming(false)
-                    .thenReturn(new OllamaResult("", "", 0, 200));
+                            .withImages(Collections.emptyList())
-            ollamaAPI.generateWithImages(
+                            .withOptions(new OptionsBuilder().build())
-                    model,
+                            .withFormat(null)
-                    prompt,
+                            .build();
-                    Collections.emptyList(),
+            OllamaGenerateStreamObserver handler = null;
-                    new OptionsBuilder().build(),
+            when(ollamaAPI.generate(request, handler)).thenReturn(new OllamaResult("", "", 0, 200));
-                    null,
+            ollamaAPI.generate(request, handler);
-                    null);
+            verify(ollamaAPI, times(1)).generate(request, handler);
-            verify(ollamaAPI, times(1))
-                    .generateWithImages(
-                            model,
-                            prompt,
-                            Collections.emptyList(),
-                            new OptionsBuilder().build(),
-                            null,
-                            null);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
@@ -221,31 +223,25 @@ class TestMockedAPIs {
         String model = "llama2";
         String prompt = "some prompt text";
         try {
-            when(ollamaAPI.generateWithImages(
+            OllamaGenerateRequest request =
-                            model,
+                    OllamaGenerateRequestBuilder.builder()
-                            prompt,
+                            .withModel(model)
-                            Collections.emptyList(),
+                            .withPrompt(prompt)
-                            new OptionsBuilder().build(),
+                            .withRaw(false)
-                            null,
+                            .withThink(false)
-                            null))
+                            .withStreaming(false)
-                    .thenReturn(new OllamaResult("", "", 0, 200));
+                            .withImages(Collections.emptyList())
-            ollamaAPI.generateWithImages(
+                            .withOptions(new OptionsBuilder().build())
-                    model,
+                            .withFormat(null)
-                    prompt,
+                            .build();
-                    Collections.emptyList(),
+            OllamaGenerateStreamObserver handler = null;
-                    new OptionsBuilder().build(),
+            when(ollamaAPI.generate(request, handler)).thenReturn(new OllamaResult("", "", 0, 200));
-                    null,
+            ollamaAPI.generate(request, handler);
-                    null);
+            verify(ollamaAPI, times(1)).generate(request, handler);
-            verify(ollamaAPI, times(1))
-                    .generateWithImages(
-                            model,
-                            prompt,
-                            Collections.emptyList(),
-                            new OptionsBuilder().build(),
-                            null,
-                            null);
         } catch (OllamaBaseException e) {
             throw new RuntimeException(e);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
         }
     }
 
@@ -254,10 +250,10 @@ class TestMockedAPIs {
         OllamaAPI ollamaAPI = Mockito.mock(OllamaAPI.class);
         String model = "llama2";
         String prompt = "some prompt text";
-        when(ollamaAPI.generate(model, prompt, false, false))
+        when(ollamaAPI.generateAsync(model, prompt, false, false))
                 .thenReturn(new OllamaAsyncResultStreamer(null, null, 3));
-        ollamaAPI.generate(model, prompt, false, false);
+        ollamaAPI.generateAsync(model, prompt, false, false);
-        verify(ollamaAPI, times(1)).generate(model, prompt, false, false);
+        verify(ollamaAPI, times(1)).generateAsync(model, prompt, false, false);
     }
 
     @Test

src/test/java/io/github/ollama4j/unittests/TestOllamaChatRequestBuilder.java

@@ -10,11 +10,9 @@ package io.github.ollama4j.unittests;
 
 import static org.junit.jupiter.api.Assertions.*;
 
-import io.github.ollama4j.models.chat.OllamaChatMessage;
 import io.github.ollama4j.models.chat.OllamaChatMessageRole;
 import io.github.ollama4j.models.chat.OllamaChatRequest;
 import io.github.ollama4j.models.chat.OllamaChatRequestBuilder;
-import java.util.Collections;
 import org.junit.jupiter.api.Test;
 
 class TestOllamaChatRequestBuilder {
@@ -22,7 +20,8 @@ class TestOllamaChatRequestBuilder {
     @Test
     void testResetClearsMessagesButKeepsModelAndThink() {
         OllamaChatRequestBuilder builder =
-                OllamaChatRequestBuilder.getInstance("my-model")
+                OllamaChatRequestBuilder.builder()
+                        .withModel("my-model")
                         .withThinking(true)
                         .withMessage(OllamaChatMessageRole.USER, "first");
 
@@ -39,26 +38,28 @@ class TestOllamaChatRequestBuilder {
         assertEquals(0, afterReset.getMessages().size());
     }
 
-    @Test
+    //    @Test
-    void testImageUrlFailuresThrowExceptionAndBuilderRemainsUsable() {
+    //    void testImageUrlFailuresThrowExceptionAndBuilderRemainsUsable() {
-        OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.getInstance("m");
+    //        OllamaChatRequestBuilder builder = OllamaChatRequestBuilder.builder().withModel("m");
-        String invalidUrl = "ht!tp:/bad_url"; // clearly invalid URL format
+    //        String invalidUrl = "ht!tp:/bad_url"; // clearly invalid URL format
-
+    //
-        // Exception should be thrown for invalid URL
+    //        // Exception should be thrown for invalid URL
-        assertThrows(
+    //        assertThrows(
-                Exception.class,
+    //                Exception.class,
-                () -> {
+    //                () -> {
-                    builder.withMessage(
+    //                    builder.withMessage(
-                            OllamaChatMessageRole.USER, "hi", Collections.emptyList(), invalidUrl);
+    //                            OllamaChatMessageRole.USER, "hi", Collections.emptyList(),
-                });
+    // invalidUrl);
-
+    //                });
-        OllamaChatRequest req =
+    //
-                builder.withMessage(OllamaChatMessageRole.USER, "hello", Collections.emptyList())
+    //        OllamaChatRequest req =
-                        .build();
+    //                builder.withMessage(OllamaChatMessageRole.USER, "hello",
-
+    // Collections.emptyList())
-        assertNotNull(req.getMessages());
+    //                        .build();
-        assert (!req.getMessages().isEmpty());
+    //
-        OllamaChatMessage msg = req.getMessages().get(0);
+    //        assertNotNull(req.getMessages());
-        assertNotNull(msg.getResponse());
+    //        assert (!req.getMessages().isEmpty());
-    }
+    //        OllamaChatMessage msg = req.getMessages().get(0);
+    //        assertNotNull(msg.getResponse());
+    //    }
 }

src/test/java/io/github/ollama4j/unittests/jackson/TestChatRequestSerialization.java

@@ -28,7 +28,7 @@ public class TestChatRequestSerialization extends AbstractSerializationTest<Olla
 
     @BeforeEach
     public void init() {
-        builder = OllamaChatRequestBuilder.getInstance("DummyModel");
+        builder = OllamaChatRequestBuilder.builder().withModel("DummyModel");
     }
 
     @Test

src/test/java/io/github/ollama4j/unittests/jackson/TestGenerateRequestSerialization.java

@@ -23,7 +23,7 @@ class TestGenerateRequestSerialization extends AbstractSerializationTest<OllamaG
 
     @BeforeEach
     public void init() {
-        builder = OllamaGenerateRequestBuilder.getInstance("DummyModel");
+        builder = OllamaGenerateRequestBuilder.builder().withModel("Dummy Model");
     }
 
     @Test