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

package/CHANGELOG.md

@@ -2,6 +2,63 @@
 
 ## [Unreleased]
 
+## [16.0.1] - 2026-06-15
+
+### Added
+
+- Added Umans AI Coding Plan API-key login support and `UMANS_AI_CODING_PLAN_API_KEY` environment fallback ([#2636](https://github.com/can1357/oh-my-pi/pull/2636) by [@oldschoola](https://github.com/oldschoola)).
+
+### Fixed
+
+- Fixed OpenAI Responses, Azure OpenAI Responses, and Codex Responses providers ignoring async `onPayload` replacement bodies. Provider payload hooks can now transform the actual request body sent upstream, matching the Anthropic/Gemini replacement contract.
+- Fixed OpenAI-compatible chat-completions streams that send object-shaped tool arguments in fragments by deep-merging nested objects and task arrays instead of replacing earlier chunks. ([#2617](https://github.com/can1357/oh-my-pi/issues/2617))
+- Fixed OpenAI Responses strict-mode tool schema normalization for nullable enum MCP parameters so enum constraints are distributed to matching `anyOf` branches instead of being copied onto the `null` branch. ([#1835](https://github.com/can1357/oh-my-pi/issues/1835))
+- Fixed Cursor provider formatting tool errors with the same `[Tool Result]` prefix as successful results, causing Composer models to misinterpret error messages (e.g. "Pattern must not be empty") as directives over long conversations. Errors now use a `[Tool Error]` prefix so the model can distinguish failures from successes in the prompt history. ([#1853](https://github.com/can1357/oh-my-pi/pull/1853))
+- Fixed `validateToolArguments` silently accepting JSON-encoded array strings (e.g. `'["a","b"]'`) against `union(string, array<string>)` schemas — providers that double-serialize tool-call arguments (Z.AI / GLM) caused tools like `search` to receive the literal `["a","b"]` as a single path, producing zero matches (single element) or glob parse errors (multi-element). A new pre-validation pass parses JSON-array-shaped strings when the schema explicitly accepts both shapes. ([#1788](https://github.com/can1357/oh-my-pi/issues/1788))
+- Fixed Anthropic thinking summaries that arrive wrapped in literal `<thinking>` tags so advisor/raw transcript dumps do not render nested thinking tags ([#2695](https://github.com/can1357/oh-my-pi/issues/2695)).
+
+## [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

package/README.md

@@ -68,6 +68,7 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **Kilo Gateway** (supports OAuth `/login kilo` or `KILO_API_KEY`)
 - **LiteLLM** (requires `LITELLM_API_KEY`)
 - **zAI** (requires `ZAI_API_KEY`)
+- **Umans AI Coding Plan** (supports `/login umans` or `UMANS_AI_CODING_PLAN_API_KEY`)
 - **MiniMax Token Plan** (requires `MINIMAX_CODE_API_KEY` or `MINIMAX_CODE_CN_API_KEY`)
 - **Xiaomi MiMo** (requires `XIAOMI_API_KEY`)
 - **ZenMux** (requires `ZENMUX_API_KEY`)
@@ -952,6 +953,7 @@ In Node.js environments, you can set environment variables to avoid passing API
 | Ollama Cloud   | `OLLAMA_CLOUD_API_KEY`                                                     |
 | Qwen Portal    | `QWEN_OAUTH_TOKEN` or `QWEN_PORTAL_API_KEY`                                  |
 | zAI            | `ZAI_API_KEY`                                                                |
+| Umans AI Coding Plan | `UMANS_AI_CODING_PLAN_API_KEY`                                           |
 | MiniMax Code   | `MINIMAX_CODE_API_KEY` (international) or `MINIMAX_CODE_CN_API_KEY` (China) |
 | Xiaomi MiMo    | `XIAOMI_API_KEY`                                                             |
 | ZenMux         | `ZENMUX_API_KEY`                                                             |
@@ -978,6 +980,7 @@ Provider endpoint defaults for the current OpenAI-compatible integrations:
 - Xiaomi MiMo: `https://api.xiaomimimo.com/anthropic`
 - ZenMux (OpenAI): `https://zenmux.ai/api/v1`
 - ZenMux (Anthropic models): `https://zenmux.ai/api/anthropic`
+- Umans AI Coding Plan: `https://api.code.umans.ai`
 - vLLM: `http://127.0.0.1:8000/v1`
 - Ollama: local OpenAI-compatible runtime (`http://127.0.0.1:11434/v1`)
 - Ollama Cloud: native Ollama API host (`https://ollama.com/api`, configured here as base URL `https://ollama.com`)

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/{grammar → dialect}/gemini.d.ts

@@ -1,4 +1,4 @@
-import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+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 ````
@@ -9,8 +9,9 @@ import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
  */
 export declare class GeminiInbandScanner 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}/gemma.d.ts

@@ -1,4 +1,4 @@
-import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
+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|>`
@@ -7,8 +7,9 @@ import type { Grammar, InbandScanEvent, InbandScanner } from "./types";
  */
 export declare class GemmaInbandScanner 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}/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/registry.d.ts

@@ -208,6 +208,10 @@ declare const ALL: ({
     readonly id: "together";
     readonly name: "Together";
     readonly login: (cb: Parameters<typeof import("./together").loginTogether>[0]) => Promise<string>;
+} | {
+    readonly id: "umans";
+    readonly name: "Umans AI Coding Plan";
+    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "venice";
     readonly name: "Venice";

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

@@ -0,0 +1,7 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+export declare const loginUmans: (options: import("./oauth").OAuthController) => Promise<string>;
+export declare const umansProvider: {
+    readonly id: "umans";
+    readonly name: "Umans AI Coding Plan";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

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.3",
+	"version": "16.0.1",
 	"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.3",
-		"@oh-my-pi/pi-utils": "15.13.3",
+		"@oh-my-pi/pi-catalog": "16.0.1",
+		"@oh-my-pi/pi-utils": "16.0.1",
 		"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);
 }