opencode-ollama-toolcall-proxy 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# OpenCode Ollama Tool-Call Proxy Plugin
+
+An [OpenCode](https://opencode.ai) plugin that intercepts chat-completion responses from a local [Ollama](https://ollama.com) server and rewrites raw tool-call markup into standard OpenAI `tool_calls` chunks. This lets models that do not expose native Ollama tool support still work as agentic coding models inside OpenCode.
+
+## Supported model families
+
+| Family | Example Ollama tags | Raw markup handled |
+|--------|---------------------|--------------------|
+| Qwen 2.5 / Qwen 2.5-Coder | `qwen2.5-coder`, `qwen2.5` | `<tools>`, `<tool_call>`, raw JSON |
+| Qwen 3.5 / Qwen 3-Coder | `qwen3.5`, `qwen3-coder` | `<tool_call><function=...>` XML |
+| Gemma 4 | `gemma4` | `<|tool_call>call:...{}<tool_call|>` |
+| Mistral / Ministral | `mistral`, `mistral-nemo`, `ministral` | `[TOOL_CALLS] JSON` and `<name>[ARGS]{}` |
+| Llama 3.x / OpenCoder | `llama3.1`, `llama3.2`, `llama3.3`, `opencoder` | raw JSON, `<|python_tag|>` |
+| Phi-4 / Phi-4 Tools | `phi4-mini`, `phi4-tools` | `{"name":..., "parameters":...}`, `functools[...]` |
+| DeepSeek R1 / V3 | `deepseek-r1`, `deepseek-v3` | native tags, fenced JSON, raw JSON, strips `<think>` |
+| Yi-Coder | `yi-coder` | raw JSON / JSON array, code fences |
+| GLM-4 / ChatGLM | `glm4`, `chatglm3` | `[TOOL_REQUEST] ... [END_TOOL_REQUEST]`, legacy XML |
+
+## Installation
+
+### From npm (recommended)
+
+```bash
+npm install -g opencode-ollama-toolcall-proxy
+```
+
+Then add the package name to your OpenCode config:
+
+```json
+{
+  "plugin": ["opencode-ollama-toolcall-proxy"]
+}
+```
+
+Restart OpenCode. The plugin is loaded automatically.
+
+### From a local checkout
+
+```bash
+git clone https://github.com/YOUR_USER/opencode-ollama-toolcall-proxy.git
+npm install
+npm run build
+```
+
+Reference the built entry point with an absolute `file://` URL:
+
+```json
+{
+  "plugin": ["file:///C:/absolute/path/to/opencode-ollama-toolcall-proxy/dist/index.js"]
+}
+```
+
+## Usage
+
+1. Make sure Ollama is running.
+2. Configure your model in `~/.config/opencode/opencode.json` with `"tools": true`:
+
+```json
+{
+  "provider": {
+    "ollama": {
+      "npm": "@ai-sdk/openai-compatible",
+      "options": { "baseURL": "http://localhost:11434/v1" },
+      "models": {
+        "qwen2.5-coder:14b": {
+          "name": "Qwen2.5 Coder 14B",
+          "tools": true,
+          "thinking": false
+        }
+      }
+    }
+  }
+}
+```
+
+3. Start OpenCode. When the model emits raw tool-call text, the plugin converts it to proper `tool_calls` before the AI SDK sees the response.
+
+## Development
+
+```bash
+# type check
+npm run typecheck
+
+# run tests
+npm test
+
+# build a single ESM bundle for publishing
+npm run build
+```
+
+## Publishing
+
+1. Pick a unique npm package name and update `name` in `package.json`.
+2. Log in to npm: `npm login`.
+3. Publish: `npm publish`.
+
+The `prepublishOnly` script automatically builds `dist/index.js` before the package is uploaded.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,1077 @@
+// converters.ts
+function makeId(seed) {
+  let hash = 0;
+  for (let i = 0; i < seed.length; i++) {
+    const char = seed.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return String(Math.abs(hash) % 1e9);
+}
+function buildToolCall(name, args, index) {
+  const argsStr = typeof args === "string" ? args : JSON.stringify(args ?? {});
+  return {
+    id: makeId(`${name}_${index}_${argsStr}`),
+    type: "function",
+    function: { name, arguments: argsStr }
+  };
+}
+var qwen25 = {
+  name: "qwen25",
+  hasPartial(content) {
+    if (!content) return false;
+    const markers = [
+      "<tools>",
+      "</tools>",
+      "<tool_call>",
+      "</tool_call>"
+    ];
+    if (markers.some((m) => content.includes(m))) return true;
+    const stripped = content.trim();
+    return stripped.startsWith("{") && stripped.includes('"name"') && stripped.includes('"arguments"');
+  },
+  isComplete(content) {
+    if (!content) return false;
+    if (/<tools>.*?<\/tools>/s.test(content)) return true;
+    if (/<tool_call>.*?<\/tool_call>/s.test(content)) return true;
+    const stripped = content.trim();
+    return stripped.startsWith("{") && stripped.endsWith("}");
+  },
+  parse(content) {
+    const out = [];
+    for (const block of matchAll(content, /<tools>(.*?)<\/tools>/gs)) {
+      out.push(...parseJsonBlock(block));
+    }
+    const toolCallBlocks = matchAll(
+      content,
+      /<tool_call>(.*?)<\/tool_call>/gs
+    );
+    for (const block of toolCallBlocks) {
+      out.push(...parseJsonBlock(block));
+    }
+    if (out.length === 0 && toolCallBlocks.length === 0) {
+      const stripped = content.trim();
+      if (stripped.startsWith("{") && stripped.endsWith("}")) {
+        out.push(...parseJsonBlock(stripped));
+      }
+    }
+    return out;
+  },
+  clean(content) {
+    let c = content;
+    c = c.replace(/<tools>.*?<\/tools>/gs, "");
+    c = c.replace(/<tool_calls>.*?<\/tool_calls>/gs, "");
+    c = c.replace(/<tool_call>.*?<\/tool_call>/gs, "");
+    const stripped = c.trim();
+    if (stripped.startsWith("{") && stripped.endsWith("}")) {
+      try {
+        const parsed = JSON.parse(stripped);
+        if (parsed.name && parsed.arguments) c = "";
+      } catch {
+      }
+    }
+    return c.trim();
+  }
+};
+function parseJsonBlock(block) {
+  const out = [];
+  const b = block.trim();
+  if (!b) return out;
+  if (b.startsWith("[") && b.endsWith("]")) {
+    try {
+      const arr = JSON.parse(b);
+      for (let i = 0; i < arr.length; i++) {
+        const tc = objectToToolCall(arr[i], i);
+        if (tc) out.push(tc);
+      }
+      return out;
+    } catch {
+    }
+  }
+  if (b.startsWith("{") && b.endsWith("}")) {
+    try {
+      const obj = JSON.parse(b);
+      const tc = objectToToolCall(obj, 0);
+      if (tc) out.push(tc);
+      return out;
+    } catch {
+    }
+  }
+  for (const line of b.split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const obj = JSON.parse(t);
+      const tc = objectToToolCall(obj, out.length);
+      if (tc) out.push(tc);
+    } catch {
+    }
+  }
+  return out;
+}
+function objectToToolCall(obj, index) {
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  if (!o.name) return null;
+  let args = o.arguments ?? o.parameters ?? {};
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+    }
+  }
+  return buildToolCall(String(o.name), args, index);
+}
+var qwen35 = {
+  name: "qwen35",
+  hasPartial(content) {
+    if (!content) return false;
+    const markers = [
+      "<tool_call>",
+      "</tool_call>",
+      "<function=",
+      "</function>",
+      "<parameter=",
+      "</parameter>",
+      "</function_invocation>"
+    ];
+    return markers.some((m) => content.includes(m));
+  },
+  isComplete(content) {
+    if (!content) return false;
+    if (/<tool_call>\s*\{.*?\}\s*<\/tool_call>/s.test(content)) return true;
+    if (/<function=[^>]+>.*?<\/function>/s.test(content)) return true;
+    return false;
+  },
+  parse(content) {
+    const out = [];
+    let remainder = content;
+    for (const [wrapper] of content.matchAll(/<tool_call>(.*?)<\/tool_call>/gs)) {
+      remainder = remainder.replace(wrapper, "");
+      const innerMatch = wrapper.match(/<tool_call>(.*?)<\/tool_call>/s);
+      if (!innerMatch) continue;
+      const inner = innerMatch[1].trim();
+      if (inner.startsWith("{") && inner.endsWith("}")) {
+        try {
+          const obj = JSON.parse(inner);
+          const tc = objectToToolCall(obj, out.length);
+          if (tc) {
+            out.push(tc);
+            continue;
+          }
+        } catch {
+        }
+      }
+      out.push(...parseFunctionBlocks(inner, out.length));
+    }
+    out.push(...parseFunctionBlocks(remainder, out.length));
+    return out;
+  },
+  clean(content) {
+    let c = content;
+    c = c.replace(/<tool_call>.*?<\/tool_call>/gs, "");
+    c = c.replace(/<function=[^>]+>.*?<\/function>/gs, "");
+    c = c.replace(/<think>.*?<\/think>/gs, "");
+    c = c.replace(/<\/function_invocation>/g, "");
+    c = c.replace(/<\/function>/g, "");
+    return c.trim();
+  }
+};
+function parseFunctionBlocks(text, baseIndex) {
+  const out = [];
+  for (const match of text.matchAll(/<function=([^>\s]+)>(.*?)<\/function>/gs)) {
+    const name = match[1].trim();
+    const body = match[2];
+    const args = parseParameterPairs(body);
+    out.push(buildToolCall(name, args, baseIndex + out.length));
+  }
+  return out;
+}
+function parseParameterPairs(body) {
+  const args = {};
+  for (const match of body.matchAll(/<parameter=([^>\s]+)>(.*?)<\/parameter>/gs)) {
+    const key = match[1].trim();
+    let value = match[2].trim();
+    try {
+      value = JSON.parse(value);
+    } catch {
+    }
+    args[key] = value;
+  }
+  return args;
+}
+var STRING_SENTINEL = `<|"|>`;
+var ESCAPE_TAG = "<escape>";
+var gemma4 = {
+  name: "gemma4",
+  hasPartial(content) {
+    if (!content) return false;
+    const markers = [
+      "<|tool_call>",
+      "<tool_call|>",
+      "<|channel>",
+      "<channel|>",
+      "<start_function_call>",
+      "<end_function_call>",
+      "call:"
+    ];
+    return markers.some((m) => content.includes(m));
+  },
+  isComplete(content) {
+    if (!content) return false;
+    if (/<\|tool_call>\s*call:[^<]+?\{.*?\}\s*<tool_call\|>/s.test(content))
+      return true;
+    if (/<start_function_call>\s*call:[^<]+?\{.*?\}\s*<end_function_call>/s.test(
+      content
+    ))
+      return true;
+    return false;
+  },
+  parse(content) {
+    const out = [];
+    for (const match of content.matchAll(
+      /<\|tool_call>(.*?)<tool_call\|>/gs
+    )) {
+      const tc = parseCallBlock(match[1].trim(), out.length);
+      if (tc) out.push(tc);
+    }
+    for (const match of content.matchAll(
+      /<start_function_call>(.*?)<end_function_call>/gs
+    )) {
+      const tc = parseCallBlock(match[1].trim(), out.length);
+      if (tc) out.push(tc);
+    }
+    return out;
+  },
+  clean(content) {
+    let c = content;
+    c = c.replace(/<\|tool_call>.*?<tool_call\|>/gs, "");
+    c = c.replace(/<\|channel>thought\s*.*?<channel\|>/gs, "");
+    c = c.replace(/<start_function_call>.*?<end_function_call>/gs, "");
+    return c.trim();
+  }
+};
+function parseCallBlock(block, index) {
+  if (!block.startsWith("call:")) return null;
+  const afterCall = block.slice(5);
+  let delimPos = -1;
+  let openDelim = null;
+  for (let i = 0; i < afterCall.length; i++) {
+    const ch = afterCall[i];
+    if (ch === "{" || ch === "(") {
+      delimPos = i;
+      openDelim = ch;
+      break;
+    }
+  }
+  if (delimPos === -1 || !openDelim) return null;
+  const name = afterCall.slice(0, delimPos).trim();
+  const closeDelim = openDelim === "{" ? "}" : ")";
+  const argsStr = extractBalanced(
+    afterCall,
+    delimPos,
+    openDelim,
+    closeDelim
+  );
+  if (argsStr === null) return null;
+  const args = parseArgPairs(argsStr);
+  return buildToolCall(name, args, index);
+}
+function extractBalanced(text, start, openCh, closeCh) {
+  if (text[start] !== openCh) return null;
+  let depth = 0;
+  let inString = false;
+  let i = start;
+  const sentinels = [STRING_SENTINEL, ESCAPE_TAG];
+  while (i < text.length) {
+    let matched = null;
+    for (const s of sentinels) {
+      if (text.startsWith(s, i)) {
+        matched = s;
+        break;
+      }
+    }
+    if (matched) {
+      inString = !inString;
+      i += matched.length;
+      continue;
+    }
+    if (!inString) {
+      if (text[i] === openCh) depth++;
+      else if (text[i] === closeCh) {
+        depth--;
+        if (depth === 0) return text.slice(start + 1, i);
+      }
+    }
+    i++;
+  }
+  return null;
+}
+function parseArgPairs(argsStr) {
+  const args = {};
+  let i = 0;
+  while (i < argsStr.length) {
+    while (i < argsStr.length && /\s/.test(argsStr[i])) i++;
+    if (i >= argsStr.length) break;
+    const keyStart = i;
+    while (i < argsStr.length && argsStr[i] !== ":") i++;
+    if (i >= argsStr.length) break;
+    const key = argsStr.slice(keyStart, i).trim();
+    i++;
+    const [value, next] = parseValue(argsStr, i);
+    args[key] = value;
+    i = next;
+    while (i < argsStr.length && /\s/.test(argsStr[i])) i++;
+    if (i < argsStr.length && argsStr[i] === ",") i++;
+  }
+  return args;
+}
+function parseValue(s, i) {
+  const n = s.length;
+  while (i < n && /\s/.test(s[i])) i++;
+  if (i >= n) return [null, i];
+  if (s.startsWith(STRING_SENTINEL, i)) {
+    i += STRING_SENTINEL.length;
+    const end = s.indexOf(STRING_SENTINEL, i);
+    if (end === -1) return [s.slice(i), n];
+    return [s.slice(i, end), end + STRING_SENTINEL.length];
+  }
+  if (s.startsWith(ESCAPE_TAG, i)) {
+    i += ESCAPE_TAG.length;
+    const end = s.indexOf(ESCAPE_TAG, i);
+    if (end === -1) return [s.slice(i), n];
+    return [s.slice(i, end), end + ESCAPE_TAG.length];
+  }
+  if (s[i] === "[") return parseList(s, i);
+  const start = i;
+  while (i < n && s[i] !== ",") i++;
+  const raw = s.slice(start, i).trim();
+  return [parseLiteral(raw), i];
+}
+function parseList(s, i) {
+  const n = s.length;
+  if (i >= n || s[i] !== "[") return [[], i];
+  i++;
+  const items = [];
+  while (i < n) {
+    while (i < n && /\s/.test(s[i])) i++;
+    if (i < n && s[i] === "]") {
+      i++;
+      break;
+    }
+    const [value, next] = parseValue(s, i);
+    items.push(value);
+    i = next;
+    while (i < n && /\s/.test(s[i])) i++;
+    if (i < n && s[i] === ",") i++;
+    else if (i < n && s[i] === "]") {
+      i++;
+      break;
+    }
+  }
+  return [items, i];
+}
+function parseLiteral(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "true") return true;
+  if (lower === "false") return false;
+  if (lower === "null" || lower === "none") return null;
+  if (/^-?\d+$/.test(raw)) return parseInt(raw, 10);
+  if (/^-?\d+\.\d+$/.test(raw)) return parseFloat(raw);
+  return raw;
+}
+var mistral = {
+  name: "mistral",
+  hasPartial(content) {
+    if (!content) return false;
+    const stripped = content.trim();
+    if (stripped.startsWith("[TOOL_CALLS]")) return true;
+    if (stripped.startsWith("[") && stripped.includes('"name"')) return true;
+    return false;
+  },
+  isComplete(content) {
+    if (!content) return false;
+    const stripped = content.trim();
+    if (stripped.startsWith("[TOOL_CALLS]")) {
+      const after = stripped.slice("[TOOL_CALLS]".length).trim();
+      if (!after) return false;
+      if (after.startsWith("[")) {
+        return canParseJson(after);
+      }
+      return /<[A-Za-z_][A-Za-z0-9_]*>\[ARGS\]\{.*\}/s.test(after);
+    }
+    if (stripped.startsWith("[")) {
+      return canParseJson(stripped);
+    }
+    return false;
+  },
+  parse(content) {
+    const out = [];
+    let text = content.trim();
+    if (text.startsWith("[TOOL_CALLS]")) {
+      text = text.slice("[TOOL_CALLS]".length).trim();
+    }
+    if (!text) return out;
+    if (text.startsWith("[")) {
+      try {
+        const arr = JSON.parse(text);
+        for (let i = 0; i < arr.length; i++) {
+          const tc = objectToToolCall(arr[i], out.length);
+          if (tc) out.push(tc);
+        }
+        return out;
+      } catch {
+      }
+    }
+    const regex = /<([A-Za-z_][A-Za-z0-9_]*)>\[ARGS\]\{/gs;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+      const name = match[1];
+      const argsStart = match.index + match[0].length - 1;
+      const argsBody = extractBalancedBraces(text, argsStart);
+      if (argsBody === null) continue;
+      let args;
+      try {
+        args = JSON.parse(`{${argsBody}}`);
+      } catch {
+        args = argsBody;
+      }
+      out.push(buildToolCall(name, args, out.length));
+    }
+    return out;
+  },
+  clean(content) {
+    if (this.hasPartial(content) && this.parse(content).length > 0) {
+      return "";
+    }
+    return content;
+  }
+};
+function extractBalancedBraces(text, openPos) {
+  if (text[openPos] !== "{") return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = openPos; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(openPos + 1, i);
+      }
+    }
+  }
+  return null;
+}
+function canParseJson(text) {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var llama = {
+  name: "llama",
+  hasPartial(content) {
+    if (!content) return false;
+    const stripped = content.trim();
+    if (stripped.startsWith("<|python_tag|>")) return true;
+    if (stripped.startsWith("[") && stripped.includes('"name"')) return true;
+    if (stripped.startsWith("{") && stripped.includes('"name"') && stripped.includes('"arguments"')) {
+      return true;
+    }
+    return false;
+  },
+  isComplete(content) {
+    if (!content) return false;
+    const stripped = content.trim();
+    if (stripped.startsWith("<|python_tag|>")) {
+      let inner = stripped.slice("<|python_tag|>".length);
+      inner = inner.replace(/<\|eom_id\|>/g, "").trim();
+      return canParseJson(inner);
+    }
+    if (stripped.startsWith("[") || stripped.startsWith("{")) {
+      return canParseJson(stripped);
+    }
+    return false;
+  },
+  parse(content) {
+    let text = content.trim();
+    if (text.startsWith("<|python_tag|>")) {
+      text = text.slice("<|python_tag|>".length);
+    }
+    text = text.replace(/<\|eom_id\|>/g, "").trim();
+    const out = [];
+    try {
+      const parsed = JSON.parse(text);
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (let i = 0; i < items.length; i++) {
+        const tc = objectToToolCall(items[i], out.length);
+        if (tc) out.push(tc);
+      }
+    } catch {
+    }
+    return out;
+  },
+  clean(content) {
+    if (this.hasPartial(content) && this.parse(content).length > 0) {
+      return "";
+    }
+    return content;
+  }
+};
+var phi4 = {
+  name: "phi4",
+  hasPartial(content) {
+    if (!content) return false;
+    const stripped = content.trim();
+    if (stripped.startsWith("functools[")) return true;
+    if (stripped.startsWith("[") && stripped.includes('"name"')) return true;
+    if (stripped.startsWith("{") && stripped.includes('"name"') && (stripped.includes('"parameters"') || stripped.includes('"arguments"'))) {
+      return true;
+    }
+    return false;
+  },
+  isComplete(content) {
+    if (!content) return false;
+    const stripped = content.trim();
+    if (stripped.startsWith("functools[")) {
+      const inner = `[${stripped.slice("functools[".length)}`;
+      return canParseJson(inner);
+    }
+    if (stripped.startsWith("[") || stripped.startsWith("{")) {
+      return canParseJson(stripped);
+    }
+    return false;
+  },
+  parse(content) {
+    let text = content.trim();
+    if (text.startsWith("functools[")) {
+      text = `[${text.slice("functools[".length)}`;
+    }
+    const out = [];
+    try {
+      const parsed = JSON.parse(text);
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (let i = 0; i < items.length; i++) {
+        const tc = objectToToolCallPhi4(items[i], out.length);
+        if (tc) out.push(tc);
+      }
+    } catch {
+    }
+    return out;
+  },
+  clean(content) {
+    if (this.hasPartial(content) && this.parse(content).length > 0) {
+      return "";
+    }
+    return content;
+  }
+};
+function objectToToolCallPhi4(obj, index) {
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  if (!o.name) return null;
+  let args = o.arguments ?? o.parameters ?? {};
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+    }
+  }
+  return buildToolCall(String(o.name), args, index);
+}
+var DEEPSEEK_TAG_SEP = "[_\u2581]";
+var deepseek = {
+  name: "deepseek",
+  hasPartial(content) {
+    if (!content) return false;
+    const stripped = stripThinkBlocks(content).trim();
+    if (/<｜tool/.test(stripped)) return true;
+    if (stripped.startsWith("[") && stripped.includes('"name"')) return true;
+    if (stripped.startsWith("{") && stripped.includes('"name"') && (stripped.includes('"parameters"') || stripped.includes('"arguments"'))) {
+      return true;
+    }
+    return false;
+  },
+  isComplete(content) {
+    if (!content) return false;
+    const stripped = stripThinkBlocks(content).trim();
+    const tagPairRegex = new RegExp(
+      `<\uFF5Ctool${DEEPSEEK_TAG_SEP}call${DEEPSEEK_TAG_SEP}begin\uFF5C>.*?<\uFF5Ctool${DEEPSEEK_TAG_SEP}call${DEEPSEEK_TAG_SEP}end\uFF5C>`,
+      "s"
+    );
+    if (tagPairRegex.test(stripped)) return true;
+    if (stripped.startsWith("[") || stripped.startsWith("{")) {
+      return canParseJson(stripped);
+    }
+    return false;
+  },
+  parse(content) {
+    const out = [];
+    let text = stripThinkBlocks(content).trim();
+    if (!text) return out;
+    const objectTagRegex = new RegExp(
+      `<\uFF5Ctool${DEEPSEEK_TAG_SEP}call${DEEPSEEK_TAG_SEP}begin\uFF5C>(.*?)<\uFF5Ctool${DEEPSEEK_TAG_SEP}call${DEEPSEEK_TAG_SEP}end\uFF5C>`,
+      "gs"
+    );
+    for (const match of text.matchAll(objectTagRegex)) {
+      const inner = match[1].trim();
+      const fencedMatch = inner.match(
+        new RegExp(
+          `^function<\uFF5Ctool${DEEPSEEK_TAG_SEP}sep\uFF5C>([^\\s\\r\\n]+)\\s*(.*)$`,
+          "s"
+        )
+      );
+      if (fencedMatch) {
+        const name = fencedMatch[1].trim();
+        const code = extractCodeBlock(fencedMatch[2]);
+        if (code) {
+          const args = parseJsonSafely(code);
+          out.push(buildToolCall(name, args, out.length));
+          continue;
+        }
+      }
+      const obj = parseJsonSafely(inner);
+      if (obj && typeof obj === "object" && "name" in obj) {
+        const tc = objectToToolCallPhi4(obj, out.length);
+        if (tc) out.push(tc);
+      }
+    }
+    if (out.length > 0) return out;
+    try {
+      const parsed = JSON.parse(text);
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (let i = 0; i < items.length; i++) {
+        const tc = objectToToolCallPhi4(items[i], out.length);
+        if (tc) out.push(tc);
+      }
+    } catch {
+    }
+    return out;
+  },
+  clean(content) {
+    let cleaned = stripThinkBlocks(content).trim();
+    if (this.hasPartial(content) && this.parse(content).length > 0) {
+      cleaned = cleaned.replace(
+        new RegExp(
+          `<\uFF5Ctool${DEEPSEEK_TAG_SEP}call${DEEPSEEK_TAG_SEP}begin\uFF5C>.*?<\uFF5Ctool${DEEPSEEK_TAG_SEP}call${DEEPSEEK_TAG_SEP}end\uFF5C>`,
+          "gs"
+        ),
+        ""
+      );
+      cleaned = cleaned.replace(/<｜tool[^｜]*｜>/g, "");
+      if (cleaned.startsWith("{") && cleaned.endsWith("}") || cleaned.startsWith("[") && cleaned.endsWith("]")) {
+        try {
+          const parsed = JSON.parse(cleaned);
+          if (parsed && typeof parsed === "object" && "name" in parsed && ("parameters" in parsed || "arguments" in parsed)) {
+            cleaned = "";
+          }
+        } catch {
+        }
+      }
+    }
+    return cleaned.trim();
+  }
+};
+function stripThinkBlocks(content) {
+  return content.replace(/<think>.*?<\/think>/gs, "");
+}
+function extractCodeBlock(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : null;
+}
+function parseJsonSafely(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+var yi = {
+  name: "yi",
+  hasPartial(content) {
+    if (!content) return false;
+    const stripped = stripCodeFence(content).trim();
+    if (stripped.startsWith("[") && stripped.includes('"name"')) return true;
+    if (stripped.startsWith("{") && stripped.includes('"name"') && (stripped.includes('"arguments"') || stripped.includes('"parameters"'))) {
+      return true;
+    }
+    return false;
+  },
+  isComplete(content) {
+    if (!content) return false;
+    const stripped = stripCodeFence(content).trim();
+    if (stripped.startsWith("[") || stripped.startsWith("{")) {
+      return canParseJson(stripped);
+    }
+    return false;
+  },
+  parse(content) {
+    const out = [];
+    const text = stripCodeFence(content).trim();
+    if (!text) return out;
+    try {
+      const parsed = JSON.parse(text);
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (let i = 0; i < items.length; i++) {
+        const tc = objectToToolCallPhi4(items[i], out.length);
+        if (tc) out.push(tc);
+      }
+    } catch {
+    }
+    return out;
+  },
+  clean(content) {
+    if (this.hasPartial(content) && this.parse(content).length > 0) {
+      return "";
+    }
+    return content;
+  }
+};
+function stripCodeFence(text) {
+  return text.replace(/```(?:json)?\s*([\s\S]*?)\s*```/g, "$1");
+}
+var glm = {
+  name: "glm",
+  hasPartial(content) {
+    if (!content) return false;
+    const markers = [
+      "[TOOL_REQUEST]",
+      "[END_TOOL_REQUEST]",
+      "<tool_call>",
+      "</tool_call>",
+      "<arg_key>",
+      "</arg_key>",
+      "<arg_value>",
+      "</arg_value>"
+    ];
+    return markers.some((m) => content.includes(m));
+  },
+  isComplete(content) {
+    if (!content) return false;
+    if (/\[TOOL_REQUEST\].*?\[END_TOOL_REQUEST\]/s.test(content)) return true;
+    if (/<tool_call>.*?<\/tool_call>/s.test(content)) return true;
+    return false;
+  },
+  parse(content) {
+    const out = [];
+    for (const jsonStr of content.matchAll(
+      /\[TOOL_REQUEST\]\s*(\{.*?\})\s*\[END_TOOL_REQUEST\]/gs
+    )) {
+      try {
+        const data = JSON.parse(jsonStr[1].trim());
+        if (data.name) {
+          out.push(
+            buildToolCall(
+              data.name,
+              data.arguments ?? {},
+              out.length
+            )
+          );
+        }
+      } catch {
+      }
+    }
+    for (const match of content.matchAll(
+      /<tool_call>\s*(.*?)\s*((?:<arg_key>.*?<\/arg_key>\s*<arg_value>.*?<\/arg_value>\s*)+)\s*<\/tool_call>/gs
+    )) {
+      const functionName = match[1].trim();
+      const argsSection = match[2];
+      const args = {};
+      for (const argMatch of argsSection.matchAll(
+        /<arg_key>\s*(.*?)\s*<\/arg_key>\s*<arg_value>\s*(.*?)\s*<\/arg_value>/gs
+      )) {
+        const key = argMatch[1].trim();
+        const rawValue = argMatch[2].trim();
+        try {
+          args[key] = JSON.parse(rawValue);
+        } catch {
+          args[key] = rawValue;
+        }
+      }
+      out.push(buildToolCall(functionName, args, out.length));
+    }
+    return out;
+  },
+  clean(content) {
+    let c = content;
+    c = c.replace(/<tool_call>.*?<\/tool_call>/gs, "");
+    c = c.replace(/\[TOOL_REQUEST\].*?\[END_TOOL_REQUEST\]/gs, "");
+    c = c.replace(/<think>.*?<\/think>/gs, "");
+    c = c.replace(/<\/think>/g, "");
+    c = c.replace(/<think>/g, "");
+    return c.trim();
+  }
+};
+function matchAll(text, regex) {
+  return Array.from(text.matchAll(regex)).map((m) => m[1] ?? "");
+}
+function selectConverter(model) {
+  const m = model.toLowerCase();
+  if (/qwen2\.5.*coder|qwen2_5.*coder/.test(m)) return qwen25;
+  if (/qwen3\.5|qwen3-coder/.test(m)) return qwen35;
+  if (/gemma4|gemma-4/.test(m)) return gemma4;
+  if (/mistral|ministral/.test(m)) return mistral;
+  if (/llama3|llama-3|opencoder/.test(m)) return llama;
+  if (/phi4|phi-4/.test(m)) return phi4;
+  if (/deepseek/.test(m)) return deepseek;
+  if (/yi-coder|yi_coder|yicoder/.test(m)) return yi;
+  if (/glm|chatglm/.test(m)) return glm;
+  return null;
+}
+
+// intercept.ts
+var installed = false;
+function installFetchInterceptor() {
+  if (installed) return;
+  installed = true;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async function(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const reqInfo = extractRequestInfo(init);
+    const converter = reqInfo?.model ? selectConverter(reqInfo.model) : null;
+    if (!reqInfo || !converter || !reqInfo.hasTools || !url.includes("/v1/chat/completions")) {
+      return originalFetch(input, init);
+    }
+    const response = await originalFetch(input, init);
+    if (reqInfo.stream) {
+      return convertStreamingResponse(response, converter);
+    }
+    return convertNonStreamingResponse(response, converter);
+  };
+}
+function extractRequestInfo(init) {
+  if (!init?.body) return null;
+  let bodyText;
+  if (typeof init.body === "string") {
+    bodyText = init.body;
+  } else if (init.body instanceof Uint8Array) {
+    bodyText = new TextDecoder().decode(init.body);
+  } else if (init.body instanceof ArrayBuffer) {
+    bodyText = new TextDecoder().decode(init.body);
+  } else {
+    return null;
+  }
+  try {
+    const json = JSON.parse(bodyText);
+    return {
+      model: json.model ?? "",
+      stream: !!json.stream,
+      hasTools: Array.isArray(json.tools) && json.tools.length > 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function convertNonStreamingResponse(response, converter) {
+  if (!response.ok) {
+    return response;
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  const choices = data.choices;
+  if (!Array.isArray(choices)) {
+    return new Response(text, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  let modified = false;
+  for (const choice of choices) {
+    const message = choice.message;
+    if (!message || typeof message.content !== "string") continue;
+    if (!converter.hasPartial(message.content)) {
+      continue;
+    }
+    const toolCalls = converter.parse(message.content);
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls;
+      const cleaned = converter.clean(message.content);
+      if (!cleaned) {
+        delete message.content;
+      } else {
+        message.content = cleaned;
+      }
+      choice.finish_reason = "tool_calls";
+      modified = true;
+    }
+  }
+  const body = modified ? JSON.stringify(data) : text;
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function convertStreamingResponse(response, converter) {
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  const { readable, writable } = new TransformStream();
+  const writer = writable.getWriter();
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let lineBuffer = "";
+  let toolCallDetected = false;
+  let toolCallComplete = false;
+  let emittedToolCall = false;
+  async function pump(reader) {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        lineBuffer += decoder.decode(value, { stream: true });
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() ?? "";
+        for (const rawLine of lines) {
+          const line = rawLine + "\n";
+          const data = parseSseDataLine(rawLine);
+          if (data === null) {
+            await writer.write(encoder.encode(line));
+            continue;
+          }
+          if (data === "[DONE]") {
+            await writer.write(encoder.encode(`data: [DONE]
+
+`));
+            continue;
+          }
+          let chunk;
+          try {
+            chunk = JSON.parse(data);
+          } catch {
+            await writer.write(encoder.encode(`data: ${data}
+`));
+            continue;
+          }
+          const content = getChunkContent(chunk);
+          if (typeof content === "string") {
+            buffer += content;
+            if (!toolCallDetected && converter.hasPartial(buffer)) {
+              toolCallDetected = true;
+            }
+            if (toolCallDetected) {
+              if (converter.isComplete(buffer)) {
+                toolCallComplete = true;
+                if (!emittedToolCall) {
+                  const toolCalls = converter.parse(buffer);
+                  if (toolCalls.length > 0) {
+                    const newChunk = buildToolCallChunk(chunk, toolCalls);
+                    await writer.write(
+                      encoder.encode(`data: ${JSON.stringify(newChunk)}
+
+`)
+                    );
+                    emittedToolCall = true;
+                  }
+                }
+              }
+              continue;
+            }
+          }
+          await writer.write(encoder.encode(`data: ${data}
+`));
+        }
+      }
+      if (lineBuffer) {
+        await writer.write(encoder.encode(lineBuffer));
+      }
+    } catch (err) {
+      console.error("[llm-toolcall-proxy] stream conversion error:", err);
+    } finally {
+      await writer.close();
+    }
+  }
+  if (!response.body) {
+    writer.close();
+  } else {
+    pump(response.body.getReader()).catch((err) => {
+      console.error("[llm-toolcall-proxy] pump error:", err);
+      writer.close();
+    });
+  }
+  return new Response(readable, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function parseSseDataLine(line) {
+  const prefix = "data: ";
+  if (!line.startsWith(prefix)) return null;
+  return line.slice(prefix.length).trim();
+}
+function getChunkContent(chunk) {
+  const choices = chunk.choices;
+  if (!Array.isArray(choices) || choices.length === 0) return void 0;
+  const delta = choices[0].delta;
+  if (!delta) return void 0;
+  return typeof delta.content === "string" ? delta.content : void 0;
+}
+function buildToolCallChunk(original, toolCalls) {
+  return {
+    id: original.id ?? "chunk",
+    object: "chat.completion.chunk",
+    created: original.created ?? Math.floor(Date.now() / 1e3),
+    model: original.model ?? "",
+    choices: [
+      {
+        index: 0,
+        delta: {
+          role: "assistant",
+          content: null,
+          tool_calls: toolCalls.map((tc, i) => ({
+            index: i,
+            id: tc.id,
+            type: tc.type,
+            function: tc.function
+          }))
+        },
+        finish_reason: "tool_calls"
+      }
+    ]
+  };
+}
+
+// index.ts
+var plugin = async () => {
+  installFetchInterceptor();
+  return {};
+};
+var index_default = plugin;
+export {
+  index_default as default
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "opencode-ollama-toolcall-proxy",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that converts raw tool-call markup from local Ollama models into standard OpenAI tool_calls.",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@opencode-ai/plugin",
+    "test": "node --experimental-strip-types test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ollama",
+    "tool-calling",
+    "function-calling",
+    "local-llm"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@opencode-ai/plugin": "1.1.44",
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.0.0"
+  }
+}