@oh-my-pi/pi-ai 15.13.2 → 15.13.3

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [15.13.3] - 2026-06-15
+
+### Added
+
+- Added the `gemini` in-band tool-call syntax with Python-style ```tool_code``` blocks and `default_api` invocations
+- Added the `gemma` token-delimited in-band tool-call syntax using `<|tool_call>` and `<|tool_response>` blocks
+- Added `gemini` and `gemma` to owned stream tool-result token detection so their tool responses are recognized
+- Fixed truncated Gemini and Gemma tool blocks from being emitted as plain text during streaming
+- Added the Azure OpenAI provider definition (`azure`) to the registry; `AZURE_OPENAI_API_KEY` resolves as its env-var API key via the catalog provider table.
+
+### Changed
+
+- Gemini tool-call examples now render without the `default_api.` namespace prefix, keeping `<example>` blocks concise. The live wire format still uses `default_api.` per the Gemini grammar.
+
+### Fixed
+
+- Fixed duplicate tool call projections by deduplicating provider-native `toolCall` events against in-band `tool_code` calls and keeping only the first real channel
+- Dropped nameless native `toolCall` events so they no longer appear as surfaced tool calls in owned-mode streams
+- Fixed truncated Gemini and Gemma tool blocks from being emitted as plain text during streaming
+- Fixed Gemini/Gemma in-band tool-call parsing around Python comments, raw/unicode string literals, and Gemma close-token text inside string values.
+
 ## [15.13.2] - 2026-06-15
 
 ### Added

package/dist/types/grammar/gemini.d.ts

@@ -0,0 +1,16 @@
+import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+/**
+ * Scanner for the hosted-Gemini / Gemma 3 Pythonic tool-calling convention
+ * (see `docs/toolconv/gemini.md`). Tool calls arrive as a ```` ```tool_code ````
+ * fenced block whose body is one or more Python call expressions, e.g.
+ * `print(default_api.search(pattern="x", skip=40))`. Like the qwen3 scanner we
+ * buffer the whole block until its closing fence, then parse all calls at once
+ * (no incremental argument deltas — Python literals are not worth streaming).
+ */
+export declare class GeminiInbandScanner implements InbandScanner {
+    #private;
+    feed(text: string): InbandScanEvent[];
+    flush(): InbandScanEvent[];
+}
+declare const grammar: Grammar;
+export default grammar;

package/dist/types/grammar/gemma.d.ts

@@ -0,0 +1,14 @@
+import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+/**
+ * Scanner for the Gemma 4 token-delimited tool-calling convention (see
+ * `docs/toolconv/gemma.md`). Each call is one `<|tool_call>call:NAME{…}<tool_call|>`
+ * block whose argument list is `key:value` pairs; string values are wrapped in
+ * the `<|"|>` token rather than ASCII quotes, so splitting must skip those spans.
+ */
+export declare class GemmaInbandScanner implements InbandScanner {
+    #private;
+    feed(text: string): InbandScanEvent[];
+    flush(): InbandScanEvent[];
+}
+declare const grammar: Grammar;
+export default grammar;

package/dist/types/grammar/rendering.d.ts

@@ -22,3 +22,9 @@ export declare function renderXmlToolCalls(calls: readonly ToolCall[], options?:
 export declare function renderPiNativeInvocation(call: ToolCall, options?: GrammarRenderOptions): string;
 export declare function renderPiNativeToolCalls(calls: readonly ToolCall[], options?: GrammarRenderOptions): string;
 export declare function renderToolResponseResults(results: readonly GrammarToolResult[]): string;
+export declare function renderGeminiInvocation(call: ToolCall, options?: GrammarRenderOptions): string;
+export declare function renderGeminiToolCalls(calls: readonly ToolCall[], options?: GrammarRenderOptions): string;
+export declare function renderGeminiToolResults(results: readonly GrammarToolResult[]): string;
+export declare function renderGemmaInvocation(call: ToolCall, _options?: GrammarRenderOptions): string;
+export declare function renderGemmaToolCalls(calls: readonly ToolCall[], options?: GrammarRenderOptions): string;
+export declare function renderGemmaToolResults(results: readonly GrammarToolResult[]): string;

package/dist/types/registry/azure.d.ts

@@ -0,0 +1,4 @@
+export declare const azureProvider: {
+    readonly id: "azure";
+    readonly name: "Azure OpenAI";
+};

package/dist/types/registry/registry.d.ts

@@ -25,6 +25,9 @@ declare const ALL: ({
     readonly refreshToken: (credentials: import("./oauth").OAuthCredentials) => Promise<import("./oauth").OAuthCredentials>;
     readonly callbackPort: 54545;
     readonly pasteCodeFlow: true;
+} | {
+    readonly id: "azure";
+    readonly name: "Azure OpenAI";
 } | {
     readonly id: "cerebras";
     readonly name: "Cerebras";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.13.2",
+	"version": "15.13.3",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,8 +38,8 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "15.13.2",
-		"@oh-my-pi/pi-utils": "15.13.2",
+		"@oh-my-pi/pi-catalog": "15.13.3",
+		"@oh-my-pi/pi-utils": "15.13.3",
 		"partial-json": "^0.1.7",
 		"zod": "^4"
 	},

package/src/grammar/factory.ts

@@ -1,5 +1,7 @@
 import anthropicGrammar from "./anthropic";
 import deepseekGrammar from "./deepseek";
+import geminiGrammar from "./gemini";
+import gemmaGrammar from "./gemma";
 import glmGrammar from "./glm";
 import harmonyGrammar from "./harmony";
 import hermesGrammar from "./hermes";
@@ -19,6 +21,8 @@ const GRAMMARS: Record<ToolCallSyntax, Grammar> = {
 	harmony: harmonyGrammar,
 	pi: piGrammar,
 	qwen3: qwen3Grammar,
+	gemini: geminiGrammar,
+	gemma: gemmaGrammar,
 };
 
 export function getInbandGrammar(syntax: ToolCallSyntax): Grammar {

package/src/grammar/gemini.md

@@ -0,0 +1,35 @@
+## Format guide
+
+Emit tool calls as Python inside a fenced ` ```tool_code ` block. Call each function as a method on `default_api`:
+
+````text
+```tool_code
+default_api.function_name(arg="value", count=2)
+```
+````
+
+Argument values are Python literals: `"strings"`, numbers, `True`/`False`, `None`, `[lists]`, `{"dicts": 1}`.
+
+Call several functions in parallel as a Python list:
+
+````text
+```tool_code
+[default_api.first(x="a"), default_api.second(y="b")]
+```
+````
+
+Tool results arrive later in a ` ```tool_outputs ` block:
+
+````text
+```tool_outputs
+verbatim tool result
+```
+````
+
+## Rules
+
+- The function name MUST match a listed function; arguments are keyword form (`name=value`).
+- Multiple calls = a single `[...]` list (or one `default_api...` call per line) inside one ` ```tool_code ` block.
+- Put any reasoning as plain text before the ` ```tool_code ` block, never inside it.
+- Read each ` ```tool_outputs ` block in call order. NEVER write a ` ```tool_outputs ` block yourself.
+- After emitting the ` ```tool_code ` block, YOU MUST STOP AND HALT.

package/src/grammar/gemini.ts

@@ -0,0 +1,440 @@
+import { mintToolCallId, partialSuffixOverlapAny } from "./coercion";
+import grammarPrompt from "./gemini.md" with { type: "text" };
+import { renderGeminiInvocation, renderGeminiToolCalls, renderGeminiToolResults } from "./rendering";
+import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+
+const CODE_OPEN = "```tool_code";
+const FENCE = "```";
+const OPEN_TAGS = [CODE_OPEN] as const;
+
+type State = "outside" | "tool";
+
+interface ParsedCall {
+	name: string;
+	arguments: Record<string, unknown>;
+}
+
+/**
+ * Scanner for the hosted-Gemini / Gemma 3 Pythonic tool-calling convention
+ * (see `docs/toolconv/gemini.md`). Tool calls arrive as a ```` ```tool_code ````
+ * fenced block whose body is one or more Python call expressions, e.g.
+ * `print(default_api.search(pattern="x", skip=40))`. Like the qwen3 scanner we
+ * buffer the whole block until its closing fence, then parse all calls at once
+ * (no incremental argument deltas — Python literals are not worth streaming).
+ */
+export class GeminiInbandScanner implements InbandScanner {
+	#buffer = "";
+	#state: State = "outside";
+
+	feed(text: string): InbandScanEvent[] {
+		if (text.length === 0) return [];
+		this.#buffer += text;
+		return this.#consume(false);
+	}
+
+	flush(): InbandScanEvent[] {
+		return this.#consume(true);
+	}
+
+	#consume(final: boolean): InbandScanEvent[] {
+		const events: InbandScanEvent[] = [];
+		while (this.#buffer.length > 0) {
+			if (this.#state === "outside") {
+				this.#consumeOutside(final, events);
+				if (this.#state === "outside") break;
+				continue;
+			}
+			this.#consumeTool(final, events);
+			if (this.#state === "tool") break;
+		}
+		return events;
+	}
+
+	#consumeOutside(final: boolean, events: InbandScanEvent[]): void {
+		const open = this.#buffer.indexOf(CODE_OPEN);
+		if (open === -1) {
+			const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, OPEN_TAGS);
+			const emit = this.#buffer.slice(0, this.#buffer.length - hold);
+			if (emit.length > 0) events.push({ type: "text", text: emit });
+			this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+			return;
+		}
+		if (open > 0) events.push({ type: "text", text: this.#buffer.slice(0, open) });
+		this.#buffer = this.#buffer.slice(open + CODE_OPEN.length);
+		this.#state = "tool";
+	}
+
+	#consumeTool(final: boolean, events: InbandScanEvent[]): void {
+		const close = this.#buffer.indexOf(FENCE);
+		if (close === -1) {
+			// Inside the fence we emit nothing until it closes; on a truncated
+			// stream the incomplete block is dropped rather than leaked as text.
+			if (final) {
+				this.#buffer = "";
+				this.#state = "outside";
+			}
+			return;
+		}
+		const body = this.#buffer.slice(0, close);
+		const rawBlock = `${CODE_OPEN}${body}${FENCE}`;
+		for (const call of parseGeminiCalls(body)) {
+			const id = mintToolCallId();
+			events.push({ type: "toolStart", id, name: call.name });
+			events.push({ type: "toolEnd", id, name: call.name, arguments: call.arguments, rawBlock });
+		}
+		this.#buffer = this.#buffer.slice(close + FENCE.length);
+		this.#state = "outside";
+	}
+}
+
+/** Extract every top-level call expression in a `tool_code` body. */
+function parseGeminiCalls(body: string): ParsedCall[] {
+	const calls: ParsedCall[] = [];
+	let i = 0;
+	const n = body.length;
+	while (i < n) {
+		const ch = body[i]!;
+		if (ch === '"' || ch === "'") {
+			i = skipString(body, i);
+			continue;
+		}
+		if (ch === "#") {
+			i = skipComment(body, i);
+			continue;
+		}
+		if (ch === "(") {
+			const name = identBefore(body, i);
+			if (name && name !== "print") {
+				const end = matchParen(body, i);
+				if (end !== -1) {
+					calls.push({ name, arguments: parsePyArgs(body.slice(i + 1, end)) });
+					i = end + 1;
+					continue;
+				}
+			}
+		}
+		i++;
+	}
+	return calls;
+}
+
+/** Identifier immediately preceding a `(` (the callee's final name segment). */
+function identBefore(body: string, parenIndex: number): string | undefined {
+	let j = parenIndex - 1;
+	while (j >= 0 && /\s/.test(body[j]!)) j--;
+	const end = j + 1;
+	while (j >= 0 && /[A-Za-z0-9_]/.test(body[j]!)) j--;
+	const name = body.slice(j + 1, end);
+	return /^[A-Za-z_]\w*$/.test(name) ? name : undefined;
+}
+
+/** Index of the `)` matching the `(` at `openIndex`, skipping string contents. */
+function matchParen(body: string, openIndex: number): number {
+	let depth = 0;
+	let i = openIndex;
+	const n = body.length;
+	while (i < n) {
+		const ch = body[i]!;
+		if (ch === '"' || ch === "'") {
+			i = skipString(body, i);
+			continue;
+		}
+		if (ch === "#") {
+			i = skipComment(body, i);
+			continue;
+		}
+		if (ch === "(") depth++;
+		else if (ch === ")" && --depth === 0) return i;
+		i++;
+	}
+	return -1;
+}
+
+/** Index just past the Python string literal starting at `i` (a quote char). */
+function skipString(body: string, i: number): number {
+	const quote = body[i]!;
+	const triple = quote + quote + quote;
+	if (body.startsWith(triple, i)) {
+		const close = body.indexOf(triple, i + 3);
+		return close === -1 ? body.length : close + 3;
+	}
+	let j = i + 1;
+	const n = body.length;
+	while (j < n) {
+		const ch = body[j]!;
+		if (ch === "\\") {
+			j += 2;
+			continue;
+		}
+		if (ch === quote) return j + 1;
+		j++;
+	}
+	return n;
+}
+
+function skipComment(body: string, i: number): number {
+	const newline = body.indexOf("\n", i + 1);
+	return newline === -1 ? body.length : newline + 1;
+}
+
+function stripComments(body: string): string {
+	let out = "";
+	let i = 0;
+	const n = body.length;
+	while (i < n) {
+		const ch = body[i]!;
+		if (ch === '"' || ch === "'") {
+			const end = skipString(body, i);
+			out += body.slice(i, end);
+			i = end;
+			continue;
+		}
+		if (ch === "#") {
+			const newline = body.indexOf("\n", i + 1);
+			if (newline === -1) break;
+			out += "\n";
+			i = newline + 1;
+			continue;
+		}
+		out += ch;
+		i++;
+	}
+	return out;
+}
+
+function parsePyArgs(text: string): Record<string, unknown> {
+	const out: Record<string, unknown> = {};
+	for (const segment of splitTopLevel(stripComments(text), ",")) {
+		const trimmed = segment.trim();
+		if (trimmed.length === 0) continue;
+		const eq = topLevelIndexOf(trimmed, "=");
+		if (eq === -1) continue; // positional args are not part of the convention
+		const key = trimmed.slice(0, eq).trim();
+		if (!/^[A-Za-z_]\w*$/.test(key)) continue;
+		out[key] = parsePyValue(trimmed.slice(eq + 1).trim());
+	}
+	return out;
+}
+
+function parsePyValue(raw: string): unknown {
+	const t = raw.trim();
+	if (t.length === 0) return "";
+	if (t === "True" || t === "true") return true;
+	if (t === "False" || t === "false") return false;
+	if (t === "None" || t === "null") return null;
+	const prefix = stringPrefixLength(t);
+	if (prefix !== undefined) return decodeString(t);
+	const first = t[0]!;
+	if (first === "[") return parseList(t);
+	if (first === "{") return parseDict(t);
+	if (/^[+-]?(\d|\.)/.test(t)) {
+		const num = Number(t);
+		if (!Number.isNaN(num)) return num;
+	}
+	return t;
+}
+
+function parseList(t: string): unknown[] {
+	const inner = t.slice(1, t.endsWith("]") ? t.length - 1 : t.length);
+	return splitTopLevel(stripComments(inner), ",")
+		.map(part => part.trim())
+		.filter(part => part.length > 0)
+		.map(parsePyValue);
+}
+
+function parseDict(t: string): Record<string, unknown> {
+	const inner = t.slice(1, t.endsWith("}") ? t.length - 1 : t.length);
+	const out: Record<string, unknown> = {};
+	for (const segment of splitTopLevel(stripComments(inner), ",")) {
+		const trimmed = segment.trim();
+		if (trimmed.length === 0) continue;
+		const colon = topLevelIndexOf(trimmed, ":");
+		if (colon === -1) continue;
+		const keyRaw = trimmed.slice(0, colon).trim();
+		const key = stringPrefixLength(keyRaw) !== undefined ? decodeString(keyRaw) : keyRaw;
+		out[key] = parsePyValue(trimmed.slice(colon + 1).trim());
+	}
+	return out;
+}
+
+function decodeString(t: string): string {
+	const prefix = stringPrefixLength(t) ?? 0;
+	const raw = t.slice(0, prefix).toLowerCase().includes("r");
+	const quote = t[prefix]!;
+	const triple = quote + quote + quote;
+	if (t.startsWith(triple, prefix) && t.length >= prefix + 6 && t.endsWith(triple)) {
+		const inner = t.slice(prefix + 3, t.length - 3);
+		return raw ? inner : unescapePythonString(inner);
+	}
+	const inner = t.endsWith(quote) && t.length >= prefix + 2 ? t.slice(prefix + 1, t.length - 1) : t.slice(prefix + 1);
+	return raw ? inner : unescapePythonString(inner);
+}
+
+function stringPrefixLength(t: string): number | undefined {
+	for (const len of [2, 1, 0]) {
+		const prefix = t.slice(0, len).toLowerCase();
+		if (
+			(prefix === "" || prefix === "r" || prefix === "u" || prefix === "b" || prefix === "br" || prefix === "rb") &&
+			(t[len] === '"' || t[len] === "'")
+		) {
+			return len;
+		}
+	}
+	return undefined;
+}
+
+function unescapePythonString(s: string): string {
+	if (!s.includes("\\")) return s;
+	let out = "";
+	let i = 0;
+	while (i < s.length) {
+		const ch = s[i]!;
+		if (ch !== "\\") {
+			out += ch;
+			i++;
+			continue;
+		}
+		const next = s[i + 1];
+		if (next && /^[0-7]$/.test(next)) {
+			const octal = /^[0-7]{1,3}/.exec(s.slice(i + 1))![0];
+			out += String.fromCharCode(parseInt(octal, 8));
+			i += octal.length + 1;
+			continue;
+		}
+		switch (next) {
+			case "n":
+				out += "\n";
+				i += 2;
+				break;
+			case "t":
+				out += "\t";
+				i += 2;
+				break;
+			case "r":
+				out += "\r";
+				i += 2;
+				break;
+			case "\\":
+				out += "\\";
+				i += 2;
+				break;
+			case "'":
+				out += "'";
+				i += 2;
+				break;
+			case '"':
+				out += '"';
+				i += 2;
+				break;
+			case "0":
+				out += "\0";
+				i += 2;
+				break;
+			case "x": {
+				const hex = s.slice(i + 2, i + 4);
+				if (/^[0-9a-fA-F]{2}$/.test(hex)) {
+					out += String.fromCharCode(parseInt(hex, 16));
+					i += 4;
+				} else {
+					out += "x";
+					i += 2;
+				}
+				break;
+			}
+			case "u": {
+				const hex = s.slice(i + 2, i + 6);
+				if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+					out += String.fromCharCode(parseInt(hex, 16));
+					i += 6;
+				} else {
+					out += "u";
+					i += 2;
+				}
+				break;
+			}
+			case "U": {
+				const hex = s.slice(i + 2, i + 10);
+				if (/^[0-9a-fA-F]{8}$/.test(hex)) {
+					out += String.fromCodePoint(parseInt(hex, 16));
+					i += 10;
+				} else {
+					out += "U";
+					i += 2;
+				}
+				break;
+			}
+			case undefined:
+				out += "\\";
+				i += 1;
+				break;
+			default:
+				out += next;
+				i += 2;
+				break;
+		}
+	}
+	return out;
+}
+
+/** Split on `sep` at bracket depth 0, skipping string literals. */
+function splitTopLevel(text: string, sep: string): string[] {
+	const parts: string[] = [];
+	let depth = 0;
+	let start = 0;
+	let i = 0;
+	const n = text.length;
+	while (i < n) {
+		const ch = text[i]!;
+		if (ch === '"' || ch === "'") {
+			i = skipString(text, i);
+			continue;
+		}
+		if (ch === "#") {
+			i = skipComment(text, i);
+			continue;
+		}
+		if (ch === "(" || ch === "[" || ch === "{") depth++;
+		else if (ch === ")" || ch === "]" || ch === "}") depth--;
+		else if (depth === 0 && ch === sep) {
+			parts.push(text.slice(start, i));
+			start = i + 1;
+		}
+		i++;
+	}
+	parts.push(text.slice(start));
+	return parts;
+}
+
+/** First index of `ch` at bracket depth 0, skipping string literals. */
+function topLevelIndexOf(text: string, ch: string): number {
+	let depth = 0;
+	let i = 0;
+	const n = text.length;
+	while (i < n) {
+		const c = text[i]!;
+		if (c === '"' || c === "'") {
+			i = skipString(text, i);
+			continue;
+		}
+		if (c === "#") {
+			i = skipComment(text, i);
+			continue;
+		}
+		if (c === "(" || c === "[" || c === "{") depth++;
+		else if (c === ")" || c === "]" || c === "}") depth--;
+		else if (depth === 0 && c === ch) return i;
+		i++;
+	}
+	return -1;
+}
+
+const grammar: Grammar = {
+	syntax: "gemini",
+	prompt: grammarPrompt,
+	createScanner: () => new GeminiInbandScanner(),
+	renderToolCall: renderGeminiInvocation,
+	renderAssistantToolCalls: renderGeminiToolCalls,
+	renderToolResults: renderGeminiToolResults,
+};
+
+export default grammar;

package/src/grammar/gemma.md

@@ -0,0 +1,23 @@
+## Format guide
+
+Emit each tool call as one `<|tool_call>` block. The body is `call:NAME{key:value,...}`; wrap every string value in the `<|"|>` token:
+
+```text
+<|tool_call>call:function_name{path:<|"|>src/a.ts<|"|>,count:2}<tool_call|>
+```
+
+Non-string values are bare: numbers (`2`), `true`/`false`, `null`, lists `[<|"|>a<|"|>,<|"|>b<|"|>]`, and nested objects `{k:<|"|>v<|"|>}`.
+
+Tool results arrive later in matching `<|tool_response>` blocks:
+
+```text
+<|tool_response>response:function_name{output:<|"|>verbatim result<|"|>}<tool_response|>
+```
+
+## Rules
+
+- `NAME` MUST match a listed function; arguments are `key:value` pairs separated by commas.
+- Multiple calls = consecutive `<|tool_call>...<tool_call|>` blocks; keep prose outside them.
+- The closer is `<tool_call|>` (pipe on the right), not `</tool_call>` or `<|tool_call>`.
+- Read each `<|tool_response>` block in call order. NEVER write a `<|tool_response>` block yourself.
+- After emitting your tool calls, YOU MUST STOP AND HALT.

package/src/grammar/gemma.ts

@@ -0,0 +1,237 @@
+import { mintToolCallId, partialSuffixOverlapAny } from "./coercion";
+import grammarPrompt from "./gemma.md" with { type: "text" };
+import { renderGemmaInvocation, renderGemmaToolCalls, renderGemmaToolResults } from "./rendering";
+import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+
+const CALL_OPEN = "<|tool_call>";
+const CALL_CLOSE = "<tool_call|>";
+const STRING = '<|"|>';
+const OPEN_TAGS = [CALL_OPEN] as const;
+const CALL_HEAD = /^call:\s*([A-Za-z_]\w*)\s*\{/;
+
+type State = "outside" | "tool";
+
+interface ParsedCall {
+	name: string;
+	arguments: Record<string, unknown>;
+}
+
+/**
+ * Scanner for the Gemma 4 token-delimited tool-calling convention (see
+ * `docs/toolconv/gemma.md`). Each call is one `<|tool_call>call:NAME{…}<tool_call|>`
+ * block whose argument list is `key:value` pairs; string values are wrapped in
+ * the `<|"|>` token rather than ASCII quotes, so splitting must skip those spans.
+ */
+export class GemmaInbandScanner implements InbandScanner {
+	#buffer = "";
+	#state: State = "outside";
+
+	feed(text: string): InbandScanEvent[] {
+		if (text.length === 0) return [];
+		this.#buffer += text;
+		return this.#consume(false);
+	}
+
+	flush(): InbandScanEvent[] {
+		return this.#consume(true);
+	}
+
+	#consume(final: boolean): InbandScanEvent[] {
+		const events: InbandScanEvent[] = [];
+		while (this.#buffer.length > 0) {
+			if (this.#state === "outside") {
+				this.#consumeOutside(final, events);
+				if (this.#state === "outside") break;
+				continue;
+			}
+			this.#consumeTool(final, events);
+			if (this.#state === "tool") break;
+		}
+		return events;
+	}
+
+	#consumeOutside(final: boolean, events: InbandScanEvent[]): void {
+		const open = this.#buffer.indexOf(CALL_OPEN);
+		if (open === -1) {
+			const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, OPEN_TAGS);
+			const emit = this.#buffer.slice(0, this.#buffer.length - hold);
+			if (emit.length > 0) events.push({ type: "text", text: emit });
+			this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+			return;
+		}
+		if (open > 0) events.push({ type: "text", text: this.#buffer.slice(0, open) });
+		this.#buffer = this.#buffer.slice(open + CALL_OPEN.length);
+		this.#state = "tool";
+	}
+
+	#consumeTool(final: boolean, events: InbandScanEvent[]): void {
+		const close = findCallClose(this.#buffer);
+		if (close === -1) {
+			if (final) {
+				this.#buffer = "";
+				this.#state = "outside";
+			}
+			return;
+		}
+		const body = this.#buffer.slice(0, close);
+		const parsed = parseGemmaCall(body);
+		if (parsed) {
+			const id = mintToolCallId();
+			events.push({ type: "toolStart", id, name: parsed.name });
+			events.push({
+				type: "toolEnd",
+				id,
+				name: parsed.name,
+				arguments: parsed.arguments,
+				rawBlock: `${CALL_OPEN}${body}${CALL_CLOSE}`,
+			});
+		}
+		this.#buffer = this.#buffer.slice(close + CALL_CLOSE.length);
+		this.#state = "outside";
+	}
+}
+
+function parseGemmaCall(body: string): ParsedCall | undefined {
+	const trimmed = body.trim();
+	const head = CALL_HEAD.exec(trimmed);
+	if (!head) return undefined;
+	const braceStart = head[0].length - 1;
+	const end = matchDelim(trimmed, braceStart, "{", "}");
+	const argsText = end === -1 ? trimmed.slice(braceStart + 1) : trimmed.slice(braceStart + 1, end);
+	return { name: head[1]!, arguments: parseGemmaArgs(argsText) };
+}
+
+function parseGemmaArgs(text: string): Record<string, unknown> {
+	const out: Record<string, unknown> = {};
+	for (const segment of splitTopLevel(text, ",")) {
+		const trimmed = segment.trim();
+		if (trimmed.length === 0) continue;
+		const colon = topLevelIndexOf(trimmed, ":");
+		if (colon === -1) continue;
+		const key = trimmed.slice(0, colon).trim();
+		if (!/^[A-Za-z_]\w*$/.test(key)) continue;
+		out[key] = parseGemmaValue(trimmed.slice(colon + 1).trim());
+	}
+	return out;
+}
+
+function parseGemmaValue(raw: string): unknown {
+	const t = raw.trim();
+	if (t.startsWith(STRING)) {
+		const close = t.indexOf(STRING, STRING.length);
+		return close === -1 ? t.slice(STRING.length) : t.slice(STRING.length, close);
+	}
+	if (t.startsWith("[")) {
+		const end = matchDelim(t, 0, "[", "]");
+		const inner = end === -1 ? t.slice(1) : t.slice(1, end);
+		return splitTopLevel(inner, ",")
+			.map(part => part.trim())
+			.filter(part => part.length > 0)
+			.map(parseGemmaValue);
+	}
+	if (t.startsWith("{")) {
+		const end = matchDelim(t, 0, "{", "}");
+		return parseGemmaArgs(end === -1 ? t.slice(1) : t.slice(1, end));
+	}
+	if (t === "true") return true;
+	if (t === "false") return false;
+	if (t === "null" || t === "none" || t === "None") return null;
+	if (/^[+-]?(\d|\.)/.test(t)) {
+		const num = Number(t);
+		if (!Number.isNaN(num)) return num;
+	}
+	return t;
+}
+
+/** Index just past the `<|"|>`-delimited string starting at `i`. */
+function skipGemmaString(text: string, i: number): number {
+	const close = text.indexOf(STRING, i + STRING.length);
+	return close === -1 ? text.length : close + STRING.length;
+}
+
+function findCallClose(text: string): number {
+	let i = 0;
+	const n = text.length;
+	while (i < n) {
+		if (text.startsWith(STRING, i)) {
+			i = skipGemmaString(text, i);
+			continue;
+		}
+		if (text.startsWith(CALL_CLOSE, i)) return i;
+		i++;
+	}
+	return -1;
+}
+
+/** Index of the `close` delimiter matching `open` at `openIndex`, skipping strings. */
+function matchDelim(text: string, openIndex: number, open: string, close: string): number {
+	let depth = 0;
+	let i = openIndex;
+	const n = text.length;
+	while (i < n) {
+		if (text.startsWith(STRING, i)) {
+			i = skipGemmaString(text, i);
+			continue;
+		}
+		const ch = text[i]!;
+		if (ch === open) depth++;
+		else if (ch === close && --depth === 0) return i;
+		i++;
+	}
+	return -1;
+}
+
+/** Split on `sep` at bracket depth 0, skipping `<|"|>` string spans. */
+function splitTopLevel(text: string, sep: string): string[] {
+	const parts: string[] = [];
+	let depth = 0;
+	let start = 0;
+	let i = 0;
+	const n = text.length;
+	while (i < n) {
+		if (text.startsWith(STRING, i)) {
+			i = skipGemmaString(text, i);
+			continue;
+		}
+		const ch = text[i]!;
+		if (ch === "{" || ch === "[" || ch === "(") depth++;
+		else if (ch === "}" || ch === "]" || ch === ")") depth--;
+		else if (depth === 0 && ch === sep) {
+			parts.push(text.slice(start, i));
+			start = i + 1;
+		}
+		i++;
+	}
+	parts.push(text.slice(start));
+	return parts;
+}
+
+/** First index of `ch` at bracket depth 0, skipping `<|"|>` string spans. */
+function topLevelIndexOf(text: string, ch: string): number {
+	let depth = 0;
+	let i = 0;
+	const n = text.length;
+	while (i < n) {
+		if (text.startsWith(STRING, i)) {
+			i = skipGemmaString(text, i);
+			continue;
+		}
+		const c = text[i]!;
+		if (c === "{" || c === "[" || c === "(") depth++;
+		else if (c === "}" || c === "]" || c === ")") depth--;
+		else if (depth === 0 && c === ch) return i;
+		i++;
+	}
+	return -1;
+}
+
+const grammar: Grammar = {
+	syntax: "gemma",
+	prompt: grammarPrompt,
+	createScanner: () => new GemmaInbandScanner(),
+	renderToolCall: renderGemmaInvocation,
+	renderAssistantToolCalls: renderGemmaToolCalls,
+	renderToolResults: renderGemmaToolResults,
+};
+
+export default grammar;

package/src/grammar/owned-stream.ts

@@ -20,6 +20,8 @@ const RESPONSE_OPEN_TOKENS: Record<ToolCallSyntax, readonly string[]> = {
 	harmony: ["<|start|>functions."],
 	pi: ["<tool_response>"],
 	qwen3: ["<tool_response>"],
+	gemini: ["```tool_outputs"],
+	gemma: ["<|tool_response>"],
 };
 
 function firstTokenIndex(text: string, tokens: readonly string[]): number {
@@ -84,6 +86,24 @@ export function wrapInbandToolStream(
 							return;
 						}
 						break;
+					case "toolcall_start": {
+						// Provider emitted a native structured tool call (e.g. Gemini via
+						// OpenRouter still returns `functionCall` parts even when owned mode
+						// sends no `tools`). Forward the native lifecycle live so the UI
+						// streams it; otherwise the turn loses its only actionable content
+						// and the loop retries forever on a reasoning-only message. The
+						// projector ignores nameless "ghost" parts and de-conflicts with the
+						// in-band channel.
+						const src = event.partial.content[event.contentIndex];
+						projector?.nativeToolStart(event.contentIndex, src?.type === "toolCall" ? src.name : "");
+						break;
+					}
+					case "toolcall_delta":
+						projector?.nativeToolDelta(event.contentIndex, event.delta);
+						break;
+					case "toolcall_end":
+						projector?.nativeToolEnd(event.contentIndex, event.toolCall);
+						break;
 					case "done":
 						projector ??= new InbandStreamProjector(out, tools, syntax, event.message, true);
 						projector.finish(event.message, true);
@@ -113,6 +133,13 @@ class InbandStreamProjector {
 	#fedLen = 0;
 	#stopped = false;
 	#responsePending = "";
+	// Provider-native tool calls forwarded live (e.g. Gemini still returns
+	// `functionCall` parts under owned mode), keyed by the inner stream's
+	// `contentIndex`. `#toolChannel` records which channel produced the turn's
+	// first real call so the other is dropped — no double-dispatch, and no
+	// guessing from emptiness. Nameless "ghost" parts never lock a channel.
+	#nativeBlocks = new Map<number, { index: number; block: ToolCall }>();
+	#toolChannel: "native" | "inband" | undefined;
 
 	constructor(
 		out: AssistantMessageEventStream,
@@ -140,6 +167,62 @@ class InbandStreamProjector {
 		this.#partial.content.push(block);
 	}
 
+	// Forward a native tool call's lifecycle live. `name` comes from the inner
+	// stream's partial (set at start for well-behaved providers). Empty `name`
+	// means a not-yet-identified or "ghost" call — skip until `nativeToolEnd`
+	// can confirm. Once the in-band channel owns the turn, native calls are
+	// dropped to avoid double-dispatch.
+	nativeToolStart(srcIndex: number, name: string): void {
+		if (this.#stopped || !name || this.#toolChannel === "inband") return;
+		this.#toolChannel = "native";
+		this.#closeText();
+		this.#closeThinking();
+		const block: ToolCall = { type: "toolCall", id: "", name, arguments: {} };
+		this.#partial.content.push(block);
+		const index = this.#partial.content.length - 1;
+		this.#nativeBlocks.set(srcIndex, { index, block });
+		if (this.#emitEvents) this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
+	}
+
+	nativeToolDelta(srcIndex: number, delta: string): void {
+		if (this.#stopped) return;
+		const entry = this.#nativeBlocks.get(srcIndex);
+		if (!entry) return;
+		if (this.#emitEvents)
+			this.#out.push({ type: "toolcall_delta", contentIndex: entry.index, delta, partial: this.#partial });
+	}
+
+	nativeToolEnd(srcIndex: number, toolCall: ToolCall): void {
+		if (this.#stopped) return;
+		const entry = this.#nativeBlocks.get(srcIndex);
+		if (entry) {
+			Object.assign(entry.block, toolCall);
+			if (this.#emitEvents)
+				this.#out.push({
+					type: "toolcall_end",
+					contentIndex: entry.index,
+					toolCall: entry.block,
+					partial: this.#partial,
+				});
+			this.#nativeBlocks.delete(srcIndex);
+			return;
+		}
+		// Never streamed (name was empty at start). Salvage a real call whose name
+		// only arrived now; drop nameless ghosts and anything the in-band channel
+		// already claimed.
+		if (!toolCall.name || this.#toolChannel === "inband") return;
+		this.#toolChannel = "native";
+		this.#closeText();
+		this.#closeThinking();
+		const block: ToolCall = { ...toolCall };
+		this.#partial.content.push(block);
+		const index = this.#partial.content.length - 1;
+		if (this.#emitEvents) {
+			this.#out.push({ type: "toolcall_start", contentIndex: index, partial: this.#partial });
+			this.#out.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: this.#partial });
+		}
+	}
+
 	text(delta: string): boolean {
 		if (this.#stopped) return true;
 		this.#fedLen += delta.length;
@@ -281,6 +364,9 @@ class InbandStreamProjector {
 	}
 
 	#beginTool(event: Extract<InbandScanEvent, { type: "toolStart" }>): void {
+		// Native owns the turn → drop the in-band call to avoid double-dispatch.
+		if (this.#toolChannel === "native") return;
+		this.#toolChannel = "inband";
 		this.#closeText();
 		this.#closeThinking();
 		if (this.#toolBlocks.has(event.id)) return;

package/src/grammar/rendering.ts

@@ -212,3 +212,102 @@ function escapeXmlAttr(value: string): string {
 function escapeXmlText(value: string): string {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
+
+// --- Gemini: Pythonic `tool_code` / `default_api` convention ---
+
+const GEMINI_CODE_OPEN = "```tool_code";
+const GEMINI_OUTPUT_OPEN = "```tool_outputs";
+const GEMINI_FENCE = "```";
+
+export function renderGeminiInvocation(call: ToolCall, options: GrammarRenderOptions = {}): string {
+	const kwargs = Object.entries(call.arguments)
+		.map(([key, value]) => `${key}=${pyValue(value)}`)
+		.join(", ");
+	return options.example ? `${call.name}(${kwargs})` : `default_api.${call.name}(${kwargs})`;
+}
+
+export function renderGeminiToolCalls(calls: readonly ToolCall[], options: GrammarRenderOptions = {}): string {
+	// One call renders bare; parallel calls render as a Python list `[a, b]`.
+	const body =
+		calls.length === 1
+			? renderGeminiInvocation(calls[0]!, options)
+			: `[${calls.map(call => renderGeminiInvocation(call, options)).join(", ")}]`;
+	// Examples show the bare call; the live wire form fences it as `tool_code`.
+	return options.example ? body : `${GEMINI_CODE_OPEN}\n${body}\n${GEMINI_FENCE}`;
+}
+
+export function renderGeminiToolResults(results: readonly GrammarToolResult[]): string {
+	return results.map(result => `${GEMINI_OUTPUT_OPEN}\n${result.text}\n${GEMINI_FENCE}`).join("\n");
+}
+
+function pyValue(value: unknown): string {
+	if (value === null || value === undefined) return "None";
+	if (typeof value === "boolean") return value ? "True" : "False";
+	if (typeof value === "number") return Number.isFinite(value) ? String(value) : pyString(String(value));
+	if (typeof value === "string") return pyString(value);
+	if (Array.isArray(value)) return `[${value.map(pyValue).join(", ")}]`;
+	if (typeof value === "object") {
+		const entries = Object.entries(value as Record<string, unknown>);
+		return `{${entries.map(([key, val]) => `${pyString(key)}: ${pyValue(val)}`).join(", ")}}`;
+	}
+	return pyString(String(value));
+}
+
+function pyString(value: string): string {
+	const escaped = value
+		.replaceAll("\\", "\\\\")
+		.replaceAll('"', '\\"')
+		.replaceAll("\n", "\\n")
+		.replaceAll("\r", "\\r")
+		.replaceAll("\t", "\\t");
+	return `"${escaped}"`;
+}
+
+// --- Gemma 4: token-delimited `call:NAME{…}` convention ---
+
+const GEMMA_CALL_OPEN = "<|tool_call>";
+const GEMMA_CALL_CLOSE = "<tool_call|>";
+const GEMMA_RESPONSE_OPEN = "<|tool_response>";
+const GEMMA_RESPONSE_CLOSE = "<tool_response|>";
+const GEMMA_STRING = '<|"|>';
+
+export function renderGemmaInvocation(call: ToolCall, _options: GrammarRenderOptions = {}): string {
+	const args = Object.entries(call.arguments)
+		.map(([key, value]) => `${key}:${gemmaValue(value)}`)
+		.join(",");
+	return `${GEMMA_CALL_OPEN}call:${call.name}{${args}}${GEMMA_CALL_CLOSE}`;
+}
+
+export function renderGemmaToolCalls(calls: readonly ToolCall[], options: GrammarRenderOptions = {}): string {
+	return calls.map(call => renderGemmaInvocation(call, options)).join("");
+}
+
+export function renderGemmaToolResults(results: readonly GrammarToolResult[]): string {
+	return results
+		.map(
+			result =>
+				`${GEMMA_RESPONSE_OPEN}response:${result.name}{output:${gemmaValue(parseMaybeJson(result.text))}}${GEMMA_RESPONSE_CLOSE}`,
+		)
+		.join("");
+}
+
+function gemmaValue(value: unknown): string {
+	if (value === null || value === undefined) return "null";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (typeof value === "number") return String(value);
+	if (typeof value === "string") return `${GEMMA_STRING}${value}${GEMMA_STRING}`;
+	if (Array.isArray(value)) return `[${value.map(gemmaValue).join(",")}]`;
+	if (typeof value === "object") {
+		const entries = Object.entries(value as Record<string, unknown>);
+		return `{${entries.map(([key, val]) => `${key}:${gemmaValue(val)}`).join(",")}}`;
+	}
+	return `${GEMMA_STRING}${String(value)}${GEMMA_STRING}`;
+}
+
+function parseMaybeJson(text: string): unknown {
+	try {
+		return JSON.parse(text) as unknown;
+	} catch {
+		return text;
+	}
+}

package/src/registry/azure.ts

@@ -0,0 +1,6 @@
+import type { ProviderDefinition } from "./types";
+
+export const azureProvider = {
+	id: "azure",
+	name: "Azure OpenAI",
+} as const satisfies ProviderDefinition;

package/src/registry/registry.ts

@@ -3,6 +3,7 @@ import { aimlApiProvider } from "./aimlapi";
 import { alibabaCodingPlanProvider } from "./alibaba-coding-plan";
 import { amazonBedrockProvider } from "./amazon-bedrock";
 import { anthropicProvider } from "./anthropic";
+import { azureProvider } from "./azure";
 import { cerebrasProvider } from "./cerebras";
 import { cloudflareAiGatewayProvider } from "./cloudflare-ai-gateway";
 import { cursorProvider } from "./cursor";
@@ -68,6 +69,7 @@ import { zhipuCodingPlanProvider } from "./zhipu-coding-plan";
  * list for the loginable providers; non-login model providers are appended.
  */
 const ALL = [
+	azureProvider,
 	openaiCodexProvider,
 	anthropicProvider,
 	zaiProvider,