@oh-my-pi/pi-ai 16.0.9 → 16.0.10

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [16.0.10] - 2026-06-18
+
+### Added
+
+- Replaced the old legacy XML-ish `pi` owned tool-calling dialect with the new sigil-delimited format (`§` call header with inline `key=value` scalars, `«…»` verbatim body fence for the dominant string argument, `¤` reasoning, `‡‡` tool result) using single-token markers that never occur in source code. Verbatim fences escalate Markdown-style (`««…»»`) so re-rendered history never collides with payload content, and the scanner gates a bare `§` on an exact known-tool name to avoid swallowing prose. Round-trips and streams through the existing scanner contract at ~46% fewer tokens than the legacy format on typical calls; selectable via `tools.format` or `PI_DIALECT=pi`.
+
+### Changed
+
+- Updated `pi` dialect formatting to use a token-frugal, sigil-delimited format (`§`, `¤`, `‡‡`)
+- Updated `pi` dialect body fences to automatically escalate when content contains fence markers
+- Changed `pi` dialect tool results response format to `‡‡` blocks
+
+### Fixed
+
+- Fixed Bedrock application inference profile ARNs to route requests to the ARN's region instead of the default Bedrock runtime region. ([#3004](https://github.com/can1357/oh-my-pi/issues/3004))
+
 ## [16.0.9] - 2026-06-18
 
 ### Fixed

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

@@ -25,6 +25,12 @@ export interface OAuthProviderInfo {
     id: OAuthProviderId;
     name: string;
     available: boolean;
+    /**
+     * Provider id the login stores credentials under, when it differs from `id`
+     * (e.g. `openai-codex-device` ⇒ `openai-codex`). Lets callers map a login
+     * entry back to the model provider it authenticates.
+     */
+    storeCredentialsAs?: string;
 }
 export interface OAuthController {
     onAuth?(info: OAuthAuthInfo): void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.0.9",
+	"version": "16.0.10",
 	"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": "16.0.9",
-		"@oh-my-pi/pi-utils": "16.0.9",
+		"@oh-my-pi/pi-catalog": "16.0.10",
+		"@oh-my-pi/pi-utils": "16.0.10",
 		"arktype": "^2.2.0",
 		"partial-json": "^0.1.7",
 		"zod": "^4"

package/src/dialect/owned-stream.ts

@@ -19,7 +19,7 @@ const RESPONSE_OPEN_TOKENS: Record<Dialect, readonly string[]> = {
 	minimax: ["<function_results>", "<tool_response>"],
 	deepseek: ["<｜tool▁outputs▁begin｜>", "<｜tool▁output▁begin｜>"],
 	harmony: ["<|start|>functions."],
-	pi: ["<tool_response>"],
+	pi: ["‡‡"],
 	qwen3: ["<tool_response>"],
 	gemini: ["```tool_outputs"],
 	gemma: ["<|tool_response>"],

package/src/dialect/pi.md

@@ -1,57 +1,55 @@
 ## Format guide
 
-A tool call is a `<call:NAME>…</call:NAME>` block (or self-closing `<call:NAME …/>`) written as plain assistant text; arguments are given as tag attributes, child elements, or a verbatim inline body.
+A tool call begins with `§` immediately followed by the function NAME (start each call on its own line). Scalar arguments follow on the same line as `key=value` pairs; a single large or multi-line string argument goes in a verbatim body fenced by `«…»` right after the header.
 
-```text
-<call:read path="src/a.ts" offset=50/>
-```
-
-Objects and arrays use child elements, repeating an element for each array item:
+Scalar-only call (the line ends the call):
 
 ```text
-<call:configure>
-<object>
-<y>4</y>
-<list>alpha</list>
-<list>beta</list>
-</object>
-</call:configure>
+§read path=src/a.ts offset=50 limit=200
 ```
 
-A single string argument can fill the body directly:
+Call with a verbatim body — everything between `«` and `»` is taken literally, no quoting or escaping:
 
 ```text
-<call:edit>
+§edit path=src/server/auth.ts«
 *** Begin Patch
-...
+*** Update File: src/server/auth.ts
+@@ class AuthService
+-  login(user) {
++  async login(user, opts) {
 *** End Patch
-</call:edit>
+»
 ```
 
-Tool results arrive as response blocks, read in call order:
+Argument values:
+
+- Strings are written bare and verbatim (`path=src/a.ts`). Quote with `"…"` only when the value contains spaces or starts with `"`, `[`, or `{` (`_i="run the tests"`).
+- Numbers, booleans, and `null` are JSON literals (`offset=50`, `force=true`).
+- Arrays and objects are inline JSON (`paths=["src","test"]`).
+- The body fence holds the call's first long/multi-line string parameter; its key is implied, never written.
+
+Private reasoning goes in a `¤…¤` block before your calls:
 
 ```text
-<tool_response>
-verbatim tool result
-</tool_response>
+¤
+brief reasoning
+¤
 ```
 
-Private reasoning goes in a `<thinking>…</thinking>` block before your calls:
+Tool results arrive in `‡‡…‡‡` blocks, read in call order:
 
 ```text
-<thinking>
-brief reasoning
-</thinking>
+‡‡
+verbatim tool result
+‡‡
 ```
 
 ## Rules
 
-- `NAME` must match a listed function; never wrap calls in JSON or fences.
-- Use attributes only for top-level scalars; put objects, arrays, and long strings in child elements.
-- Strings are verbatim (no quotes, no entity escaping); numbers, booleans, and null are JSON literals.
-- An object opens a child block whose scalar subfields may also be attributes; an array repeats its element once per item.
-- The inline body fills the first unset string-typed parameter and may contain any raw text except `</call:NAME>`.
-- Emit parallel calls as consecutive blocks. NEVER invent call ids; results are positional.
-- Private reasoning goes in a `<thinking>…</thinking>` block before your calls; NEVER put calls inside it.
-- Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.
+- `NAME` MUST match a listed function; never wrap calls in JSON or fences.
+- Put each scalar argument once as `key=value`; reserve the `«…»` body for the one dominant string argument (file contents, patches, commands, queries).
+- Body text is verbatim — include no surrounding quotes. If the body itself contains `»`, widen BOTH guillemet fences equally (`««…»»`, `«««…»»»`).
+- Emit parallel calls as consecutive `§…` blocks. NEVER invent call ids; results are positional.
+- Private reasoning goes in a `¤…¤` block before your calls; NEVER put calls inside it, and keep a literal `¤` out of the reasoning text.
+- Read each `‡‡…‡‡` result in call order. NEVER emit a `‡‡` block yourself.
 - After emitting your tool calls, YOU MUST EMIT THE STOP SEQUENCE AND HALT.

package/src/dialect/pi.ts

@@ -1,19 +1,8 @@
 import type { Message, ToolCall } from "../types";
 import type { ToolArgShape } from "./coercion";
-import {
-	buildArgShapes,
-	coerceValue,
-	collectSchemaTypes,
-	getArrayItemSchema,
-	getObjectProperties,
-	isArraySchema,
-	isObjectSchema,
-	isStringOnlySchema,
-	mintToolCallId,
-	partialSuffixOverlapAny,
-} from "./coercion";
+import { buildArgShapes, coerceValue, isStringOnlySchema, mintToolCallId, partialSuffixOverlapAny } from "./coercion";
 import dialectPrompt from "./pi.md" with { type: "text" };
-import { renderChatMlTranscript, renderToolResponseResults, stringifyJson } from "./rendering";
+import { renderChatMlTranscript, stringifyJson } from "./rendering";
 import type {
 	DialectDefinition,
 	DialectRenderOptions,
@@ -23,57 +12,66 @@ import type {
 	InbandScannerOptions,
 } from "./types";
 
-const CALL_PREFIX = "<call:";
-const THINK_OPEN = "<thinking>";
-const THINK_CLOSE = "</thinking>";
-const CALL_TAGS = [CALL_PREFIX] as const;
-const OUTSIDE_TAGS = [CALL_PREFIX, THINK_OPEN] as const;
+// Pi — a sigil-delimited, token-frugal owned dialect.
+//
+//   §read path=src/a.ts offset=50          ← scalar-only call (newline-terminated)
+//   §edit path=src/a.ts«                    ← header + verbatim body fence
+//   *** Begin Patch
+//   ...
+//   *** End Patch»
+//
+// Design goals vs the XML-ish `pi` dialect:
+//   - one-token structural sigils (`§` call, `«»` body fence, `¤` thinking, `‡‡`
+//     tool result — each a single o200k token that never occurs in source code)
+//     instead of `<call:NAME>` / `</call:NAME>` (3 tokens + the repeated name);
+//   - scalar arguments inline as `key=value` (the key appears once) rather than
+//     `<key>value</key>` (key twice + four bracket tokens);
+//   - the dominant string argument fills a verbatim body fence, dropping its key
+//     entirely and needing no escaping for code/patches.
+//
+// Verbatim fences (body `«»`, result `‡‡`) escalate Markdown/raw-string style:
+// when the content contains the closer, the renderer widens the fence (`««…»»`,
+// `‡‡‡…‡‡‡`) so re-rendered history can never collide with payload content.
+
+const CALL_SIGIL = "§";
+const FENCE_OPEN = "«";
+const FENCE_CLOSE = "»";
+const THINK_SIGIL = "¤";
+const RESULT_FENCE = "‡";
+const OUTSIDE_TAGS = [CALL_SIGIL, THINK_SIGIL] as const;
+const CALL_TAGS = [CALL_SIGIL] as const;
 const NAME_START = /[A-Za-z_]/;
 const NAME_CHAR = /[A-Za-z0-9_-]/;
 const EMPTY_STRING_ARGS: ReadonlySet<string> = new Set<string>();
 
 type ScannerState = "outside" | "body" | "thinking";
-type BodyMode = "undecided" | "inline" | "members";
 
-type RawAttribute = { name: string; value: string | true };
-
-type OpenTag = {
-	name: string;
-	rawAttrs: RawAttribute[];
-	selfClosing: boolean;
-	end: number;
-};
-
-type MembersResult = {
-	ok: boolean;
-	value: Record<string, unknown>;
-	next: number;
-};
-
-type ValueResult = {
-	ok: boolean;
-	value: unknown;
-	next: number;
-};
+type HeaderEnd =
+	| { kind: "fence"; index: number }
+	| { kind: "newline"; index: number }
+	| { kind: "eof"; index: number }
+	| { kind: "incomplete" };
 
 export class PiNativeInbandScanner implements InbandScanner {
 	#buffer = "";
 	#state: ScannerState = "outside";
-	#bodyMode: BodyMode = "undecided";
 	#id = "";
 	#name = "";
 	#args: Record<string, unknown> = {};
-	#inlineKey = "";
-	#inlineValue = "";
-	#inlineLeading = false;
+	#bodyKey = "";
+	#bodyValue = "";
+	#bodyLeading = false;
+	#closeMarker = "";
 	#rawBlock = "";
+	#thinking = "";
 	readonly #argShapes: Map<string, ToolArgShape>;
 	readonly #stringArgs: (toolName: string) => ReadonlySet<string>;
-	#thinking = "";
+	readonly #knowsTools: boolean;
 	readonly #parseThinking: boolean;
 
 	constructor(options: InbandScannerOptions = {}) {
 		this.#argShapes = buildArgShapes(options.tools);
+		this.#knowsTools = this.#argShapes.size > 0;
 		this.#stringArgs =
 			options.stringArgs ?? (toolName => this.#argShapes.get(toolName)?.stringArgs ?? EMPTY_STRING_ARGS);
 		this.#parseThinking = options.parseThinking !== false;
@@ -96,37 +94,19 @@ export class PiNativeInbandScanner implements InbandScanner {
 				if (!this.#consumeOutside(events, final)) break;
 				continue;
 			}
-
 			if (this.#state === "thinking") {
 				if (!this.#consumeThinking(events, final)) break;
 				continue;
 			}
-
-			if (this.#bodyMode === "undecided") {
-				const mode = this.#classifyBody(final);
-				if (!mode) break;
-				this.#bodyMode = mode;
-				if (mode === "inline") {
-					this.#inlineKey = this.#inlineTargetKey() ?? "input";
-					this.#inlineValue = "";
-					this.#inlineLeading = true;
-				}
-			}
-
-			if (this.#bodyMode === "inline") {
-				if (!this.#consumeInline(events, final)) break;
-				continue;
-			}
-
-			if (!this.#consumeMembers(events, final)) break;
+			if (!this.#consumeBody(events, final)) break;
 		}
 		if (final && this.#state === "thinking") this.#endThinking(events);
 		return events;
 	}
 
 	#consumeOutside(events: InbandScanEvent[], final: boolean): boolean {
-		const call = this.#buffer.indexOf(CALL_PREFIX);
-		const think = this.#parseThinking ? this.#buffer.indexOf(THINK_OPEN) : -1;
+		const call = this.#buffer.indexOf(CALL_SIGIL);
+		const think = this.#parseThinking ? this.#buffer.indexOf(THINK_SIGIL) : -1;
 		let start = call;
 		let isThink = false;
 		if (think !== -1 && (start === -1 || think < start)) {
@@ -148,124 +128,109 @@ export class PiNativeInbandScanner implements InbandScanner {
 		}
 
 		if (isThink) {
-			this.#buffer = this.#buffer.slice(THINK_OPEN.length);
+			this.#buffer = this.#buffer.slice(THINK_SIGIL.length);
 			this.#thinking = "";
 			events.push({ type: "thinkingStart" });
 			this.#state = "thinking";
 			return true;
 		}
 
-		const tagEnd = findTagEnd(this.#buffer, 0);
-		if (tagEnd === -1) {
-			if (final) this.#buffer = "";
-			return false;
+		return this.#beginCall(events, final);
+	}
+
+	// Buffer starts with `§`. Resolve the tool name, then the header terminator.
+	// Returns false to wait for more input (call still streaming in).
+	#beginCall(events: InbandScanEvent[], final: boolean): boolean {
+		const nameStart = CALL_SIGIL.length;
+		if (nameStart >= this.#buffer.length && !final) return false; // just `§` so far
+		let nameEnd = nameStart;
+		if (!isNameStart(this.#buffer[nameEnd])) return this.#rejectSigil(events);
+		nameEnd++;
+		while (nameEnd < this.#buffer.length && isNameChar(this.#buffer[nameEnd])) nameEnd++;
+		if (nameEnd >= this.#buffer.length && !final) return false; // name may continue
+
+		const name = this.#buffer.slice(CALL_SIGIL.length, nameEnd);
+		// Guard against `§` in prose: only claim a known tool when schemas exist.
+		if (this.#knowsTools && !this.#argShapes.has(name)) return this.#rejectSigil(events);
+
+		const header = findHeaderEnd(this.#buffer, nameEnd);
+		if (header.kind === "fence") {
+			let runEnd = header.index;
+			while (runEnd < this.#buffer.length && this.#buffer[runEnd] === FENCE_OPEN) runEnd++;
+			if (runEnd >= this.#buffer.length && !final) return false; // fence run may grow
+			return this.#startCall(events, name, nameEnd, header.index, "fence", runEnd - header.index);
 		}
-
-		const tag = parseCallOpenTag(this.#buffer);
-		if (!tag) {
-			events.push({ type: "text", text: this.#buffer[0] ?? "" });
-			this.#buffer = this.#buffer.slice(1);
-			return true;
+		if (header.kind === "newline") {
+			return this.#startCall(events, name, nameEnd, header.index, "newline", 0);
 		}
-
-		this.#beginCall(tag, events);
-		this.#buffer = this.#buffer.slice(tag.end);
-		if (tag.selfClosing) {
-			events.push({
-				type: "toolEnd",
-				id: this.#id,
-				name: this.#name,
-				arguments: this.#args,
-				rawBlock: this.#rawBlock,
-			});
-			this.#reset();
-			return true;
-		}
-
-		this.#state = "body";
-		this.#bodyMode = "undecided";
-		return true;
+		// "eof"/"incomplete": the header may still be streaming in — only a scalar
+		// call with no trailing newline at true end-of-stream finalizes here.
+		if (!final) return false;
+		return this.#startCall(events, name, nameEnd, this.#buffer.length, "eof", 0);
 	}
 
-	#consumeThinking(events: InbandScanEvent[], final: boolean): boolean {
-		const close = this.#buffer.indexOf(THINK_CLOSE);
-		if (close === -1) {
-			const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, [THINK_CLOSE]);
-			this.#emitThinking(this.#buffer.slice(0, this.#buffer.length - hold), events);
-			this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
-			if (final) {
-				this.#endThinking(events);
-				this.#state = "outside";
-			}
-			return false;
-		}
-		this.#emitThinking(this.#buffer.slice(0, close), events);
-		this.#buffer = this.#buffer.slice(close + THINK_CLOSE.length);
-		this.#endThinking(events);
-		this.#state = "outside";
+	// `§` not followed by a known tool name is prose — surface it as literal text.
+	#rejectSigil(events: InbandScanEvent[]): boolean {
+		events.push({ type: "text", text: CALL_SIGIL });
+		this.#buffer = this.#buffer.slice(CALL_SIGIL.length);
 		return true;
 	}
 
-	#emitThinking(delta: string, events: InbandScanEvent[]): void {
-		if (delta.length === 0) return;
-		this.#thinking += delta;
-		events.push({ type: "thinkingDelta", delta });
-	}
-
-	#endThinking(events: InbandScanEvent[]): void {
-		events.push({ type: "thinkingEnd", thinking: this.#thinking });
-		this.#thinking = "";
-		this.#state = "outside";
-	}
-
-	#beginCall(tag: OpenTag, events: InbandScanEvent[]): void {
+	#startCall(
+		events: InbandScanEvent[],
+		name: string,
+		argsStart: number,
+		headerEnd: number,
+		kind: "fence" | "newline" | "eof",
+		fenceLen: number,
+	): boolean {
+		const shape = this.#argShapes.get(name);
 		this.#id = mintToolCallId();
-		this.#name = tag.name;
-		this.#args = coerceAttributes(tag.rawAttrs, this.#shape()?.properties ?? {});
-		this.#inlineKey = "";
-		this.#inlineValue = "";
-		this.#inlineLeading = false;
-		this.#rawBlock = this.#buffer.slice(0, tag.end);
+		this.#name = name;
+		this.#args = parseHeaderArgs(this.#buffer.slice(argsStart, headerEnd), shape?.properties ?? {});
 		events.push({ type: "toolStart", id: this.#id, name: this.#name });
-	}
 
-	#classifyBody(final: boolean): BodyMode | undefined {
-		const closeTag = this.#closeTag();
-		const first = skipWhitespace(this.#buffer, 0);
-		const close = this.#buffer.indexOf(closeTag);
-		const inlineKey = this.#inlineTargetKey();
-
-		if (close !== -1 && first >= close) return inlineKey ? "inline" : "members";
-		if (first >= this.#buffer.length) return undefined;
-
-		const fromFirst = this.#buffer.slice(first);
-		if (!final && closeTag.startsWith(fromFirst)) return undefined;
-
-		if (this.#buffer[first] !== "<") return inlineKey ? "inline" : "members";
-		if (this.#buffer.startsWith(closeTag, first)) return inlineKey ? "inline" : "members";
-		if (this.#buffer.startsWith("</", first)) return "members";
-
-		const elementName = readElementNamePrefix(this.#buffer, first);
-		if (elementName === undefined) return final ? (inlineKey ? "inline" : "members") : undefined;
-		if (elementName.length === 0) return inlineKey ? "inline" : "members";
+		if (kind === "fence") {
+			const fenceEnd = headerEnd + fenceLen;
+			this.#rawBlock = this.#buffer.slice(0, fenceEnd);
+			this.#closeMarker = FENCE_CLOSE.repeat(fenceLen);
+			this.#bodyKey = this.#inlineTargetKey() ?? "input";
+			this.#bodyValue = "";
+			this.#bodyLeading = true;
+			this.#buffer = this.#buffer.slice(fenceEnd);
+			this.#state = "body";
+			return true;
+		}
 
-		const shape = this.#shape();
-		if (!shape) return "members";
-		return Object.hasOwn(shape.properties, elementName) ? "members" : inlineKey ? "inline" : "members";
+		this.#rawBlock = this.#buffer.slice(0, headerEnd);
+		events.push({
+			type: "toolEnd",
+			id: this.#id,
+			name: this.#name,
+			arguments: this.#args,
+			rawBlock: this.#rawBlock,
+		});
+		let next = headerEnd;
+		if (kind === "newline") {
+			if (this.#buffer[next] === "\r") next++;
+			if (this.#buffer[next] === "\n") next++;
+		}
+		this.#buffer = this.#buffer.slice(next);
+		this.#reset();
+		return true;
 	}
 
-	#consumeInline(events: InbandScanEvent[], final: boolean): boolean {
-		this.#stripInlineLeadingDelimiter(final);
-		const closeTag = this.#closeTag();
-		const close = this.#buffer.indexOf(closeTag);
+	#consumeBody(events: InbandScanEvent[], final: boolean): boolean {
+		this.#stripBodyLeading(final);
+		const close = this.#buffer.indexOf(this.#closeMarker);
 		if (close === -1) {
 			if (final) {
 				this.#reset();
 				this.#buffer = "";
 				return false;
 			}
-			const overlap = partialSuffixOverlapAny(this.#buffer, [closeTag]);
-			let hold = Math.max(1, overlap);
+			const overlap = partialSuffixOverlapAny(this.#buffer, [this.#closeMarker]);
+			let hold = Math.max(this.#closeMarker.length, overlap);
 			if (overlap > 0) {
 				const beforeOverlap = this.#buffer.length - overlap - 1;
 				if (this.#buffer[beforeOverlap] === "\n") {
@@ -277,67 +242,33 @@ export class PiNativeInbandScanner implements InbandScanner {
 			if (emitLength > 0) {
 				const delta = this.#buffer.slice(0, emitLength);
 				this.#rawBlock += delta;
-				this.#emitInlineDelta(delta, events);
+				this.#emitBodyDelta(delta, events);
 				this.#buffer = this.#buffer.slice(emitLength);
 			}
 			return false;
 		}
 
 		const rawDelta = this.#buffer.slice(0, close);
-		this.#rawBlock += rawDelta + closeTag;
+		this.#rawBlock += rawDelta + this.#closeMarker;
 		let delta = rawDelta;
 		if (delta.endsWith("\r\n")) delta = delta.slice(0, -2);
 		else if (delta.endsWith("\n")) delta = delta.slice(0, -1);
-		this.#emitInlineDelta(delta, events);
-		this.#args[this.#inlineKey] = this.#inlineValue;
-		events.push({ type: "toolEnd", id: this.#id, name: this.#name, arguments: this.#args, rawBlock: this.#rawBlock });
-		this.#buffer = this.#buffer.slice(close + closeTag.length);
+		this.#emitBodyDelta(delta, events);
+		this.#args[this.#bodyKey] = this.#bodyValue;
+		events.push({
+			type: "toolEnd",
+			id: this.#id,
+			name: this.#name,
+			arguments: this.#args,
+			rawBlock: this.#rawBlock,
+		});
+		this.#buffer = this.#buffer.slice(close + this.#closeMarker.length);
 		this.#reset();
 		return true;
 	}
 
-	#consumeMembers(events: InbandScanEvent[], final: boolean): boolean {
-		const closeTag = this.#closeTag();
-		let searchFrom = 0;
-		while (true) {
-			const close = this.#buffer.indexOf(closeTag, searchFrom);
-			if (close === -1) {
-				if (final) {
-					this.#reset();
-					this.#buffer = "";
-				}
-				return false;
-			}
-
-			const body = this.#buffer.slice(0, close);
-			const parsed = parseMembers(body, 0, undefined, this.#shape()?.properties ?? {});
-			if (!parsed.ok || skipWhitespace(body, parsed.next) !== body.length) {
-				searchFrom = close + closeTag.length;
-				continue;
-			}
-
-			const bodyArgs = parsed.value;
-			const args = { ...this.#args, ...bodyArgs };
-			this.#rawBlock += body + closeTag;
-			this.#emitCompletedStringDeltas(bodyArgs, events);
-			events.push({ type: "toolEnd", id: this.#id, name: this.#name, arguments: args, rawBlock: this.#rawBlock });
-			this.#buffer = this.#buffer.slice(close + closeTag.length);
-			this.#reset();
-			return true;
-		}
-	}
-
-	#emitCompletedStringDeltas(args: Record<string, unknown>, events: InbandScanEvent[]): void {
-		for (const key in args) {
-			const value = args[key];
-			if (typeof value === "string" && value.length > 0) {
-				events.push({ type: "toolArgDelta", id: this.#id, name: this.#name, key, delta: value });
-			}
-		}
-	}
-
-	#stripInlineLeadingDelimiter(final: boolean): void {
-		if (!this.#inlineLeading) return;
+	#stripBodyLeading(final: boolean): void {
+		if (!this.#bodyLeading) return;
 		if (this.#buffer.length === 0) return;
 		if (this.#buffer[0] === "\r") {
 			if (this.#buffer.length === 1 && !final) return;
@@ -345,24 +276,55 @@ export class PiNativeInbandScanner implements InbandScanner {
 				this.#rawBlock += this.#buffer.slice(0, 2);
 				this.#buffer = this.#buffer.slice(2);
 			}
-			this.#inlineLeading = false;
+			this.#bodyLeading = false;
 			return;
 		}
 		if (this.#buffer[0] === "\n") {
 			this.#rawBlock += this.#buffer[0];
 			this.#buffer = this.#buffer.slice(1);
 		}
-		this.#inlineLeading = false;
+		this.#bodyLeading = false;
+	}
+
+	#emitBodyDelta(delta: string, events: InbandScanEvent[]): void {
+		if (delta.length === 0) return;
+		this.#bodyValue += delta;
+		events.push({ type: "toolArgDelta", id: this.#id, name: this.#name, key: this.#bodyKey, delta });
+	}
+
+	#consumeThinking(events: InbandScanEvent[], final: boolean): boolean {
+		const close = this.#buffer.indexOf(THINK_SIGIL);
+		if (close === -1) {
+			const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, [THINK_SIGIL]);
+			this.#emitThinking(this.#buffer.slice(0, this.#buffer.length - hold), events);
+			this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+			if (final) {
+				this.#endThinking(events);
+				this.#state = "outside";
+			}
+			return false;
+		}
+		this.#emitThinking(this.#buffer.slice(0, close), events);
+		this.#buffer = this.#buffer.slice(close + THINK_SIGIL.length);
+		this.#endThinking(events);
+		this.#state = "outside";
+		return true;
 	}
 
-	#emitInlineDelta(delta: string, events: InbandScanEvent[]): void {
+	#emitThinking(delta: string, events: InbandScanEvent[]): void {
 		if (delta.length === 0) return;
-		this.#inlineValue += delta;
-		events.push({ type: "toolArgDelta", id: this.#id, name: this.#name, key: this.#inlineKey, delta });
+		this.#thinking += delta;
+		events.push({ type: "thinkingDelta", delta });
+	}
+
+	#endThinking(events: InbandScanEvent[]): void {
+		events.push({ type: "thinkingEnd", thinking: this.#thinking });
+		this.#thinking = "";
+		this.#state = "outside";
 	}
 
 	#inlineTargetKey(): string | undefined {
-		const shape = this.#shape();
+		const shape = this.#argShapes.get(this.#name);
 		if (shape) {
 			for (const key of shape.parameterOrder) {
 				if (Object.hasOwn(this.#args, key)) continue;
@@ -370,258 +332,149 @@ export class PiNativeInbandScanner implements InbandScanner {
 			}
 			return undefined;
 		}
-
 		for (const key of this.#stringArgs(this.#name)) {
 			if (!Object.hasOwn(this.#args, key)) return key;
 		}
 		return "input";
 	}
 
-	#shape(): ToolArgShape | undefined {
-		return this.#argShapes.get(this.#name);
-	}
-
-	#closeTag(): string {
-		return `</call:${this.#name}>`;
-	}
-
 	#reset(): void {
 		this.#state = "outside";
-		this.#bodyMode = "undecided";
 		this.#id = "";
 		this.#name = "";
 		this.#args = {};
-		this.#inlineKey = "";
-		this.#inlineValue = "";
-		this.#inlineLeading = false;
+		this.#bodyKey = "";
+		this.#bodyValue = "";
+		this.#bodyLeading = false;
+		this.#closeMarker = "";
 		this.#rawBlock = "";
 	}
 }
 
-function parseMembers(
-	text: string,
-	position: number,
-	endTag: string | undefined,
-	properties: Record<string, unknown>,
-): MembersResult {
-	const value: Record<string, unknown> = {};
-	let index = position;
+function parseHeaderArgs(text: string, properties: Record<string, unknown>): Record<string, unknown> {
+	const args: Record<string, unknown> = {};
+	let index = skipWhitespace(text, 0);
 	while (index < text.length) {
-		index = skipWhitespace(text, index);
-		if (endTag && text.startsWith(endTag, index)) return { ok: true, value, next: index + endTag.length };
-		if (index >= text.length) break;
-		if (text[index] !== "<" || text.startsWith("</", index) || text.startsWith(CALL_PREFIX, index)) {
-			return { ok: false, value, next: index };
-		}
-
-		const tag = parseElementOpenTag(text, index);
-		if (!tag) return { ok: false, value, next: index };
-		const propertySchema = properties[tag.name];
-		const schemaArray = isArraySchema(propertySchema);
-		const itemSchema = schemaArray ? getArrayItemSchema(propertySchema) : propertySchema;
-		const parsed = parseElementValue(text, tag, itemSchema);
-		if (!parsed.ok) return { ok: false, value, next: index };
-		addMember(value, tag.name, parsed.value, schemaArray);
-		index = parsed.next;
-	}
-
-	return endTag ? { ok: false, value, next: index } : { ok: true, value, next: index };
-}
-
-function parseElementValue(text: string, tag: OpenTag, schema: unknown): ValueResult {
-	const attrProperties = getObjectProperties(schema);
-	const attrs = coerceAttributes(tag.rawAttrs, attrProperties);
-	if (tag.selfClosing) {
-		if (isObjectSchema(schema) || tag.rawAttrs.length > 0) return { ok: true, value: attrs, next: tag.end };
-		return { ok: true, value: coerceValue("", schema), next: tag.end };
-	}
-
-	const bodyStart = tag.end;
-	const closeTag = `</${tag.name}>`;
-	if (shouldParseObjectBody(text, bodyStart, closeTag, schema, tag.rawAttrs.length > 0)) {
-		const parsed = parseMembers(text, bodyStart, closeTag, attrProperties);
-		if (!parsed.ok) return { ok: false, value: undefined, next: bodyStart };
-		return { ok: true, value: { ...attrs, ...parsed.value }, next: parsed.next };
-	}
-
-	const close = text.indexOf(closeTag, bodyStart);
-	if (close === -1) return { ok: false, value: undefined, next: bodyStart };
-	const raw = stripBlockDelimiters(text.slice(bodyStart, close));
-	return { ok: true, value: coerceValue(raw, schema), next: close + closeTag.length };
-}
-
-function shouldParseObjectBody(
-	text: string,
-	bodyStart: number,
-	closeTag: string,
-	schema: unknown,
-	hasAttrs: boolean,
-): boolean {
-	if (isObjectSchema(schema)) return true;
-	if (isTypedScalarSchema(schema)) return false;
-	if (hasAttrs) return true;
-	const first = skipWhitespace(text, bodyStart);
-	if (text.startsWith(closeTag, first)) return false;
-	return text[first] === "<" && !text.startsWith("</", first) && !text.startsWith(CALL_PREFIX, first);
-}
-
-function isTypedScalarSchema(schema: unknown): boolean {
-	const types = collectSchemaTypes(schema);
-	if (types.size === 0) return false;
-	return !types.has("object") && !types.has("array");
-}
-
-function addMember(target: Record<string, unknown>, key: string, value: unknown, schemaArray: boolean): void {
-	if (schemaArray) {
-		const existing = target[key];
-		if (Array.isArray(existing)) existing.push(value);
-		else target[key] = [value];
-		return;
-	}
-
-	if (!Object.hasOwn(target, key)) {
-		target[key] = value;
-		return;
-	}
-
-	const existing = target[key];
-	if (Array.isArray(existing)) existing.push(value);
-	else target[key] = [existing, value];
-}
-
-function coerceAttributes(
-	rawAttrs: readonly RawAttribute[],
-	properties: Record<string, unknown>,
-): Record<string, unknown> {
-	const attrs: Record<string, unknown> = {};
-	for (const attr of rawAttrs) {
-		attrs[attr.name] = attr.value === true ? true : coerceValue(attr.value, properties[attr.name]);
-	}
-	return attrs;
-}
-
-function parseCallOpenTag(text: string): OpenTag | undefined {
-	if (!text.startsWith(CALL_PREFIX)) return undefined;
-	const tagEnd = findTagEnd(text, 0);
-	if (tagEnd === -1) return undefined;
-	return parseOpenTagContent(text, CALL_PREFIX.length, tagEnd);
-}
-
-function parseElementOpenTag(text: string, start: number): OpenTag | undefined {
-	if (text[start] !== "<" || text.startsWith("</", start) || text.startsWith(CALL_PREFIX, start)) return undefined;
-	const tagEnd = findTagEnd(text, start);
-	if (tagEnd === -1) return undefined;
-	return parseOpenTagContent(text, start + 1, tagEnd);
-}
-
-function parseOpenTagContent(text: string, contentStart: number, tagEnd: number): OpenTag | undefined {
-	let contentEnd = tagEnd;
-	let cursor = skipWhitespace(text, contentStart);
-	const nameStart = cursor;
-	if (!isNameStart(text[cursor])) return undefined;
-	cursor++;
-	while (cursor < contentEnd && isNameChar(text[cursor])) cursor++;
-	const name = text.slice(nameStart, cursor);
-
-	let selfClosing = false;
-	let last = contentEnd - 1;
-	while (last >= cursor && isWhitespace(text[last])) last--;
-	if (text[last] === "/") {
-		selfClosing = true;
-		contentEnd = last;
-	}
-
-	return {
-		name,
-		rawAttrs: parseRawAttributes(text.slice(cursor, contentEnd)),
-		selfClosing,
-		end: tagEnd + 1,
-	};
-}
-
-function parseRawAttributes(text: string): RawAttribute[] {
-	const attrs: RawAttribute[] = [];
-	let index = 0;
-	while (index < text.length) {
-		index = skipWhitespace(text, index);
-		if (index >= text.length) break;
 		if (!isNameStart(text[index])) {
 			index++;
 			continue;
 		}
-
 		const nameStart = index;
 		index++;
 		while (index < text.length && isNameChar(text[index])) index++;
-		const name = text.slice(nameStart, index);
+		const key = text.slice(nameStart, index);
 		index = skipWhitespace(text, index);
 		if (text[index] !== "=") {
-			attrs.push({ name, value: true });
+			args[key] = true;
 			continue;
 		}
+		index = skipWhitespace(text, index + 1);
+		const parsed = readInlineValue(text, index, properties[key]);
+		args[key] = parsed.value;
+		index = skipWhitespace(text, parsed.next);
+	}
+	return args;
+}
 
-		index++;
-		index = skipWhitespace(text, index);
-		if (index >= text.length) {
-			attrs.push({ name, value: "" });
-			break;
-		}
+type InlineValue = { value: unknown; next: number };
 
-		const quote = text[index];
-		if (quote === '"' || quote === "'") {
-			const valueStart = ++index;
-			while (index < text.length && text[index] !== quote) index++;
-			attrs.push({ name, value: text.slice(valueStart, index) });
-			if (index < text.length) index++;
-			continue;
+function readInlineValue(text: string, start: number, schema: unknown): InlineValue {
+	const ch = text[start];
+	if (ch === '"') {
+		let index = start + 1;
+		while (index < text.length) {
+			const c = text[index];
+			if (c === "\\") {
+				index += 2;
+				continue;
+			}
+			if (c === '"') {
+				index++;
+				break;
+			}
+			index++;
+		}
+		const raw = text.slice(start, index);
+		try {
+			return { value: JSON.parse(raw) as unknown, next: index };
+		} catch {
+			return { value: raw.slice(1, raw.endsWith('"') ? -1 : undefined), next: index };
 		}
-
-		const valueStart = index;
-		while (index < text.length && !isWhitespace(text[index])) index++;
-		attrs.push({ name, value: text.slice(valueStart, index) });
 	}
-	return attrs;
-}
-
-function readElementNamePrefix(text: string, ltIndex: number): string | undefined {
-	let index = ltIndex + 1;
-	if (index >= text.length) return undefined;
-	if (!isNameStart(text[index])) return "";
-	const start = index;
-	index++;
-	while (index < text.length && isNameChar(text[index])) index++;
-	if (index >= text.length) return undefined;
-	const next = text[index];
-	return isWhitespace(next) || next === "/" || next === ">" ? text.slice(start, index) : "";
+	if (ch === "[" || ch === "{") {
+		const end = matchBracket(text, start);
+		const raw = text.slice(start, end);
+		try {
+			return { value: JSON.parse(raw) as unknown, next: end };
+		} catch {
+			return { value: raw, next: end };
+		}
+	}
+	let index = start;
+	while (index < text.length && !isWhitespace(text[index])) index++;
+	return { value: coerceValue(text.slice(start, index), schema), next: index };
 }
 
-function findTagEnd(text: string, start: number): number {
-	let quote = "";
+function matchBracket(text: string, start: number): number {
+	let depth = 0;
+	let inString = false;
 	for (let index = start; index < text.length; index++) {
 		const ch = text[index];
-		if (quote) {
-			if (ch === quote) quote = "";
+		if (inString) {
+			if (ch === "\\") {
+				index++;
+				continue;
+			}
+			if (ch === '"') inString = false;
 			continue;
 		}
-		if (ch === '"' || ch === "'") {
-			quote = ch;
+		if (ch === '"') {
+			inString = true;
 			continue;
 		}
-		if (ch === ">") return index;
+		if (ch === "[" || ch === "{") depth++;
+		else if (ch === "]" || ch === "}") {
+			depth--;
+			if (depth === 0) return index + 1;
+		}
 	}
-	return -1;
+	return text.length;
 }
 
-function stripBlockDelimiters(raw: string): string {
-	let start = 0;
-	let end = raw.length;
-	if (raw.startsWith("\r\n")) start = 2;
-	else if (raw.startsWith("\n")) start = 1;
-	if (end > start) {
-		if (raw.endsWith("\r\n")) end -= 2;
-		else if (raw.endsWith("\n")) end -= 1;
+// Locate where a call header ends: the first top-level body fence, the first
+// literal newline (scalar-only call), end-of-input, or "incomplete" when a
+// quoted/bracketed value is still mid-stream.
+function findHeaderEnd(text: string, start: number): HeaderEnd {
+	let inString = false;
+	let depth = 0;
+	for (let index = start; index < text.length; index++) {
+		const ch = text[index];
+		if (inString) {
+			if (ch === "\\") {
+				index++;
+				continue;
+			}
+			if (ch === '"') inString = false;
+			continue;
+		}
+		if (ch === '"') {
+			inString = true;
+			continue;
+		}
+		if (ch === "[" || ch === "{") {
+			depth++;
+			continue;
+		}
+		if (ch === "]" || ch === "}") {
+			if (depth > 0) depth--;
+			continue;
+		}
+		if (depth > 0) continue;
+		if (ch === FENCE_OPEN) return { kind: "fence", index };
+		if (ch === "\n" || ch === "\r") return { kind: "newline", index };
 	}
-	return raw.slice(start, end);
+	if (inString || depth > 0) return { kind: "incomplete" };
+	return { kind: "eof", index: text.length };
 }
 
 function skipWhitespace(text: string, index: number): number {
@@ -645,26 +498,83 @@ function renderToolCall(call: ToolCall, options: DialectRenderOptions = {}): str
 	return renderInvocation(call, buildArgShapes(options.tools).get(call.name));
 }
 
+function renderAssistantToolCalls(calls: readonly ToolCall[], options: DialectRenderOptions = {}): string {
+	const shapes = buildArgShapes(options.tools);
+	return calls.map(call => renderInvocation(call, shapes.get(call.name))).join("\n");
+}
+
 function renderInvocation(call: ToolCall, shape: ToolArgShape | undefined): string {
-	let body = `<call:${call.name}>`;
+	const properties = shape?.properties ?? {};
+	const bodyKey = selectBodyKey(call.arguments, shape);
+	let header = `${CALL_SIGIL}${call.name}`;
 	for (const key in call.arguments) {
-		body += `\n${renderElement(key, call.arguments[key], shape?.properties[key])}`;
+		if (key === bodyKey) continue;
+		header += ` ${key}=${renderInlineValue(call.arguments[key], properties[key])}`;
 	}
-	return `${body}\n</call:${call.name}>`;
+	if (bodyKey === undefined) return header;
+	const body = String(call.arguments[bodyKey]);
+	const fence = 1 + maxRun(body, FENCE_CLOSE);
+	return `${header}${FENCE_OPEN.repeat(fence)}\n${body}\n${FENCE_CLOSE.repeat(fence)}`;
 }
 
-function renderAssistantToolCalls(calls: readonly ToolCall[], options: DialectRenderOptions = {}): string {
-	const shapes = buildArgShapes(options.tools);
-	return calls.map(call => renderInvocation(call, shapes.get(call.name))).join("\n");
+// The body holds a single dominant string argument: the first string-only
+// parameter whose value contains a newline. Single-line strings stay inline
+// (quoted when needed) so the verbatim fence is reserved for genuine blocks.
+function selectBodyKey(args: Record<string, unknown>, shape: ToolArgShape | undefined): string | undefined {
+	// Round-trip requires renderer and scanner to agree on the omitted body key.
+	// The scanner assigns the body to the first string-only parameter missing from
+	// the header, so a body is only safe when no earlier parameter is also absent
+	// (no schema → keep everything inline).
+	if (!shape) return undefined;
+	for (const key of shape.parameterOrder) {
+		if (!Object.hasOwn(args, key)) return undefined;
+		const value = args[key];
+		if (typeof value === "string" && value.includes("\n") && isStringOnlySchema(shape.properties[key])) return key;
+	}
+	return undefined;
+}
+
+function renderInlineValue(value: unknown, schema: unknown): string {
+	if (typeof value === "string") {
+		return needsQuote(value) ? JSON.stringify(value) : value;
+	}
+	if (isStringOnlySchema(schema) && value === null) return '""';
+	return stringifyJson(value);
+}
+
+function needsQuote(value: string): boolean {
+	if (value.length === 0) return true;
+	const first = value[0];
+	if (first === '"' || first === "[" || first === "{") return true;
+	return /[\s«»]/.test(value);
+}
+
+function maxRun(text: string, ch: string): number {
+	let best = 0;
+	let run = 0;
+	for (let index = 0; index < text.length; index++) {
+		if (text[index] === ch) {
+			run++;
+			if (run > best) best = run;
+		} else {
+			run = 0;
+		}
+	}
+	return best;
 }
 
 function renderToolResults(results: readonly DialectToolResult[], _options?: DialectRenderOptions): string {
-	return renderToolResponseResults(results);
+	return results
+		.map(result => {
+			const fence = RESULT_FENCE.repeat(Math.max(2, 1 + maxRun(result.text, RESULT_FENCE)));
+			return `${fence}\n${result.text}\n${fence}`;
+		})
+		.join("\n");
 }
 
 function renderThinking(text: string): string {
 	if (!text) return "";
-	return `<thinking>\n${text}\n</thinking>`;
+	return `${THINK_SIGIL}\n${text}\n${THINK_SIGIL}`;
 }
 
 function renderTranscript(messages: readonly Message[], options: DialectRenderOptions = {}): string {
@@ -676,29 +586,6 @@ function renderTranscript(messages: readonly Message[], options: DialectRenderOp
 	});
 }
 
-function renderElement(key: string, value: unknown, schema: unknown): string {
-	if (Array.isArray(value)) {
-		const itemSchema = getArrayItemSchema(schema);
-		return value.map(item => renderElement(key, item, itemSchema)).join("\n");
-	}
-	if (value && typeof value === "object") {
-		const record = value as Record<string, unknown>;
-		const properties = getObjectProperties(schema);
-		let body = `<${key}>`;
-		for (const childKey in record) {
-			body += `\n${renderElement(childKey, record[childKey], properties[childKey])}`;
-		}
-		return `${body}\n</${key}>`;
-	}
-	return `<${key}>${renderScalar(value, schema)}</${key}>`;
-}
-
-function renderScalar(value: unknown, schema: unknown): string {
-	if (typeof value === "string") return value;
-	if (isStringOnlySchema(schema) && value === null) return "";
-	return stringifyJson(value);
-}
-
 const definition: DialectDefinition = {
 	dialect: "pi",
 	prompt: dialectPrompt,

package/src/providers/amazon-bedrock.ts

@@ -80,6 +80,13 @@ function resolveBearerToken(options: BedrockOptions): string | undefined {
 	return options.bearerToken || apiKey || $env.AWS_BEARER_TOKEN_BEDROCK;
 }
 
+function inferRegionFromBedrockArn(modelId: string): string | undefined {
+	const parts = modelId.split(":", 6);
+	if (parts[0] !== "arn" || parts[2] !== "bedrock") return undefined;
+	const region = parts[3];
+	return region || undefined;
+}
+
 type Block = (TextContent | ThinkingContent | ToolCall) & {
 	index?: number;
 	partialJson?: string;
@@ -206,7 +213,12 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 
 		const blocks = output.content as Block[];
 		let rawRequestDump: RawHttpRequestDump | undefined;
-		const region = options.region || $env.AWS_REGION || $env.AWS_DEFAULT_REGION || "us-east-1";
+		const region =
+			options.region ||
+			inferRegionFromBedrockArn(model.id) ||
+			$env.AWS_REGION ||
+			$env.AWS_DEFAULT_REGION ||
+			"us-east-1";
 
 		try {
 			const cacheRetention = resolveCacheRetention(options.cacheRetention);

package/src/registry/oauth/index.ts

@@ -19,6 +19,7 @@ const builtInOAuthProviders: OAuthProviderInfo[] = PROVIDER_REGISTRY.filter(
 	id: provider.id,
 	name: provider.name,
 	available: provider.available ?? true,
+	storeCredentialsAs: provider.storeCredentialsAs,
 }));
 
 const customOAuthProviders = new Map<string, OAuthProviderInterface>();
@@ -163,6 +164,7 @@ export function getOAuthProviders(): OAuthProviderInfo[] {
 		id: provider.id,
 		name: provider.name,
 		available: true,
+		storeCredentialsAs: provider.storeCredentialsAs,
 	}));
 	return [...builtInOAuthProviders, ...customProviders];
 }

package/src/registry/oauth/types.ts

@@ -31,6 +31,12 @@ export interface OAuthProviderInfo {
 	id: OAuthProviderId;
 	name: string;
 	available: boolean;
+	/**
+	 * Provider id the login stores credentials under, when it differs from `id`
+	 * (e.g. `openai-codex-device` ⇒ `openai-codex`). Lets callers map a login
+	 * entry back to the model provider it authenticates.
+	 */
+	storeCredentialsAs?: string;
 }
 
 export interface OAuthController {