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

package/CHANGELOG.md

@@ -2,6 +2,69 @@
 
 ## [Unreleased]
 
+## [16.0.0] - 2026-06-15
+
+### Breaking Changes
+
+- Renamed the public dialect entrypoint from `@oh-my-pi/pi-ai/grammar` to `@oh-my-pi/pi-ai/dialect`.
+- Renamed grammar dialect identifiers from `ToolCallSyntax` to `Dialect`, renamed the `Grammar` interface to `DialectDefinition`, and renamed `Grammar.syntax` to `DialectDefinition.dialect`.
+- Added `DialectDefinition.renderThinking` and `DialectDefinition.renderTranscript` so dialect implementations serialize complete native chat transcripts, not just tool call/result blocks.
+
+### Added
+
+- Added `renderTranscript` method to dialect definitions for serializing complete native chat transcripts
+- Added `renderThinking` method to dialect definitions for rendering thinking/reasoning blocks
+- Added support for 11 dialect implementations: Anthropic, DeepSeek, Gemini, Gemma, GLM, Harmony, Hermes, Kimi, Pi-native, Qwen3, and XML
+- Added `createInbandScanner` factory function to instantiate dialect-specific scanners
+- Added `getDialectDefinition` function to retrieve dialect implementations by name
+- Added `renderToolCatalog` and `renderInbandToolPrompt` functions for tool catalog rendering
+- Added `renderToolInventory` function to generate human-readable per-tool documentation with examples
+- Added `renderToolExamples` function to render tool usage examples in the model's native dialect
+- Added `encodeInbandToolHistory` function to encode tool call history in dialect-specific format
+- Added `wrapInbandToolStream` function to process streaming responses with in-band tool call parsing
+- Added `ThinkingInbandScanner` for parsing thinking/reasoning blocks across dialects
+- Added `OwnedStream` class for managing dialect-aware streaming with tool call events
+- Added in-band thinking channels to every dialect that was missing one: `gemini` (a ```` ```thinking ```` fence mirroring ```` ```tool_code ````), `gemma` (its native `<|channel>thought…<channel|>` reasoning channel), `kimi` (`<think>…</think>`), and `pi` (`<thinking>…</thinking>`). Each scanner now parses reasoning into thinking events instead of leaking chain-of-thought into the visible reply, and every dialect's `renderThinking` is a real channel that round-trips back through its scanner (no passthrough renderers).
+
+### Changed
+
+- Moved public dialect entrypoint from `@oh-my-pi/pi-ai/grammar` to `@oh-my-pi/pi-ai/dialect` in package exports
+- Updated internal imports in `stream-markup-healing.ts` to use new dialect module path
+- Changed `renderToolInventory` to demote a tool description's own markdown headers by one level when it contains a top-level `# ` header, so they nest under the wrapping `# Tool: <name>` heading instead of reading as sibling sections. Descriptions that already start at `##` and headers inside fenced code blocks are left untouched.
+
+### Fixed
+
+- Fixed Gemini, Gemma, Kimi, and Pi in-band scanners to respect `parseThinking: false`, leaving private reasoning markers in visible text when parsing is disabled
+- Fixed thinking-channel parsing for streaming Gemini, Gemma, Kimi, and Pi outputs so split or partial `<thinking>` blocks no longer leak into visible replies
+- Fixed in-band thinking finalization and Kimi stream-healing interactions so leaked `<think>` blocks are preserved when structured tool calls are present, not duplicated when explicit reasoning is present, and closed on stream flush.
+
+### Removed
+
+- Removed `src/grammar/factory.ts` (replaced by `src/dialect/factory.ts`)
+- Removed `src/grammar/rendering.ts` (functionality moved to `src/dialect/rendering.ts`)
+- Removed `src/grammar/xml.ts` (replaced by `src/dialect/xml.ts`)
+
+## [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 → dialect}/anthropic.d.ts

@@ -1,9 +1,9 @@
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare class AnthropicInbandScanner implements InbandScanner {
     #private;
     constructor(options?: InbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/{grammar → dialect}/catalog.d.ts

@@ -1,3 +1,3 @@
-import type { InbandTool, ToolCallSyntax } from "./types";
+import type { Dialect, InbandTool } from "./types";
 export declare function renderToolCatalog(tools: readonly InbandTool[]): string;
-export declare function renderInbandToolPrompt(tools: readonly InbandTool[], syntax: ToolCallSyntax): string;
+export declare function renderInbandToolPrompt(tools: readonly InbandTool[], dialect: Dialect): string;

package/dist/types/{grammar → dialect}/deepseek.d.ts

@@ -1,4 +1,4 @@
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare const DEEPSEEK_TOOL_CALLS_BEGIN = "<\uFF5Ctool\u2581calls\u2581begin\uFF5C>";
 export declare const DEEPSEEK_TOOL_CALLS_END = "<\uFF5Ctool\u2581calls\u2581end\uFF5C>";
 export declare const DEEPSEEK_TOOL_CALL_BEGIN = "<\uFF5Ctool\u2581call\u2581begin\uFF5C>";
@@ -10,5 +10,5 @@ export declare class DeepSeekInbandScanner implements InbandScanner {
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/dialect/examples.d.ts

@@ -0,0 +1,2 @@
+import type { Dialect, InbandTool } from "./types";
+export declare function renderToolExamples(tool: InbandTool, dialect: Dialect, intentField?: string): string;

package/dist/types/dialect/factory.d.ts

@@ -0,0 +1,3 @@
+import type { Dialect, DialectDefinition, InbandScanner, InbandScannerOptions } from "./types";
+export declare function getDialectDefinition(dialect: Dialect): DialectDefinition;
+export declare function createInbandScanner(dialect: Dialect, options?: InbandScannerOptions): InbandScanner;

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

@@ -0,0 +1,17 @@
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } 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;
+    constructor(options?: InbandScannerOptions);
+    feed(text: string): InbandScanEvent[];
+    flush(): InbandScanEvent[];
+}
+declare const definition: DialectDefinition;
+export default definition;

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

@@ -0,0 +1,15 @@
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } 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;
+    constructor(options?: InbandScannerOptions);
+    feed(text: string): InbandScanEvent[];
+    flush(): InbandScanEvent[];
+}
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/{grammar → dialect}/glm.d.ts

@@ -1,9 +1,9 @@
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare class GLMInbandScanner implements InbandScanner {
     #private;
     constructor(options?: InbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/{grammar → dialect}/harmony.d.ts

@@ -1,8 +1,8 @@
-import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner } from "./types";
 export declare class HarmonyInbandScanner implements InbandScanner {
     #private;
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/{grammar → dialect}/hermes.d.ts

@@ -1,9 +1,9 @@
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare class HermesInbandScanner implements InbandScanner {
     #private;
     constructor(options?: InbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/dialect/history.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "../types";
+import type { Dialect, InbandTool } from "./types";
+export declare function encodeInbandToolHistory(messages: Context["messages"], dialect: Dialect, tools?: readonly InbandTool[]): Context["messages"];

package/dist/types/{grammar → dialect}/inventory.d.ts

@@ -3,10 +3,10 @@ import type { InbandTool } from "./types";
  * Human-readable per-tool inventory: each tool renders as a `# Tool: <name>`
  * section with its description, a simplified TypeScript-style parameter
  * signature (derived from the wire JSON Schema), and examples in the model's
- * native tool-call syntax. Shared by the verbose system-prompt inventory and
+ * native dialect. Shared by the verbose system-prompt inventory and
  * `/dump` so both render the catalog the same way.
  *
- * `model` is a model id; the native example syntax is resolved from it
- * (`preferredToolSyntax`, which falls back to XML for empty/unknown ids).
+ * `model` is a model id; the native example dialect is resolved from it
+ * (`preferredDialect`, which falls back to XML for empty/unknown ids).
  */
 export declare function renderToolInventory(tools: readonly InbandTool[], model: string): string;

package/dist/types/{grammar → dialect}/kimi.d.ts

@@ -1,4 +1,4 @@
-import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare const KIMI_SECTION_BEGIN = "<|tool_calls_section_begin|>";
 export declare const KIMI_SECTION_END = "<|tool_calls_section_end|>";
 export declare const KIMI_CALL_BEGIN = "<|tool_call_begin|>";
@@ -6,8 +6,9 @@ export declare const KIMI_CALL_END = "<|tool_call_end|>";
 export declare const KIMI_ARG_BEGIN = "<|tool_call_argument_begin|>";
 export declare class KimiInbandScanner implements InbandScanner {
     #private;
+    constructor(options?: InbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/dialect/owned-stream.d.ts

@@ -0,0 +1,4 @@
+import type { AssistantMessage, AssistantMessageEventStream as AssistantMessageEventStreamType } from "../types";
+import type { Dialect, InbandTool } from "./types";
+export declare function parseInbandToolMessage(message: AssistantMessage, dialect: Dialect, tools: readonly InbandTool[]): AssistantMessage;
+export declare function wrapInbandToolStream(inner: AssistantMessageEventStreamType, tools: readonly InbandTool[], dialect: Dialect, onAbort?: () => void, abortOnFabrication?: boolean): AssistantMessageEventStreamType;

package/dist/types/{grammar → dialect}/pi.d.ts

@@ -1,9 +1,9 @@
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare class PiNativeInbandScanner implements InbandScanner {
     #private;
     constructor(options?: InbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/{grammar → dialect}/qwen3.d.ts

@@ -1,9 +1,9 @@
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare class Qwen3InbandScanner implements InbandScanner {
     #private;
     constructor(options?: InbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

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

@@ -0,0 +1,45 @@
+import type { AssistantMessage, Message, ToolCall } from "../types";
+import type { DialectRenderOptions, DialectToolResult } from "./types";
+export declare function renderToolResponseResults(results: readonly DialectToolResult[]): string;
+export declare function kimiCallId(name: string, id: string, index: number): string;
+export declare function harmonyRecipient(name: string): string;
+export declare function stringifyJson(value: unknown): string;
+export declare function escapeXmlAttr(value: string): string;
+export declare function escapeXmlText(value: string): string;
+export type AssistantTranscriptParts = {
+    readonly text: string;
+    readonly thinking: string;
+    readonly toolCalls: readonly ToolCall[];
+};
+export type ToolCallRenderer = (calls: readonly ToolCall[], options?: DialectRenderOptions) => string;
+export type ToolResultRenderer = (results: readonly DialectToolResult[], options?: DialectRenderOptions) => string;
+export type ChatMlTranscriptConfig = {
+    readonly bos?: string;
+    readonly toolResultRole: "tool" | "user";
+    readonly renderThinking: (text: string) => string;
+    readonly renderCalls: ToolCallRenderer;
+    readonly renderResultsBody: ToolResultRenderer;
+};
+export type LegacyTextTranscriptConfig = {
+    readonly renderThinking: (text: string) => string;
+    readonly renderCalls: ToolCallRenderer;
+    readonly renderResults: ToolResultRenderer;
+};
+export declare function renderChatMlTranscript(messages: readonly Message[], options: DialectRenderOptions, config: ChatMlTranscriptConfig): string;
+export declare function renderLegacyTextTranscript(messages: readonly Message[], options: DialectRenderOptions, config: LegacyTextTranscriptConfig): string;
+export declare function assistantTranscriptParts(message: AssistantMessage): AssistantTranscriptParts;
+export declare function collectToolResultRun(messages: readonly Message[], start: number): {
+    readonly results: readonly DialectToolResult[];
+    readonly next: number;
+};
+export declare function messageContentText(content: string | readonly {
+    readonly type: string;
+    readonly text?: string;
+    readonly mimeType?: string;
+}[]): string;
+export declare function renderDelimitedThinking(open: string, close: string, text: string): string;
+export declare function chatMlTurn(role: "assistant" | "system" | "tool" | "user", body: string): string;
+export declare function kimiTurn(role: "assistant" | "system" | "user", name: string, body: string): string;
+export declare function gemmaTurn(role: "model" | "system" | "user", body: string): string;
+export declare function geminiTurn(role: "model" | "user", body: string): string;
+export declare function joinUserBodies(left: string, right: string): string;

package/dist/types/{grammar → dialect}/types.d.ts

@@ -1,6 +1,6 @@
-import type { ToolCallSyntax } from "@oh-my-pi/pi-catalog/identity";
-import type { Context, ToolCall } from "../types";
-export type { ToolCallSyntax };
+import type { Dialect as CatalogDialect } from "@oh-my-pi/pi-catalog/identity";
+import type { Context, Message, ToolCall } from "../types";
+export type { Dialect } from "@oh-my-pi/pi-catalog/identity";
 export type InbandScanEvent = {
     type: "text";
     text: string;
@@ -33,35 +33,37 @@ export interface InbandScanner {
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-export interface GrammarToolResult {
+export interface DialectToolResult {
     readonly id: string;
     readonly name: string;
     readonly index: number;
     readonly text: string;
     readonly isError: boolean;
 }
-export interface GrammarRenderOptions {
+export interface DialectRenderOptions {
     readonly tools?: readonly InbandTool[];
     readonly example?: boolean;
 }
-export interface Grammar {
-    readonly syntax: ToolCallSyntax;
+export interface DialectDefinition {
+    readonly dialect: CatalogDialect;
     readonly prompt: string;
     createScanner(options?: InbandScannerOptions): InbandScanner;
     /** Render a single tool-call invocation — the inner element only, WITHOUT any parallel-call block envelope (e.g. anthropic's `<function_calls>` / kimi's section wrapper). */
-    renderToolCall(call: ToolCall, options?: GrammarRenderOptions): string;
-    /** Render a batch of (parallel) tool calls as one complete block, including whatever envelope the syntax wraps multiple calls in. */
-    renderAssistantToolCalls(calls: readonly ToolCall[], options?: GrammarRenderOptions): string;
-    renderToolResults(results: readonly GrammarToolResult[], options?: GrammarRenderOptions): string;
+    renderToolCall(call: ToolCall, options?: DialectRenderOptions): string;
+    /** Render a batch of (parallel) tool calls as one complete block, including whatever envelope the dialect wraps multiple calls in. */
+    renderAssistantToolCalls(calls: readonly ToolCall[], options?: DialectRenderOptions): string;
+    renderToolResults(results: readonly DialectToolResult[], options?: DialectRenderOptions): string;
+    renderThinking(text: string): string;
+    renderTranscript(messages: readonly Message[], options?: DialectRenderOptions): string;
 }
 export interface InbandScannerOptions {
-    /** string-typed arg names for a tool → read verbatim. Ignored by JSON-carrying syntaxes. */
+    /** string-typed arg names for a tool → read verbatim. Ignored by JSON-carrying dialects. */
     stringArgs?: (toolName: string) => ReadonlySet<string>;
-    /** Full tool schemas for schema-driven syntaxes such as GLM XML and pi-native. */
+    /** Full tool schemas for schema-driven dialects such as GLM XML and pi-native. */
     tools?: readonly InbandTool[];
     /** XML only: parse pipe-wrapped DeepSeek DSML tags vs plain Anthropic invoke/parameter tags. */
     xmlTagset?: "anthropic" | "dsml";
-    /** Emit thinking markers as thinking events instead of visible text when the syntax defines them. */
+    /** Emit thinking markers as thinking events instead of visible text when the dialect defines them. */
     parseThinking?: boolean;
 }
 export type InbandTool = NonNullable<Context["tools"]>[number];

package/dist/types/{grammar → dialect}/xml.d.ts

@@ -1,9 +1,9 @@
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
 export declare class XmlInbandScanner implements InbandScanner {
     #private;
     constructor(options?: InbandScannerOptions);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }
-declare const grammar: Grammar;
-export default grammar;
+declare const definition: DialectDefinition;
+export default definition;

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/dist/types/utils/stream-markup-healing.d.ts

@@ -3,7 +3,7 @@
  *
  * Hosted models sometimes leak raw template markup into visible `content` instead
  * of returning structured events. Tool-call healing delegates to the same
- * grammar scanners used by owned in-band tool calling; this file keeps the
+ * dialect scanners used by owned in-band tool calling; this file keeps the
  * provider-facing compatibility wrapper and model/provider gating.
  */
 export interface HealedToolCall {
@@ -47,11 +47,12 @@ export declare class StreamMarkupHealing {
     /** Feed a chunk and return cleaned text/thinking/tool-call events in stream order. */
     feedEvents(text: string): StreamMarkupHealingEvent[];
     /**
-     * Like {@link feed}, but discards completed calls. Used when the upstream
-     * chunk also carries structured `tool_calls`, keeping that structured payload
-     * as the single source of truth.
+     * Feed a chunk and return cleaned events, excluding synthesized tool calls.
+     * Used when the upstream chunk also carries structured `tool_calls`, keeping
+     * that structured payload as the single source of truth while preserving
+     * adjacent text and thinking events.
      */
-    consumeWithoutCalls(text: string): string;
+    feedEventsWithoutCalls(text: string): StreamMarkupHealingEvent[];
     /** Drain accumulated tool calls from calls to {@link feed}. */
     drainCompleted(): HealedToolCall[];
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.13.2",
+	"version": "16.0.0",
 	"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": "16.0.0",
+		"@oh-my-pi/pi-utils": "16.0.0",
 		"partial-json": "^0.1.7",
 		"zod": "^4"
 	},
@@ -96,9 +96,9 @@
 			"types": "./dist/types/utils/harmony-leak.d.ts",
 			"import": "./src/utils/harmony-leak.ts"
 		},
-		"./grammar": {
-			"types": "./dist/types/grammar/index.d.ts",
-			"import": "./src/grammar/index.ts"
+		"./dialect": {
+			"types": "./dist/types/dialect/index.d.ts",
+			"import": "./src/dialect/index.ts"
 		},
 		"./utils/*": {
 			"types": "./dist/types/utils/*.d.ts",

package/src/{grammar → dialect}/anthropic.ts

@@ -1,8 +1,22 @@
+import type { Message, ToolCall } from "../types";
 import { parseJsonWithRepair } from "../utils/json-parse";
-import grammarPrompt from "./anthropic.md" with { type: "text" };
-import { buildStringArgsResolver, mintToolCallId } from "./coercion";
-import { renderAnthropicInvocation, renderAnthropicToolCalls, renderAnthropicToolResults } from "./rendering";
-import type { Grammar, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+import dialectPrompt from "./anthropic.md" with { type: "text" };
+import { buildArgShapes, buildStringArgsResolver, mintToolCallId, type ToolArgShape } from "./coercion";
+import {
+	escapeXmlAttr,
+	escapeXmlText,
+	renderDelimitedThinking,
+	renderLegacyTextTranscript,
+	stringifyJson,
+} from "./rendering";
+import type {
+	DialectDefinition,
+	DialectRenderOptions,
+	DialectToolResult,
+	InbandScanEvent,
+	InbandScanner,
+	InbandScannerOptions,
+} from "./types";
 
 const MAX_PARTIAL_TAG_LENGTH = 256;
 const MAX_PARAMETER_VALUE_LENGTH = 1_000_000;
@@ -509,13 +523,63 @@ function couldBeTagPrefix(buffer: string, prefixes: readonly string[]): boolean
 	return false;
 }
 
-const grammar: Grammar = {
-	syntax: "anthropic",
-	prompt: grammarPrompt,
+function renderToolCall(call: ToolCall, options: DialectRenderOptions = {}): string {
+	return renderInvoke(call, buildArgShapes(options.tools).get(call.name));
+}
+
+function renderAssistantToolCalls(calls: readonly ToolCall[], options: DialectRenderOptions = {}): string {
+	if (calls.length === 0) return "";
+	return `<function_calls>\n${renderInvokes(calls, options.tools ?? [])}\n</function_calls>`;
+}
+
+function renderToolResults(results: readonly DialectToolResult[]): string {
+	const body = results
+		.map(result => {
+			const tag = result.isError ? "error" : "result";
+			const streamTag = result.isError ? "stderr" : "stdout";
+			return `<${tag}>\n<tool_name>${escapeXmlText(result.name)}</tool_name>\n<${streamTag}>${result.text}</${streamTag}>\n</${tag}>`;
+		})
+		.join("\n");
+	return `<function_results>\n${body}\n</function_results>`;
+}
+
+function renderThinking(text: string): string {
+	return renderDelimitedThinking("<thinking>", "</thinking>", text);
+}
+
+function renderTranscript(messages: readonly Message[], options: DialectRenderOptions = {}): string {
+	return renderLegacyTextTranscript(messages, options, {
+		renderThinking,
+		renderCalls: renderAssistantToolCalls,
+		renderResults: renderToolResults,
+	});
+}
+
+function renderInvoke(call: ToolCall, shape: ToolArgShape | undefined): string {
+	let body = `<invoke name="${escapeXmlAttr(call.name)}">`;
+	for (const key in call.arguments) {
+		const value = call.arguments[key];
+		const isString = shape?.stringArgs.has(key) === true;
+		const rendered = isString && typeof value === "string" ? value : stringifyJson(value);
+		body += `<parameter name="${escapeXmlAttr(key)}">${rendered}</parameter>`;
+	}
+	return `${body}</invoke>`;
+}
+
+function renderInvokes(calls: readonly ToolCall[], tools: NonNullable<DialectRenderOptions["tools"]>): string {
+	const shapes = buildArgShapes(tools);
+	return calls.map(call => renderInvoke(call, shapes.get(call.name))).join("\n");
+}
+
+const definition: DialectDefinition = {
+	dialect: "anthropic",
+	prompt: dialectPrompt,
 	createScanner: options => new AnthropicInbandScanner(options),
-	renderToolCall: renderAnthropicInvocation,
-	renderAssistantToolCalls: renderAnthropicToolCalls,
-	renderToolResults: renderAnthropicToolResults,
+	renderToolCall,
+	renderAssistantToolCalls,
+	renderToolResults,
+	renderThinking,
+	renderTranscript,
 };
 
-export default grammar;
+export default definition;

package/src/{grammar → dialect}/catalog.ts

@@ -1,10 +1,10 @@
 import { toolWireSchema } from "../utils/schema";
-import { getInbandGrammar } from "./factory";
+import { getDialectDefinition } from "./factory";
 import promptTemplate from "./prompt-template.md" with { type: "text" };
-import type { InbandTool, ToolCallSyntax } from "./types";
+import type { Dialect, InbandTool } from "./types";
 
 const TOOLS_TOKEN = "{{TOOLS}}";
-const GRAMMAR_TOKEN = "{{GRAMMAR}}";
+const DIALECT_PROMPT_TOKEN = "{{DIALECT}}";
 
 export function renderToolCatalog(tools: readonly InbandTool[]): string {
 	return tools
@@ -21,7 +21,9 @@ export function renderToolCatalog(tools: readonly InbandTool[]): string {
 		.join("\n");
 }
 
-export function renderInbandToolPrompt(tools: readonly InbandTool[], syntax: ToolCallSyntax): string {
-	const prompt = getInbandGrammar(syntax).prompt.trim();
-	return promptTemplate.replace(TOOLS_TOKEN, () => renderToolCatalog(tools)).replace(GRAMMAR_TOKEN, () => prompt);
+export function renderInbandToolPrompt(tools: readonly InbandTool[], dialect: Dialect): string {
+	const prompt = getDialectDefinition(dialect).prompt.trim();
+	return promptTemplate
+		.replace(TOOLS_TOKEN, () => renderToolCatalog(tools))
+		.replace(DIALECT_PROMPT_TOKEN, () => prompt);
 }