@linxiraos/pi-ai 1.0.0

package/src/dialect/thinking.ts

@@ -0,0 +1,292 @@
+import { partialSuffixOverlapAny } from "./coercion";
+import { FencedThinkingScanner } from "./fenced-thinking";
+import type { InbandScanEvent, InbandScanner } from "./types";
+
+type Tag = { readonly open: string; readonly close: string; readonly fenced?: boolean };
+
+/**
+ * Every dialect's in-band thinking section in its canonical `renderThinking`
+ * form (see the sibling `./*.ts` scanners). {@link ThinkingInbandScanner} heals
+ * reasoning a model leaked into its visible text channel back into thinking
+ * events, whichever dialect idiom the leak used.
+ *
+ * Plain (attribute-free) delimiters only — matching what `renderThinking`
+ * emits and what models leak in practice. Attributed or namespaced XML thinking
+ * tags (`<thinking signature="…">`, `antml:thinking`) are recovered by the owned
+ * anthropic-dialect parser, not this text-channel healing fallback.
+ */
+const TAGS: readonly Tag[] = [
+	{ open: "<think>", close: "</think>" }, // deepseek, glm, hermes, kimi, qwen3 (and anthropic/minimax/xml)
+	{ open: "<thinking>", close: "</thinking>" }, // anthropic, minimax, xml
+	{ open: "<scratchpad>", close: "</scratchpad>" }, // anthropic
+	{ open: "```thinking\n", close: "```", fenced: true }, // gemini fenced thinking
+	{ open: "<|channel>thought\n", close: "<channel|>" }, // gemma reasoning channel
+	{ open: "<|start|>assistant<|channel|>analysis<|message|>", close: "<|end|>" }, // harmony analysis (rendered)
+	{ open: "<|channel|>analysis<|message|>", close: "<|end|>" }, // harmony analysis (bare leak)
+];
+const OPENS = TAGS.map(tag => tag.open);
+
+export class ThinkingInbandScanner implements InbandScanner {
+	#buffer = "";
+	#closeTag = "";
+	#thinking = "";
+	/** Fence-aware close-matcher while inside a ` ```thinking ` block; undefined otherwise. */
+	#fenced: FencedThinkingScanner | undefined;
+	/** Backtick count that opened the Markdown code span/fence we are inside; 0 when not in code. */
+	#codeTicks = 0;
+	/** True when {@link #codeTicks} opened a fenced block (closes on a fence line), not an inline span. */
+	#codeFenced = false;
+	/**
+	 * Leading-space count on the current output line, or -1 once a non-space
+	 * character has appeared. Starts at 0 (line start) so a fence opening the
+	 * stream — or one indented ≤3 spaces, as CommonMark allows — is recognized.
+	 */
+	#lineIndent = 0;
+
+	feed(text: string): InbandScanEvent[] {
+		if (text.length === 0) return [];
+		this.#buffer += text;
+		return this.#consume(false);
+	}
+
+	flush(): InbandScanEvent[] {
+		const events = this.#consume(true);
+		if (this.#buffer.length === 0) return events;
+		if (this.#closeTag) {
+			this.#emitThinking(this.#buffer, events);
+			events.push({ type: "thinkingEnd", thinking: this.#thinking });
+		} else {
+			events.push({ type: "text", text: this.#buffer });
+		}
+		this.#buffer = "";
+		this.#closeTag = "";
+		return events;
+	}
+
+	#consume(final: boolean): InbandScanEvent[] {
+		const events: InbandScanEvent[] = [];
+		for (;;) {
+			if (this.#fenced) {
+				// Run even with an empty buffer so a held partial close flushes on final.
+				const result = this.#fenced.feed(this.#buffer, final);
+				this.#buffer = result.closed ? result.rest : "";
+				this.#emitThinking(result.thinking, events);
+				if (result.closed || final) {
+					events.push({ type: "thinkingEnd", thinking: this.#thinking });
+					this.#thinking = "";
+					this.#closeTag = "";
+					this.#fenced = undefined;
+				}
+				if (this.#fenced) break;
+				continue;
+			}
+			if (this.#buffer.length === 0) break;
+			if (this.#closeTag) {
+				const close = this.#buffer.indexOf(this.#closeTag);
+				if (close === -1) {
+					const hold = final ? 0 : partialSuffixOverlapAny(this.#buffer, [this.#closeTag]);
+					this.#emitThinking(this.#buffer.slice(0, this.#buffer.length - hold), events);
+					this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+					break;
+				}
+				this.#emitThinking(this.#buffer.slice(0, close), events);
+				this.#buffer = this.#buffer.slice(close + this.#closeTag.length);
+				events.push({ type: "thinkingEnd", thinking: this.#thinking });
+				this.#thinking = "";
+				this.#closeTag = "";
+				continue;
+			}
+			if (this.#codeTicks > 0) {
+				if (this.#emitCode(final, events)) continue;
+				break;
+			}
+
+			const hit = scanVisible(this.#buffer, final);
+			if (hit.kind === "none") {
+				this.#emitText(this.#buffer, events);
+				this.#buffer = "";
+				break;
+			}
+			if (hit.index > 0) this.#emitText(this.#buffer.slice(0, hit.index), events);
+			if (hit.kind === "hold") {
+				this.#buffer = this.#buffer.slice(hit.index);
+				break;
+			}
+			if (hit.kind === "code") {
+				const fenced = hit.ticks >= 3 && this.#lineIndent >= 0 && this.#lineIndent <= 3;
+				this.#emitText(this.#buffer.slice(hit.index, hit.index + hit.ticks), events);
+				this.#buffer = this.#buffer.slice(hit.index + hit.ticks);
+				this.#codeTicks = hit.ticks;
+				this.#codeFenced = fenced;
+				continue;
+			}
+			this.#buffer = this.#buffer.slice(hit.index + hit.tag.open.length);
+			this.#closeTag = hit.tag.close;
+			this.#thinking = "";
+			if (hit.tag.fenced) this.#fenced = new FencedThinkingScanner();
+			events.push({ type: "thinkingStart" });
+		}
+		return events;
+	}
+
+	/**
+	 * Emit buffered content while inside a Markdown code region, suppressing
+	 * reasoning-tag detection. A fenced block closes only on a fence line (a line
+	 * of backticks ≥ the opener); an inline span closes on the first backtick run
+	 * of exactly the opener length. Returns true when the region closed and the
+	 * loop should continue, false when it held back and should break.
+	 */
+	#emitCode(final: boolean, events: InbandScanEvent[]): boolean {
+		if (this.#codeFenced) {
+			const end = findFenceCloseEnd(this.#buffer, this.#codeTicks, final);
+			if (end !== -1) {
+				this.#emitText(this.#buffer.slice(0, end), events);
+				this.#buffer = this.#buffer.slice(end);
+				this.#codeTicks = 0;
+				this.#codeFenced = false;
+				return true;
+			}
+			if (final) {
+				this.#emitText(this.#buffer, events);
+				this.#buffer = "";
+				this.#codeTicks = 0;
+				this.#codeFenced = false;
+				return false;
+			}
+			// Stream committed lines; hold only the last (possibly partial) fence line.
+			const lastNl = this.#buffer.lastIndexOf("\n");
+			if (lastNl !== -1) {
+				this.#emitText(this.#buffer.slice(0, lastNl + 1), events);
+				this.#buffer = this.#buffer.slice(lastNl + 1);
+			}
+			return false;
+		}
+		const close = findBacktickRun(this.#buffer, 0, this.#codeTicks);
+		if (close !== -1 && (final || close + this.#codeTicks < this.#buffer.length)) {
+			this.#emitText(this.#buffer.slice(0, close + this.#codeTicks), events);
+			this.#buffer = this.#buffer.slice(close + this.#codeTicks);
+			this.#codeTicks = 0;
+			return true;
+		}
+		// No committed close yet: emit text, holding a trailing backtick run that
+		// may still grow into — or past — the closing delimiter.
+		const hold = final ? 0 : trailingBacktickRun(this.#buffer);
+		this.#emitText(this.#buffer.slice(0, this.#buffer.length - hold), events);
+		this.#buffer = this.#buffer.slice(this.#buffer.length - hold);
+		if (final) this.#codeTicks = 0;
+		return false;
+	}
+
+	#emitText(text: string, events: InbandScanEvent[]): void {
+		if (text.length === 0) return;
+		events.push({ type: "text", text });
+		this.#lineIndent = trailingLineIndent(text, this.#lineIndent);
+	}
+
+	#emitThinking(delta: string, events: InbandScanEvent[]): void {
+		if (delta.length === 0) return;
+		this.#thinking += delta;
+		events.push({ type: "thinkingDelta", delta });
+	}
+}
+
+/** Outcome of scanning idle visible text for the next reasoning-tag or code-span boundary. */
+type VisibleHit =
+	| { readonly kind: "tag"; readonly index: number; readonly tag: Tag }
+	| { readonly kind: "code"; readonly index: number; readonly ticks: number }
+	| { readonly kind: "hold"; readonly index: number }
+	| { readonly kind: "none" };
+
+/**
+ * Walk idle visible text for the earliest boundary: a leaked reasoning-tag open,
+ * a Markdown code-span/fence opener (a backtick run), or — when more chunks may
+ * follow — a held partial delimiter at the buffer tail.
+ *
+ * Reasoning tags win at any position so the gemini ` ```thinking ` fence is
+ * healed instead of being read as a code fence. Backtick runs enter code mode so
+ * a literal `<think>` inside inline code or a fenced block stays visible text.
+ */
+function scanVisible(buffer: string, final: boolean): VisibleHit {
+	for (let i = 0; i < buffer.length; i++) {
+		const tag = TAGS.find(candidate => buffer.startsWith(candidate.open, i));
+		if (tag) return { kind: "tag", index: i, tag };
+		if (!final) {
+			const rest = buffer.slice(i);
+			if (OPENS.some(open => open.length > rest.length && open.startsWith(rest))) {
+				return { kind: "hold", index: i };
+			}
+		}
+		if (buffer[i] === "`") {
+			const ticks = backtickRun(buffer, i);
+			if (!final && i + ticks === buffer.length) return { kind: "hold", index: i };
+			return { kind: "code", index: i, ticks };
+		}
+	}
+	return { kind: "none" };
+}
+
+/** Length of the maximal backtick run beginning at `from`. */
+function backtickRun(buffer: string, from: number): number {
+	let end = from;
+	while (end < buffer.length && buffer[end] === "`") end++;
+	return end - from;
+}
+
+/** Index of the first maximal backtick run of exactly `ticks` at/after `from`, else -1. */
+function findBacktickRun(buffer: string, from: number, ticks: number): number {
+	for (let i = buffer.indexOf("`", from); i !== -1; i = buffer.indexOf("`", i)) {
+		const run = backtickRun(buffer, i);
+		if (run === ticks) return i;
+		i += run;
+	}
+	return -1;
+}
+
+/** Length of a backtick run that ends at the buffer tail; 0 when the tail is not a backtick. */
+function trailingBacktickRun(buffer: string): number {
+	let start = buffer.length;
+	while (start > 0 && buffer[start - 1] === "`") start--;
+	return buffer.length - start;
+}
+
+/**
+ * Leading-space count of the line at the tail of `text`, continuing from the
+ * prior line's `indent` state (see {@link ThinkingInbandScanner.#lineIndent}).
+ * Returns -1 once any non-space character has appeared on the current line.
+ */
+function trailingLineIndent(text: string, prior: number): number {
+	const lastNl = text.lastIndexOf("\n");
+	let indent = lastNl === -1 ? prior : 0;
+	for (let i = lastNl + 1; i < text.length; i++) {
+		if (indent === -1) break;
+		indent = text[i] === " " ? indent + 1 : -1;
+	}
+	return indent;
+}
+
+/**
+ * Index just past the first closing fence line for a fenced block opened with
+ * `ticks` backticks, or -1 when none is committed yet. A closing fence is a whole
+ * line whose trimmed content is only backticks, at least `ticks` of them. A line
+ * without a terminating newline is committed only when `final` (no more input can
+ * extend it into a non-fence line).
+ */
+function findFenceCloseEnd(buffer: string, ticks: number, final: boolean): number {
+	for (let start = 0; start <= buffer.length; ) {
+		const nl = buffer.indexOf("\n", start);
+		const terminated = nl !== -1;
+		const line = buffer.slice(start, terminated ? nl : buffer.length).trim();
+		if (line.length >= ticks && isAllBackticks(line) && (terminated || final)) {
+			return terminated ? nl + 1 : buffer.length;
+		}
+		if (!terminated) break;
+		start = nl + 1;
+	}
+	return -1;
+}
+
+/** True when `text` is non-empty and every character is a backtick. */
+function isAllBackticks(text: string): boolean {
+	for (let i = 0; i < text.length; i++) if (text[i] !== "`") return false;
+	return text.length > 0;
+}

package/src/dialect/types.ts

@@ -0,0 +1,56 @@
+import type { Dialect as CatalogDialect } from "@linxiraos/pi-catalog/identity";
+import type { Context, Message, ToolCall } from "../types";
+
+export type { Dialect } from "@linxiraos/pi-catalog/identity";
+
+export type InbandScanEvent =
+	| { type: "text"; text: string }
+	| { type: "thinkingStart" }
+	| { type: "thinkingDelta"; delta: string }
+	| { type: "thinkingEnd"; thinking: string }
+	| { type: "toolStart"; id: string; name: string }
+	| { type: "toolArgDelta"; id: string; name: string; key: string; delta: string }
+	| { type: "toolEnd"; id: string; name: string; arguments: Record<string, unknown>; rawBlock?: string };
+
+export interface InbandScanner {
+	feed(text: string): InbandScanEvent[];
+	flush(): InbandScanEvent[];
+}
+
+export interface DialectToolResult {
+	readonly id: string;
+	readonly name: string;
+	readonly index: number;
+	readonly text: string;
+	readonly isError: boolean;
+}
+
+export interface DialectRenderOptions {
+	readonly tools?: readonly InbandTool[];
+}
+
+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?: 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 dialects. */
+	stringArgs?: (toolName: string) => ReadonlySet<string>;
+	/** 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 dialect defines them. */
+	parseThinking?: boolean;
+}
+
+export type InbandTool = NonNullable<Context["tools"]>[number];

package/src/dialect/xml.md

@@ -0,0 +1,22 @@
+## Format guide
+
+A call is one `<invoke>` element whose `<parameter>` children carry its arguments:
+
+```text
+<invoke name="fn"><parameter name="arg">value</parameter></invoke>
+```
+
+Emit consecutive `<invoke>…</invoke>` blocks for multiple calls; you MAY wrap them in `<tool_calls>…</tool_calls>`. Each call's result arrives as a response block:
+
+```text
+<tool_response>
+verbatim tool result
+</tool_response>
+```
+
+## Rules
+
+- `name` MUST match a listed function.
+- Parameter values are read literally by regex (delimiter matching), NOT a real XML parser: write them verbatim and never HTML-escape (emit `a & b`, never `a &amp; b`; `<`/`>` stay literal too). Only the body's own `</parameter>` closing tag is reserved. Non-string values are JSON; add `string="false"` to a parameter only to force JSON parsing of a value the schema treats as a string.
+- Read each `<tool_response>` in call order. NEVER emit `<tool_response>` yourself.
+- Emit the stop sequence ONLY after the call is fully written — NEVER announce a tool then stop (e.g. halting at "Let's run `cargo clippy`" with no `<invoke>` emitted). Write the complete call, THEN the stop sequence, THEN halt.

package/src/dialect/xml.ts

@@ -0,0 +1,90 @@
+import type { Message, ToolCall } from "../types";
+import { AnthropicInbandScanner } from "./anthropic";
+import { buildArgShapes, type ToolArgShape } from "./coercion";
+import { DeepSeekInbandScanner } from "./deepseek";
+import {
+	escapeXmlAttr,
+	renderDelimitedThinking,
+	renderLegacyTextTranscript,
+	renderToolResponseResults,
+	stringifyJson,
+} from "./rendering";
+import type {
+	DialectDefinition,
+	DialectRenderOptions,
+	DialectToolResult,
+	InbandScanEvent,
+	InbandScanner,
+	InbandScannerOptions,
+} from "./types";
+import dialectPrompt from "./xml.md" with { type: "text" };
+
+export class XmlInbandScanner implements InbandScanner {
+	readonly #inner: InbandScanner;
+
+	constructor(options: InbandScannerOptions = {}) {
+		this.#inner =
+			options.xmlTagset === "dsml" ? new DeepSeekInbandScanner(options) : new AnthropicInbandScanner(options);
+	}
+
+	feed(text: string): InbandScanEvent[] {
+		return this.#inner.feed(text);
+	}
+
+	flush(): InbandScanEvent[] {
+		return this.#inner.flush();
+	}
+}
+
+function renderToolCall(call: ToolCall, options: DialectRenderOptions = {}): string {
+	return renderInvoke(call, buildArgShapes(options.tools).get(call.name));
+}
+
+function renderAssistantToolCalls(calls: readonly ToolCall[], options: DialectRenderOptions = {}): string {
+	return renderInvokes(calls, options.tools ?? []);
+}
+
+function renderToolResults(results: readonly DialectToolResult[]): string {
+	return renderToolResponseResults(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: "xml",
+	prompt: dialectPrompt,
+	createScanner: options => new XmlInbandScanner(options),
+	renderToolCall,
+	renderAssistantToolCalls,
+	renderToolResults,
+	renderThinking,
+	renderTranscript,
+};
+
+export default definition;

package/src/error/abort.ts

@@ -0,0 +1,18 @@
+import { attach, create, Flag } from "./flags";
+
+/**
+ * A request was cancelled — by the caller's `AbortSignal` or a provider-local
+ * watchdog. Carries the {@link Flag.Abort} classification structurally so retry
+ * logic does not have to regex the message text.
+ *
+ * The default message is kept byte-identical to the historical
+ * `"Request was aborted"` string so any remaining text-based matchers keep
+ * working through the migration.
+ */
+export class AbortError extends Error {
+	constructor(message = "Request was aborted", options?: { cause?: unknown }) {
+		super(message, options?.cause === undefined ? undefined : { cause: options.cause });
+		this.name = "AbortError";
+		attach(this, create(Flag.Abort));
+	}
+}

package/src/error/auth-classify.ts

@@ -0,0 +1,47 @@
+import { extractHttpStatusFromError } from "@linxiraos/pi-utils";
+import { isOAuthExpiry, isUsageLimit } from "./flags";
+import { isConcurrencyCapExclusion, isUsageLimitOutcome } from "./rate-limit";
+
+/**
+ * Whether an OAuth refresh failure is definitive (the credential must be
+ * disabled) versus transient. Thin alias over the {@link Flag.OAuthExpiry}
+ * text classifier {@link isOAuthExpiry}; retained as the public
+ * `@linxiraos/pi-ai` entrypoint name used by the coding agent and auth-broker.
+ */
+export function isDefinitiveOAuthFailure(errorMsg: string): boolean {
+	return isOAuthExpiry(errorMsg);
+}
+
+const INVALIDATED_OAUTH_TOKEN_PATTERN = /\binvalidated oauth token\b/i;
+
+/** Whether an upstream response explicitly says the supplied OAuth bearer was invalidated. */
+export function isInvalidatedOAuthTokenError(error: unknown): boolean {
+	if (typeof error === "object" && error !== null && "errorMessage" in error) {
+		const errorMessage = error.errorMessage;
+		if (typeof errorMessage === "string" && INVALIDATED_OAUTH_TOKEN_PATTERN.test(errorMessage)) return true;
+	}
+	const message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;
+	return message !== undefined && INVALIDATED_OAUTH_TOKEN_PATTERN.test(message);
+}
+
+/**
+ * Whether an upstream failure should rotate to a sibling credential: a hard
+ * `401`, a `403` (token valid but access denied — plan, model policy, or org
+ * restriction a sibling account may not share), a body-classified usage limit
+ * (Codex `usage_limit_reached`, Anthropic account rate-limit, Google
+ * `resource_exhausted`, OpenAI `insufficient_quota`, …), or a bare `429`
+ * whose payload did not preserve a richer quota code.
+ * Transient 429s (`Too many requests`, per-minute caps) stay in the
+ * upstream-backoff lane.
+ */
+export function isAuthRetryableError(error: unknown): boolean {
+	if (isUsageLimit(error)) return true;
+	if (isInvalidatedOAuthTokenError(error)) return true;
+	const httpStatus = extractHttpStatusFromError(error);
+	const message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;
+	const embeddedStatus = message ? extractHttpStatusFromError({ message }) : undefined;
+	const status = httpStatus ?? embeddedStatus;
+	if (isConcurrencyCapExclusion(status, message)) return false;
+	if (status === 401 || status === 403) return true;
+	return isUsageLimitOutcome(status, message);
+}

package/src/error/auth.ts

@@ -0,0 +1,48 @@
+import { attach, create, Flag } from "./flags";
+
+/**
+ * No API key / credential was available to dispatch a request.
+ *
+ * The default message preserves the historical `"No API key for provider: X"`
+ * wording, which {@link Flag.AuthFailed}'s regex (`no api key`) keys off — but
+ * the flag is also attached structurally so classification never depends on the
+ * exact phrasing.
+ */
+export class MissingApiKeyError extends Error {
+	readonly provider: string | undefined;
+
+	constructor(provider?: string, message?: string) {
+		super(message ?? (provider ? `No API key for provider: ${provider}` : "No API key available"));
+		this.name = "MissingApiKeyError";
+		this.provider = provider;
+		attach(this, create(Flag.AuthFailed));
+	}
+}
+
+/** A user-facing login flow required an `onPrompt` callback that was not supplied. */
+export class OnPromptRequiredError extends Error {
+	constructor(providerLabel: string) {
+		super(`${providerLabel} login requires onPrompt callback`);
+		this.name = "OnPromptRequiredError";
+	}
+}
+
+/** An interactive login asked for an API key but the user supplied an empty value. */
+export class ApiKeyRequiredError extends Error {
+	constructor(message = "API key is required") {
+		super(message);
+		this.name = "ApiKeyRequiredError";
+	}
+}
+
+/**
+ * A user cancelled an interactive login / device flow. Classified as an abort
+ * so it is never surfaced as a retryable transient failure.
+ */
+export class LoginCancelledError extends Error {
+	constructor(message = "Login cancelled") {
+		super(message);
+		this.name = "LoginCancelledError";
+		attach(this, create(Flag.Abort));
+	}
+}

package/src/error/aws.ts

@@ -0,0 +1,35 @@
+/** Which AWS credential-resolution path failed. */
+export type AwsCredentialsErrorKind =
+	/** No usable credential source resolved (chain exhausted). */
+	| "resolution"
+	/** SSO cache token missing (`aws sso login` not run). */
+	| "sso-token-missing"
+	/** SSO cache token present but expired. */
+	| "sso-token-expired"
+	/** SSO `GetRoleCredentials` call failed or returned no role. */
+	| "sso-role"
+	/** External `credential_process` failed, timed out, or emitted bad output. */
+	| "credential-process"
+	/** STS web-identity exchange failed or returned malformed credentials. */
+	| "web-identity"
+	/** ECS/container credential endpoint failed or returned malformed credentials. */
+	| "container";
+
+/** A failure resolving AWS credentials for the Bedrock provider. */
+export class AwsCredentialsError extends Error {
+	readonly kind: AwsCredentialsErrorKind;
+
+	constructor(message: string, kind: AwsCredentialsErrorKind, options?: { cause?: unknown }) {
+		super(message, options?.cause === undefined ? undefined : { cause: options.cause });
+		this.name = "AwsCredentialsError";
+		this.kind = kind;
+	}
+}
+
+/** A malformed AWS event-stream frame (bad length, CRC mismatch, unknown header type). */
+export class EventStreamFrameError extends Error {
+	constructor(detail: string) {
+		super(`eventstream: ${detail}`);
+		this.name = "EventStreamFrameError";
+	}
+}