ai-sdk-ollama 3.6.0 → 3.7.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 3.7.1
+
+### Patch Changes
+
+- 70def97: Support media/image content in tool result messages. When a tool returns `output.type === 'content'` with `image-data`, `image-url`, or `file-data` (image) parts, the provider now sends them in the tool message's `images` array to Ollama. Fixes #527.
+
+## 3.7.0
+
+### Minor Changes
+
+- 229a396: Use jsonrepair for tool-call argument parsing
+  - **Tool-call JSON repair**: `parseToolArguments` now uses [jsonrepair](https://github.com/josdejong/jsonrepair) when `JSON.parse` fails, so malformed tool-argument strings (trailing commas, unquoted keys, single quotes) are repaired instead of returning `{}`. Same logic is used when converting messages in `convertToOllamaChatMessages`.
+  - **Quoted/double-encoded JSON**: When the model returns a quoted JSON string (e.g. `"{\"query\":\"weather\"}"`), the inner JSON is now parsed so tool arguments are not lost.
+  - **Exports**: `parseToolArguments` and `resolveToolCallingOptions` are now exported from the main and browser entry points for advanced use.
+  - **Example**: New `tool-json-repair-example.ts` in examples/node demonstrates tool-argument repair; `json-repair-example.ts` and README updated to reference it.
+
 ## 3.6.0
 
 ### Minor Changes

package/dist/index.browser.cjs

@@ -28,6 +28,8 @@ __export(index_browser_exports, {
   createOllama: () => createOllama,
   generateText: () => generateText,
   ollama: () => ollama,
+  parseToolArguments: () => parseToolArguments,
+  resolveToolCallingOptions: () => resolveToolCallingOptions,
   streamText: () => streamText
 });
 module.exports = __toCommonJS(index_browser_exports);
@@ -36,187 +38,8 @@ module.exports = __toCommonJS(index_browser_exports);
 var import_provider = require("@ai-sdk/provider");
 var import_browser = require("ollama/browser");
 
-// src/utils/convert-to-ollama-messages.ts
-function convertToOllamaChatMessages(prompt) {
-  const messages = [];
-  for (const message of prompt) {
-    switch (message.role) {
-      case "system": {
-        messages.push({
-          role: "system",
-          content: message.content
-        });
-        break;
-      }
-      case "user": {
-        if (typeof message.content === "string") {
-          messages.push({
-            role: "user",
-            content: message.content
-          });
-        } else {
-          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-          const imageParts = message.content.filter(
-            (part) => part.type === "file"
-          ).filter((part) => {
-            return part.mediaType?.startsWith("image/") || false;
-          }).map((part) => {
-            const imageData = part.data;
-            if (imageData instanceof URL) {
-              if (imageData.protocol === "data:") {
-                const base64Match = imageData.href.match(
-                  /data:[^;]+;base64,(.+)/
-                );
-                if (base64Match) {
-                  return base64Match[1];
-                }
-                return imageData.href;
-              }
-              return imageData.href;
-            } else if (typeof imageData === "string") {
-              if (imageData.startsWith("data:")) {
-                const base64Match = imageData.match(/data:[^;]+;base64,(.+)/);
-                if (base64Match) {
-                  return base64Match[1];
-                }
-              }
-              return imageData;
-            } else if (imageData instanceof Uint8Array) {
-              return Buffer.from(imageData).toString("base64");
-            } else {
-              console.warn(
-                `Unsupported image data type: ${typeof imageData}`
-              );
-              return null;
-            }
-          }).filter((img) => img !== null);
-          messages.push({
-            role: "user",
-            content: textParts || "",
-            // Ensure content is never undefined
-            images: imageParts.length > 0 ? imageParts : void 0
-          });
-        }
-        break;
-      }
-      case "assistant": {
-        let content;
-        const toolCalls = [];
-        if (typeof message.content === "string") {
-          content = message.content;
-        } else {
-          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-          const reasoningParts = message.content.filter((part) => part.type === "reasoning").map((part) => part.text).join("\n");
-          content = [textParts, reasoningParts].filter(Boolean).join("\n");
-          for (const part of message.content) {
-            if (part.type === "tool-call") {
-              let args;
-              try {
-                args = typeof part.input === "string" ? JSON.parse(part.input) : part.input;
-              } catch (error48) {
-                console.warn("Failed to parse tool call input:", error48);
-                args = {};
-              }
-              toolCalls.push({
-                id: part.toolCallId,
-                type: "function",
-                function: {
-                  name: part.toolName,
-                  arguments: args
-                }
-              });
-            }
-          }
-        }
-        messages.push({
-          role: "assistant",
-          content: content || "",
-          // Ensure content is never undefined
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
-        });
-        break;
-      }
-      case "tool": {
-        if (typeof message.content === "string") {
-          messages.push({
-            role: "tool",
-            content: message.content
-          });
-        } else {
-          for (const part of message.content) {
-            if (part.type === "tool-result") {
-              const contentValue = part.output.type === "text" || part.output.type === "error-text" ? part.output.value : part.output.type === "json" || part.output.type === "error-json" ? JSON.stringify(part.output.value) : JSON.stringify(part.output);
-              messages.push({
-                role: "tool",
-                content: contentValue,
-                tool_name: part.toolName
-              });
-            }
-          }
-        }
-        break;
-      }
-      default: {
-        const role = message.role;
-        throw new Error(
-          `Unsupported message role: ${role}. Supported roles are: system, user, assistant, tool`
-        );
-      }
-    }
-  }
-  return messages;
-}
-
-// src/utils/map-ollama-finish-reason.ts
-function mapOllamaFinishReason(reason) {
-  if (!reason) {
-    return {
-      unified: "stop",
-      raw: void 0
-    };
-  }
-  switch (reason) {
-    case "stop": {
-      return {
-        unified: "stop",
-        raw: reason
-      };
-    }
-    case "length": {
-      return {
-        unified: "length",
-        raw: reason
-      };
-    }
-    default: {
-      return {
-        unified: "other",
-        raw: reason
-      };
-    }
-  }
-}
-
-// src/utils/ollama-error.ts
-var OllamaError = class _OllamaError extends Error {
-  constructor({
-    message,
-    cause,
-    data
-  }) {
-    super(message);
-    __publicField(this, "cause");
-    __publicField(this, "data");
-    this.name = "OllamaError";
-    this.cause = cause;
-    this.data = data;
-  }
-  static isOllamaError(error48) {
-    return error48 instanceof _OllamaError;
-  }
-};
-
 // src/utils/tool-calling-reliability.ts
+var import_jsonrepair = require("jsonrepair");
 var DEFAULT_TOOL_CALLING_OPTIONS = {
   maxRetries: 2,
   forceCompletion: true,
@@ -242,10 +65,29 @@ function parseToolArguments(input) {
   if (typeof input === "string") {
     try {
       const parsed = JSON.parse(input);
+      if (typeof parsed === "string") {
+        try {
+          const inner = JSON.parse(parsed);
+          return ensureRecord(inner);
+        } catch {
+          try {
+            const repaired = (0, import_jsonrepair.jsonrepair)(parsed);
+            return ensureRecord(JSON.parse(repaired));
+          } catch {
+            return {};
+          }
+        }
+      }
       return ensureRecord(parsed);
-    } catch (error48) {
-      console.warn("Failed to parse tool arguments as JSON:", error48);
-      return {};
+    } catch {
+      try {
+        const repaired = (0, import_jsonrepair.jsonrepair)(input);
+        const parsed = JSON.parse(repaired);
+        return ensureRecord(parsed);
+      } catch (error48) {
+        console.warn("Failed to parse tool arguments as JSON:", error48);
+        return {};
+      }
     }
   }
   return ensureRecord(input);
@@ -404,13 +246,10 @@ function normalizeToolParameters(input, mappings = DEFAULT_PARAMETER_MAPPINGS) {
   }
   return normalized;
 }
-async function validateToolResult(toolName, input, result, executeFunction, options = {}) {
+async function validateToolResult(_toolName, input, result, executeFunction, options = {}) {
   const { normalizeParameters = true, parameterMappings } = options;
   const normalizedInput = normalizeParameters ? normalizeToolParameters(input, parameterMappings) : input;
   if (!result || typeof result === "object" && Object.keys(result).length === 0) {
-    console.warn(
-      `\u26A0\uFE0F Tool ${toolName} returned empty result, attempting recovery...`
-    );
     try {
       const recoveredResult = await executeFunction(normalizedInput);
       if (recoveredResult && (typeof recoveredResult !== "object" || Object.keys(recoveredResult).length > 0)) {
@@ -535,9 +374,209 @@ ${finalInstruction}`;
   return textContent?.text || "";
 }
 
+// src/utils/convert-to-ollama-messages.ts
+function normalizeImageDataForOllama(imageData) {
+  if (imageData instanceof URL) {
+    if (imageData.protocol === "data:") {
+      const base64Match = imageData.href.match(/data:[^;]+;base64,(.+)/);
+      const extracted = base64Match?.[1];
+      if (typeof extracted === "string") return extracted;
+      return imageData.href;
+    }
+    return imageData.href;
+  }
+  if (typeof imageData === "string") {
+    if (imageData.startsWith("data:")) {
+      const base64Match = imageData.match(/data:[^;]+;base64,(.+)/);
+      const extracted = base64Match?.[1];
+      if (typeof extracted === "string") return extracted;
+    }
+    return imageData;
+  }
+  if (imageData instanceof Uint8Array) {
+    return Buffer.from(imageData).toString("base64");
+  }
+  return null;
+}
+function convertToOllamaChatMessages(prompt) {
+  const messages = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: message.content
+        });
+        break;
+      }
+      case "user": {
+        if (typeof message.content === "string") {
+          messages.push({
+            role: "user",
+            content: message.content
+          });
+        } else {
+          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+          const imageParts = message.content.filter(
+            (part) => part.type === "file"
+          ).filter((part) => part.mediaType?.startsWith("image/") ?? false).map((part) => normalizeImageDataForOllama(part.data)).filter((img) => img !== null);
+          messages.push({
+            role: "user",
+            content: textParts || "",
+            // Ensure content is never undefined
+            images: imageParts.length > 0 ? imageParts : void 0
+          });
+        }
+        break;
+      }
+      case "assistant": {
+        let content;
+        const toolCalls = [];
+        if (typeof message.content === "string") {
+          content = message.content;
+        } else {
+          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+          const reasoningParts = message.content.filter((part) => part.type === "reasoning").map((part) => part.text).join("\n");
+          content = [textParts, reasoningParts].filter(Boolean).join("\n");
+          for (const part of message.content) {
+            if (part.type === "tool-call") {
+              const args = parseToolArguments(part.input);
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: args
+                }
+              });
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: content || "",
+          // Ensure content is never undefined
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "tool": {
+        if (typeof message.content === "string") {
+          messages.push({
+            role: "tool",
+            content: message.content
+          });
+        } else {
+          for (const part of message.content) {
+            if (part.type !== "tool-result") continue;
+            if (part.output.type === "content") {
+              const textParts = [];
+              const imageParts = [];
+              for (const item of part.output.value) {
+                switch (item.type) {
+                  case "text": {
+                    textParts.push(item.text);
+                    break;
+                  }
+                  case "image-data": {
+                    const normalized = normalizeImageDataForOllama(item.data);
+                    if (normalized) imageParts.push(normalized);
+                    break;
+                  }
+                  case "image-url": {
+                    imageParts.push(item.url);
+                    break;
+                  }
+                  case "file-data": {
+                    if (item.mediaType?.startsWith("image/")) {
+                      const normalized = normalizeImageDataForOllama(item.data);
+                      if (normalized) imageParts.push(normalized);
+                    }
+                    break;
+                  }
+                }
+              }
+              messages.push({
+                role: "tool",
+                content: textParts.join("\n") || "",
+                tool_name: part.toolName,
+                images: imageParts.length > 0 ? imageParts : void 0
+              });
+              continue;
+            }
+            const contentValue = part.output.type === "text" || part.output.type === "error-text" ? part.output.value : part.output.type === "json" || part.output.type === "error-json" ? JSON.stringify(part.output.value) : part.output.type === "execution-denied" ? "" : JSON.stringify(part.output);
+            messages.push({
+              role: "tool",
+              content: contentValue,
+              tool_name: part.toolName
+            });
+          }
+        }
+        break;
+      }
+      default: {
+        const role = message.role;
+        throw new Error(
+          `Unsupported message role: ${role}. Supported roles are: system, user, assistant, tool`
+        );
+      }
+    }
+  }
+  return messages;
+}
+
+// src/utils/map-ollama-finish-reason.ts
+function mapOllamaFinishReason(reason) {
+  if (!reason) {
+    return {
+      unified: "stop",
+      raw: void 0
+    };
+  }
+  switch (reason) {
+    case "stop": {
+      return {
+        unified: "stop",
+        raw: reason
+      };
+    }
+    case "length": {
+      return {
+        unified: "length",
+        raw: reason
+      };
+    }
+    default: {
+      return {
+        unified: "other",
+        raw: reason
+      };
+    }
+  }
+}
+
+// src/utils/ollama-error.ts
+var OllamaError = class _OllamaError extends Error {
+  constructor({
+    message,
+    cause,
+    data
+  }) {
+    super(message);
+    __publicField(this, "cause");
+    __publicField(this, "data");
+    this.name = "OllamaError";
+    this.cause = cause;
+    this.data = data;
+  }
+  static isOllamaError(error48) {
+    return error48 instanceof _OllamaError;
+  }
+};
+
 // src/utils/object-generation-reliability.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_jsonrepair = require("jsonrepair");
+var import_jsonrepair2 = require("jsonrepair");
 function isZodSchema(schema) {
   return typeof schema === "object" && schema !== null && "parse" in schema && typeof schema.parse === "function";
 }
@@ -1150,7 +1189,7 @@ async function enhancedRepairText(options) {
 async function cascadeRepairText(options) {
   const { text } = options;
   try {
-    const repairedText = (0, import_jsonrepair.jsonrepair)(text);
+    const repairedText = (0, import_jsonrepair2.jsonrepair)(text);
     JSON.parse(repairedText);
     return repairedText;
   } catch {