ollama provider (#22)

* feat: enhance agent functionality with ollama

* fix test and tsc error

* feat: add examples for ollama agent and embedding, and enhance openrouter reasoning

Author: wangzuo

bun.lock

@@ -0,0 +1 @@
+/dist

packages/fluent-ai/.gitignore

@@ -0,0 +1,41 @@
+import z from "zod";
+import { agent, agentTool, inspectAgentStream, ollama } from "~/src/index";
+
+const retrieveContext = async (args: { query: string }) => {
+  await Bun.sleep(500); // Simulate latency
+
+  return {
+    context:
+      "The Eiffel Tower is a wrought-iron lattice tower on the Champ de Mars in Paris, France. It is named after the engineer Gustave Eiffel, whose company designed and built the tower from 1887 to 1889.",
+  };
+};
+
+const retrieveContextTool = agentTool("retrieve_context")
+  .description("Retrieve information to help answer a query.")
+  .input(
+    z.object({
+      query: z.string().describe("The query to retrieve context for."),
+    }),
+  )
+  .execute(retrieveContext);
+
+const chatAgent = agent("chat-agent")
+  .model(ollama().chat("qwen3:1.7b"))
+  .tool(retrieveContextTool)
+  .instructions(
+    () => `You have access to a tool that retrieves context.
+Use the tool to help answer user queries.`,
+  );
+
+const stream = chatAgent.generate(
+  [
+    {
+      id: "1",
+      role: "user",
+      text: "Tell me about the Eiffel Tower.",
+    },
+  ],
+  { maxSteps: 8 },
+);
+
+await inspectAgentStream(stream);

packages/fluent-ai/examples/ollama-agent.ts

@@ -5,13 +5,30 @@ const models = await ollama().models().run();
 console.log(models);
 
 const response = await ollama()
-  .chat(models[0].name)
+  .chat(models[0].id)
   .messages([
     {
       role: "user",
-      content: "What is the capital of France?",
+      text: "What is the capital of France?",
     },
   ])
   .run();
 
 console.log(response);
+
+const streamResponse = await ollama()
+  .chat(models[0].id)
+  .messages([
+    {
+      role: "user",
+      text: "What is the capital of Spain?",
+    },
+  ])
+  .stream()
+  .run();
+
+for await (const chunk of streamResponse) {
+  if (chunk.message?.text) {
+    process.stdout.write(chunk.message.text);
+  }
+}

packages/fluent-ai/examples/ollama-chat.ts

@@ -0,0 +1,8 @@
+import { ollama } from "../src";
+
+const result = await ollama()
+  .embedding("embeddinggemma")
+  .input(["Why is the sky blue?", "Why is the grass green?"])
+  .run();
+
+console.log(result.embeddings);

packages/fluent-ai/examples/ollama-embed.ts

@@ -7,8 +7,8 @@ const job: Job = {
   input: {
     model: "google/gemini-2.5-flash",
     messages: [
-      { role: "system", content: "You are a helpful assistant." },
-      { role: "user", content: "Hi" },
+      { role: "system", text: "You are a helpful assistant." },
+      { role: "user", text: "Hi" },
     ],
   },
 };

packages/fluent-ai/examples/openrouter-chat.ts

@@ -0,0 +1,16 @@
+import { openrouter } from "~/src/index";
+
+const stream = await openrouter()
+  .chat("deepseek/deepseek-r1")
+  .messages([
+    {
+      role: "user",
+      text: "How would you build the world's tallest skyscraper?",
+    },
+  ])
+  .stream()
+  .run();
+
+for await (const chunk of stream) {
+  console.log(JSON.stringify(chunk, null, 2));
+}

packages/fluent-ai/examples/openrouter-reasoning.ts

@@ -9,7 +9,8 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
-    }
+    },
+    "./src": "./src/index.ts"
   },
   "files": [
     "src",
@@ -19,10 +20,6 @@
     "build": "bun run build.ts",
     "prepublishOnly": "rm -rf dist && bun run build"
   },
-  "dependencies": {
-    "eventsource-parser": "^3.0.6",
-    "partial-json": "^0.1.7"
-  },
   "keywords": [
     "ai",
     "openai",

packages/fluent-ai/package.json

@@ -1,11 +1,15 @@
 import { z } from "zod";
-import { convertMessagesForChatCompletion } from "~/src/agent/message";
 import {
   agentToolSchema,
   type AgentToolBuilder,
   type AgentTool,
 } from "~/src/agent/tool";
-import type { Message } from "~/src/job/schema";
+import type {
+  Message,
+  ToolMessage,
+  MessageChunk,
+  AssistantMessage,
+} from "~/src/job/schema";
 import type { ChatBuilder } from "~/src/builder/chat";
 
 export const agentSchema = z.object({
@@ -14,7 +18,30 @@ export const agentSchema = z.object({
   tools: z.array(agentToolSchema),
 });
 
-interface GenerateOptions {
+interface ChunkEvent {
+  type: "chunk";
+  chunk: {
+    text?: string;
+    reasoning?: string;
+  };
+}
+
+interface ToolEvent {
+  type: "tool";
+  tool: {
+    name: string;
+    args: any;
+    result?: any;
+    error?: any;
+  };
+}
+
+interface MessageEvent {
+  type: "message";
+  message: Message;
+}
+
+export interface AgentGenerateOptions {
   maxSteps: number;
 }
 
@@ -46,28 +73,27 @@ export class Agent<TContext = any> {
   generate = async function* (
     this: Agent<TContext>,
     initialMessages: Message[],
-    options: GenerateOptions,
+    options: AgentGenerateOptions,
     context?: TContext,
   ) {
     const body = agentSchema.parse(this.body);
 
-    let shouldBreak = false;
+    let shouldFinish = false;
     let newMessages: Message[] = [];
     for (let iteration = 0; iteration < options.maxSteps; iteration++) {
-      if (shouldBreak) {
+      if (shouldFinish) {
         break;
       }
 
       const instructions =
         typeof body.instructions === "function"
-          ? body.instructions()
+          ? body.instructions() // TODO: more context
           : body.instructions;
-      const allMessages = initialMessages.concat(newMessages);
-      const convertedMessages = convertMessagesForChatCompletion(allMessages);
-      const messages = [{ role: "system", content: instructions }].concat(
-        convertedMessages as any,
+      const systemMessage = { role: "system", text: instructions };
+      const messages = ([systemMessage] as Message[]).concat(
+        initialMessages,
+        newMessages,
       );
-      // TODO: agent tool vs chat tool
       const tools = body.tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
@@ -78,82 +104,87 @@ export class Agent<TContext = any> {
         .stream()
         .run();
 
-      let totalText = "";
-      for await (const chunk of result) {
-        const delta = chunk.raw.choices[0].delta;
+      let newAssistantMessage: AssistantMessage = {
+        role: "assistant",
+        text: "",
+        reasoning: "",
+      };
 
-        // TODO: tool calls with content??
-        if (delta.tool_calls) {
-          // TODO: tool call with content
-          // TODO: tool call with input streaming
-          // TODO: support multiple tool calls
-          const toolCall = delta.tool_calls[0];
-          const toolName = toolCall.function.name;
-          const input = JSON.parse(toolCall.function.arguments); // TODO: parsing error handling
+      for await (const chunk of result as AsyncIterable<MessageChunk>) {
+        if (chunk.toolCalls) {
+          // existing assistant message chunked out before tool call
+          if (newAssistantMessage.text || newAssistantMessage.reasoning) {
+            yield {
+              type: "message",
+              message: newAssistantMessage,
+            } as MessageEvent;
+            newMessages.push(newAssistantMessage);
+            newAssistantMessage = {
+              role: "assistant",
+              text: "",
+              reasoning: "",
+            };
+          }
 
-          const agentTool = body.tools.find((t) => t.name === toolName);
+          const toolCall = chunk.toolCalls[0];
+          const { name, arguments: args } = toolCall.function;
+          const agentTool = body.tools.find((t) => t.name === name);
           if (!agentTool) {
-            throw new Error(`Unknown tool: ${toolName}`);
+            throw new Error(`Unknown tool: ${name}`);
           }
 
-          const toolPart = {
-            type: "tool-" + toolName,
-            toolCallId: toolCall.id,
-            input: input,
-          };
-
-          yield { type: "tool-call-input", data: toolPart };
-
-          let output = null;
-          let outputError = null;
+          yield { type: "tool", tool: { name, args } };
 
+          let result = null;
+          let error = null;
           try {
-            output = await agentTool.execute(input, context!);
+            result = await agentTool.execute(args, context!);
           } catch (err) {
-            outputError = (err as Error).message;
+            error = (err as Error).message;
           }
 
-          if (outputError) {
-            yield {
-              type: "tool-call-output",
-              data: { ...toolPart, outputError },
-            };
-          } else {
-            yield { type: "tool-call-output", data: { ...toolPart, output } };
-          }
+          yield {
+            type: "tool",
+            tool: { name, args, result, error },
+          } as ToolEvent;
 
-          const newMessage: Message = {
+          const newMessage: ToolMessage = {
             role: "tool",
-            parts: [
-              {
-                type: `tool-${toolName}`,
-                toolCallId: toolCall.id,
-                input: input,
-                output: output,
-                outputError: outputError,
-              },
-            ],
+            text: "",
+            content: {
+              callId: toolCall.id,
+              name: name,
+              args: args,
+              result: result,
+              error: error,
+            },
           };
 
-          yield { type: "message-created", data: newMessage };
+          yield { type: "message", message: newMessage } as MessageEvent;
           newMessages.push(newMessage);
-        } else if (delta.content) {
-          const text = delta.content as string;
-          yield { type: "text-delta", data: { text } };
-          totalText += text;
-          shouldBreak = true;
+          shouldFinish = false;
+        } else if (chunk.text || chunk.reasoning) {
+          yield {
+            type: "chunk",
+            chunk: {
+              text: chunk.text,
+              reasoning: chunk.reasoning,
+            },
+          } as ChunkEvent;
+
+          if (chunk.text) {
+            newAssistantMessage.text += chunk.text;
+          }
+          if (chunk.reasoning) {
+            newAssistantMessage.reasoning += chunk.reasoning;
+          }
+          shouldFinish = true;
         }
       }
 
-      if (totalText.trim()) {
-        const newMessage: Message = {
-          role: "assistant",
-          parts: [{ type: "text", text: totalText.trim() }],
-        };
-
-        yield { type: "message-created", data: newMessage };
-        newMessages.push(newMessage);
-        shouldBreak = true;
+      if (newAssistantMessage.text || newAssistantMessage.reasoning) {
+        yield { type: "message", message: newAssistantMessage } as MessageEvent;
+        newMessages.push(newAssistantMessage);
       }
     }
   };