@linxiraos/pi-ai 1.2.1 → 1.3.1

package/dist/types/providers/cursor.d.ts

@@ -218,6 +218,13 @@ export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unkn
  * call handed to an external executor is only a handoff while the marker is
  * absent, and the consumer that runs it needs a runnable block.
  *
+ * A frame whose `toolCallId` already has a block in `output` is the server
+ * re-dispatching that call (a new `execId`, e.g. a `read` re-sent once a
+ * parallel shell created the file). It adds no block: a second block with the
+ * same id makes every rebuilt history replay the call twice, which Cursor
+ * rejects (issue #15749). The re-run's result supersedes the first one in the
+ * host's result buffer.
+ *
  * Exported for tests to exercise ordering with adjacent text/thinking blocks.
  */
 export declare function synthesizeCursorExecToolCall(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, toolCallId: string, toolName: string, args: Record<string, unknown>, { executed }?: {

package/dist/types/providers/ollama.d.ts

@@ -1,8 +1,13 @@
-import type { StreamFunction, StreamOptions, ToolChoice } from "../types.js";
+import type { Model, StreamFunction, StreamOptions, ToolChoice } from "../types.js";
 export interface OllamaChatOptions extends StreamOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     disableReasoning?: boolean;
     toolChoice?: ToolChoice;
 }
+/** Whether Ollama chat removes assistant thinking from replayed history. */
+export declare function ollamaChatDropsOwnThinking(model: {
+    api?: string;
+    compat?: Model["compat"];
+} | null | undefined): boolean;
 /** Retry EOS-only Ollama completions before the agent loop sees an empty stop. */
 export declare const streamOllama: StreamFunction<"ollama-chat">;

package/dist/types/providers/openai-codex-responses.d.ts

@@ -6,6 +6,12 @@ export type { CodexAttestationProvider } from "./openai-codex-attestation.js";
 import type { ResponseInput } from "./openai-responses-wire.js";
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    /**
+     * Run with the least reasoning the model allows; takes precedence over
+     * `reasoning`. Sends the `none` tier where the catalog's disable mode is
+     * `none-effort`, else the model's lowest supported effort.
+     */
+    disableReasoning?: boolean;
     reasoningSummary?: "auto" | "concise" | "detailed" | null;
     /** Explicit `reasoning.context` replay scope. Omitted by default so Codex applies its native request policy. */
     reasoningContext?: CodexReasoningContext;

package/dist/types/providers/openai-responses.d.ts

@@ -114,6 +114,15 @@ interface OpenAIResponsesChainState {
     /** Set once chaining is judged unsupported for this session (circuit breaker). */
     disabled: boolean;
 }
+/**
+ * Whether the next request for `model` replays native Responses history items
+ * (encrypted reasoning, item ids), as {@link buildParams} decides it. A session
+ * is cold, rebuilding turns from message content, from the first request on a
+ * connection-bound host (`compat.connectionBoundNativeHistory`, GitHub Copilot)
+ * and after `close()` on any host, until a response succeeds. Without session
+ * state every request replays.
+ */
+export declare function openAIResponsesReplaysNativeHistory(model: Pick<Model, "api" | "provider" | "compat"> | null | undefined, providerSessionState: Map<string, ProviderSessionState> | undefined): boolean;
 /**
  * Set the process-wide storage default per provider id, used when a request
  * leaves `storeResponses` unset. Hosts call this from their settings so every

package/dist/types/providers/openai-shared.d.ts

@@ -399,6 +399,22 @@ interface StrictToolsRetryContext {
     strictToolsApplied: boolean;
     tools: Tool[] | undefined;
 }
+/**
+ * Read OpenRouter's `error.metadata.raw` from a captured non-2xx body.
+ *
+ * OpenRouter routes to a different upstream per request, so its top-level
+ * `error.message` is a generic policy sentence ("Access denied by security
+ * policy") and the only place the routed provider's own words appear is
+ * `error.metadata.raw`. Providers that proxy through OpenRouter also hang the
+ * upstream provider name there.
+ *
+ * The detail lives in the decoded body captured on the thrown
+ * {@link AIError.OpenAIHttpError}, not on the error object itself: no error
+ * class in this package carries an `error` property, so reading
+ * `error.error.metadata.raw` unconditionally yielded `undefined` and the
+ * upstream detail was dropped from every surfaced message.
+ */
+export declare function readOpenRouterRawMetadata(capturedErrorResponse: CapturedHttpErrorResponse | undefined): string | undefined;
 /** Decide whether an OpenAI-family request should retry once with non-strict tools. */
 export declare function shouldRetryWithoutStrictTools(error: unknown, capturedErrorResponse: CapturedHttpErrorResponse | undefined, context: StrictToolsRetryContext): boolean;
 export declare const OPENAI_RESPONSES_PROGRESS_EVENT_TYPES: ReadonlySet<string>;
@@ -525,6 +541,20 @@ export interface BuildResponsesInputOptions<TApi extends Api> {
  * Callers gate on {@link isHarmonyDialectModel}. Items are copied, not mutated.
  */
 export declare function escapeReplayedControlTokens(items: ResponseInput): ResponseInput;
+/**
+ * Whether a same-provider assistant turn may replay its native items while the
+ * provider session is still cold (#489). A cold session rebuilds turns from
+ * message content because some backends bind native items to one connection
+ * (GitHub Copilot: `401 input item does not belong to this connection`, #488).
+ * Binding needs server-issued state that survives replay sanitization: an
+ * `encrypted_content` blob or an item id. A turn with neither, whose every
+ * reasoning item carries plaintext `reasoning_text`, has nothing to bind and is
+ * exactly what the server receives once the session warms; rebuilding it would
+ * drop that reasoning and change the prompt prefix the server cached.
+ * Summary-only reasoning keeps the rebuild: it is no evidence of a server that
+ * returns plaintext reasoning.
+ */
+export declare function isColdReplayableResponsesTurn(items: ResponseInput): boolean;
 export declare function buildResponsesInput<TApi extends Api>(options: BuildResponsesInputOptions<TApi>): ResponseInput;
 /**
  * Non-empty `reasoning_text` shipped for a synthesized reasoning item when no

package/dist/types/providers/systemone-server.d.ts

@@ -1,7 +1,9 @@
 import type { JudgmentRequest, JudgmentResult } from "../judgment/types.js";
+import type { JudgmentImageAssets } from "../judgment/wire.js";
 export interface SystemOneParsedRequest {
     modelId: string;
     request: JudgmentRequest;
+    imageAssets?: JudgmentImageAssets;
 }
 /** `POST /v1/systemone` response body; `cost` (USD) appears only when the route billed one. */
 export interface SystemOneResponseBody {
@@ -14,10 +16,12 @@ export interface SystemOneResponseBody {
     };
 }
 /**
- * Validate the routing-relevant parts of a System One request body.
+ * Validate the routing-relevant parts of a System One request body, including
+ * top-level embedded images and inline TypeSafe image assets.
  *
- * @throws {AIError.ValidationError} naming the offending field when `model`,
- * `state`, or `questions` is missing or malformed.
+ * @throws {AIError.ValidationError} when required routing fields are missing
+ * or malformed, supplied image data is invalid, or an asset uses multipart
+ * `part`, which this JSON ingress cannot read.
  */
 export declare function parseRequest(body: unknown): SystemOneParsedRequest;
 /** Re-encode a judgment result in TypeSafe's response shape. */

package/dist/types/providers/transform-messages.d.ts

@@ -9,6 +9,10 @@ import type { Api, AssistantMessage, Message, Model } from "../types.js";
  * MUST not push a normalized id past this bound.
  */
 export declare const MAX_TOOL_CALL_ID_LENGTH = 64;
+/** Replace unsupported tool-call ID characters and cap the result for strict replay providers. */
+export declare function normalizeToolCallId(id: string, maxLength?: number): string;
+/** Whether `id` already satisfies the strict 1–64 `[a-zA-Z0-9_-]` tool-call ID contract. */
+export declare function isValidToolCallId(id: string): boolean;
 /**
  * OpenAI Responses-family APIs mint composite tool ids (`call_id|item_id`);
  * opaque Chat Completions ids do not (openai-completions preserves same-model
@@ -25,12 +29,31 @@ export declare function isResponsesFamilyApi(api: Api | undefined): boolean;
 export declare function responsesCallComponent(id: string): string;
 export declare function appendDuplicateSuffix(originalId: string, suffix: string, maxLength: number): string;
 /**
- * Whether a tool-call name cannot belong to any declared tool: missing, empty,
- * longer than OpenAI's 128-character replay limit, or containing whitespace or
- * control characters (tool schemas never allow them; their presence means the
- * name slot carries invocation text).
+ * Whether a tool-call name cannot be replayed to the target: missing, empty,
+ * longer than its declaration limit, or containing a character outside its
+ * declaration charset. Models emit such names when the name slot carries
+ * invocation text (whitespace, NULs) or an invented internal URL (`proc://*`).
+ *
+ * Without a target, use the OpenAI Responses native-history constraints.
+ */
+export declare function isMalformedToolCallName(name: unknown, allowedName?: RegExp, maxLength?: number): boolean;
+/**
+ * Whether {@link transformMessages} drops `msg` from every replay: a turn cut
+ * off by `length` / `error` / `aborted` that carries no text and no tool call.
+ */
+export declare function shouldDropTruncatedThinkingOnlyAssistant(msg: AssistantMessage): boolean;
+/**
+ * Whether `msg` reaches a replay as an assistant turn, so it can be the latest
+ * surviving one: {@link sanitizeMalformedToolCalls} drops its malformed tool
+ * calls, then {@link shouldDropTruncatedThinkingOnlyAssistant} a truncated
+ * turn left with no text and no tool call. On an already sanitized list this
+ * is `!shouldDropTruncatedThinkingOnlyAssistant(msg)`. Pass the target `model`
+ * to apply its tool-name limits; without one, any provider-declarable name survives.
  */
-export declare function isMalformedToolCallName(name: unknown): boolean;
+export declare function isSurvivingAssistant(msg: AssistantMessage, model?: Model): boolean;
+export declare function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messages">;
+/** Whether `turn` came from `model` itself: its own turns replay their native reasoning unchanged. */
+export declare function isSameModelTurn(turn: Pick<AssistantMessage, "provider" | "api" | "model">, model: Pick<Model, "provider" | "api" | "id">): boolean;
 /**
  * Normalize tool call ID for cross-provider compatibility.
  * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.

package/dist/types/registry/oauth/google-antigravity.d.ts

@@ -1,5 +1,5 @@
 /**
- * Antigravity OAuth flow (Gemini 3, Claude, GPT-OSS via Google Cloud)
+ * Google Antigravity OAuth flow (Gemini, Claude, GPT-OSS via Google Cloud)
  * Uses different OAuth credentials than google-gemini-cli for access to additional models.
  */
 import type { AfterExchangeHook } from "../hooks/types.js";

package/dist/types/stream.d.ts

@@ -5,8 +5,6 @@ import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli.js";
 import type { GoogleVertexOptions } from "./providers/google-vertex.js";
 import type { Api, AssistantMessage, Context, Model, OptionsForApi, SimpleStreamOptions, ToolChoice } from "./types.js";
 import { AssistantMessageEventStream } from "./utils/event-stream.js";
-/** Strict official-Codex endpoint check; exact origin or a path boundary after {@link CODEX_BASE_URL}. */
-export declare function isOfficialCodexApiUrl(baseUrl: string | undefined): boolean;
 export declare function configureProviderMaxInFlightRequests(limits: Record<string, number> | undefined): void;
 export declare const __providerInFlightForTesting: {
     setRoot(root: string | undefined): void;

package/dist/types/types.d.ts

@@ -9,7 +9,7 @@ import type { ApiKey } from "./auth-retry.js";
 import type { OAuthRequestIdentity } from "./auth/types.js";
 import type { BedrockOptions } from "./providers/amazon-bedrock.js";
 import type { AnthropicOptions } from "./providers/anthropic.js";
-import type { FallbackParam, StopDetails } from "./providers/anthropic-wire.js";
+import type { FallbackParam, MessageCreateParamsStreaming, StopDetails } from "./providers/anthropic-wire.js";
 import type { AzureOpenAIResponsesOptions } from "./providers/azure-openai-responses.js";
 import type { CursorOptions } from "./providers/cursor.js";
 import type { AppleFoundationModelsOptions } from "./providers/apple-foundation-models.js";
@@ -267,6 +267,11 @@ export interface StreamOptions {
     frequencyPenalty?: number;
     maxTokens?: number;
     signal?: AbortSignal;
+    /**
+     * OpenAI chat-completions HTTP attempt budget. When set, transient provider
+     * errors are not replayed above the transport, so retries share this limit.
+     */
+    maxHttpAttempts?: number;
     apiKey?: string;
     /** @internal Stored credential row serving this request, when known. */
     credentialId?: number;
@@ -398,8 +403,6 @@ export interface StreamOptions {
     liveSteering?: LiveSteering;
     /** Canonical Codex compaction classification; ignored by other providers. */
     codexCompaction?: CodexCompactionRequestContext;
-    /** Codex Code Mode tool exposure snapshot emitted as `tool_namespaces_info` turn metadata; ignored by other providers. */
-    toolNamespacesInfo?: unknown;
     /**
      * Optional per-provider concurrent request cap for LLM stream calls. Keys are
      * provider ids (`model.provider`); positive numeric values cap in-flight
@@ -645,6 +648,13 @@ export interface ThinkingContent {
      * replay natively on another host.
      */
     summary?: boolean;
+    /**
+     * `true`: the block is narration — prose the model addressed to the user
+     * between tool calls, which the provider returned as a signed thinking block
+     * (Anthropic connector-text summarization). It stays a thinking block for
+     * replay; user-facing surfaces present it as answer text.
+     */
+    narration?: boolean;
 }
 export interface RedactedThinkingContent {
     type: "redactedThinking";
@@ -652,11 +662,12 @@ export interface RedactedThinkingContent {
 }
 /**
  * Anthropic server-side-fallback boundary marker persisted on assistant
- * turns whose provider request opted into
- * `AnthropicOptions.fallbacks`. Consumers other than the Anthropic
- * provider MUST ignore it — `transformMessages` strips the block on any
- * cross-provider hop and on non-official Anthropic replays, so downstream
- * converters never see it.
+ * turns whose response switched models mid-stream, whether the request
+ * opted into `AnthropicOptions.fallbacks` or a gateway opted in on its
+ * behalf. Consumers other than the Anthropic provider MUST ignore it —
+ * `transformMessages` strips the block on any non-Anthropic hop, and
+ * `convertAnthropicMessages` only puts it on the wire for an opted-in
+ * request to the official endpoint.
  */
 export interface AnthropicFallbackContent {
     type: "fallback";
@@ -983,6 +994,12 @@ export type AssistantRetryRecovery = {
 export interface ContextSnapshot {
     promptTokens: number;
     nonMessageTokens: number;
+    /**
+     * Estimated tool-schema tokens included in `nonMessageTokens` (0 when the
+     * model defers schemas server-side). Lets a later model whose schema policy
+     * differs rebase the provider anchor instead of inheriting its schemas.
+     */
+    toolSchemaTokens?: number;
     /** Estimated prompt tokens removed by local history rewrites after this provider snapshot was recorded. */
     historyRewriteTokensRemoved?: number;
     /**
@@ -1031,6 +1048,12 @@ export interface AssistantMessage {
      */
     serviceTier?: ServiceTier;
     usage: Usage;
+    /**
+     * Visible output tokens a history rewrite (shake) has since removed from
+     * `content`. `usage.output` still counts them, so a replay estimate subtracts
+     * them to keep the turn's reasoning without recharging the removed text.
+     */
+    elidedOutputTokens?: number;
     stopReason: StopReason;
     stopDetails?: StopDetails | null;
     errorMessage?: string;
@@ -1418,7 +1441,8 @@ export type AssistantMessageEvent = {
 export interface AnthropicFallbackCreditHandle {
     token: string;
     prefillClaim?: boolean | null;
-    params: unknown;
+    /** The refused request's body, replayed with the credit token on the fallback model. */
+    params: MessageCreateParamsStreaming;
     betas?: readonly string[];
     betaHeader?: string;
     expiresAt: number;

package/dist/types/usage/muse-code.d.ts

@@ -1,2 +1,2 @@
-import type { UsageProvider } from "../usage.js";
+import { type UsageProvider } from "../usage.js";
 export declare const museCodeUsageProvider: UsageProvider;

package/dist/types/utils/dsml-leak.d.ts

@@ -1,29 +1,33 @@
 /**
- * Removal of DeepSeek DSML tool-call markup left in visible assistant text.
+ * Removal of DeepSeek tool-call markup left in visible assistant text.
  *
  * DeepSeek models on OpenAI-compatible hosts sometimes emit their tool calls as
- * raw `<｜DSML｜…>` markup in `content`. A well-formed envelope is healed into a
- * structured call by `StreamMarkupHealing`, but a degraded model can drop the
- * opening `<｜DSML｜tool_calls>` / `<｜DSML｜invoke name="…">` tags (or the host
- * runs no healer at all). That markup must not stay in history: replaying it
- * teaches the model to keep writing tool calls as text (issue #10556). Callers
- * strip it before the message is committed and tell the model its call failed.
+ * text in `content`: the V4 `<｜DSML｜…>` envelope or the V3 chat-template
+ * tokens (`<｜tool▁calls▁begin｜>` …). A well-formed call is healed into a
+ * structured call by `StreamMarkupHealing`, but a degraded model can drop
+ * required tags (or the host runs no healer at all). That markup must not stay
+ * in history: replaying it teaches the model to keep writing tool calls as text
+ * (issue #10556). Callers strip it before the message is committed and tell the
+ * model its call failed.
  */
 import type { AssistantMessage, Model } from "../types.js";
 /**
  * Whether DSML leak recovery applies to `model`: a DeepSeek-class model, or one
  * explicitly configured with the `dsml` stream healer (e.g. a `models.yml` entry
- * whose id the classifier cannot place). Other models never write DSML tool
- * calls, so DSML text from them is prose and is left alone.
+ * whose id the classifier cannot place). Other models never write DeepSeek tool
+ * calls, so such markup from them is prose and is left alone.
  */
 export declare function isDsmlLeakRecoveryTarget(model: Model): boolean;
 /**
- * Strip leaked DSML tool-call markup from `text`, leaving quoted code intact.
- * Returns `undefined` when `text` carries no such markup.
+ * Strip leaked DeepSeek tool-call markup (DSML or chat-template tokens) from
+ * `text`, leaving quoted code intact. Returns `undefined` when `text` carries
+ * no such markup.
  */
 export declare function stripDsmlToolMarkup(text: string): string | undefined;
 /**
- * Remove leaked DSML tool-call markup from `message`'s text blocks in place,
- * dropping blocks left empty. Returns true when anything was removed.
+ * Remove leaked DSML tool-call markup from an assistant message before commit,
+ * including reasoning blocks and turns with valid structured calls. Rewritten
+ * thinking with an opaque signature is discarded; OpenAI-compatible reasoning
+ * field names are replay markers, not signatures, and survive cleanup.
  */
 export declare function removeDsmlToolMarkupLeak(message: AssistantMessage): boolean;

package/dist/types/utils/narration.d.ts

@@ -0,0 +1,9 @@
+import type { AssistantMessage } from "../types.js";
+/**
+ * The message as a user-facing surface should present it: every narration
+ * thinking block (see `ThinkingContent.narration`) becomes a text block, so it
+ * renders as part of the answer instead of folding into reasoning. Returns the
+ * input unchanged when it holds no narration. Display-only: replay must keep
+ * the original thinking blocks and their signatures.
+ */
+export declare function presentNarrationAsAnswer(message: AssistantMessage): AssistantMessage;

package/dist/types/utils/openai-http.d.ts

@@ -26,6 +26,8 @@ export interface OpenAIStreamRequestInit {
     body: unknown;
     signal: AbortSignal;
     fetch?: FetchImpl;
+    /** Override the default transport attempt budget for this request. */
+    maxAttempts?: number;
     /** Optional caller-specific gate composed with shared transport retry exclusions. */
     shouldRetryResponse?: (response: Response, bodyText: string) => boolean | Promise<boolean>;
     /**

package/dist/types/utils/request-body.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bytes of a request body as the server reads them: the `gzip`/`zstd`
+ * `Content-Encoding` applied by request compression is undone, any other
+ * encoding is returned untouched.
+ */
+export declare function decodeRequestBodyBytes(bytes: Uint8Array, contentEncoding: string | null): Uint8Array;
+/**
+ * Text of a string or byte request body after undoing its content encoding;
+ * `undefined` when the request has no such body (none, stream, form data).
+ */
+export declare function requestBodyText(init: RequestInit | undefined): string | undefined;

package/dist/types/utils/request-compression.d.ts

@@ -0,0 +1,21 @@
+import type { FetchImpl, Model } from "../types.js";
+/**
+ * Compresses request bodies from {@link model} to its provider's own endpoint
+ * when its catalog rules declare encodings the endpoint decodes
+ * (`request-encodings` / `endpoint-hosts` KDL axes). Long sessions resend
+ * multi-MB transcripts every turn, so upload time dominates time-to-first-token
+ * on ordinary uplinks.
+ *
+ * Install it beneath any body rewriter or signer (e.g. the cch attestation
+ * patch): those must see the uncompressed bytes. Other hosts, small bodies,
+ * bodies that already carry `Content-Encoding`, and `PI_REQUEST_COMPRESSION=0`
+ * pass through untouched. A possible rejection — the host's decode error, or a
+ * non-JSON 400/403/415 from a proxy in front of it — is resent uncompressed
+ * once; only when that resend succeeds is the encoding latched off for the
+ * host, so a genuine 400 never disables compression. When a non-JSON refusal
+ * recurs uncompressed with the same status and a non-JSON body, that status
+ * stops being re-checked for the host.
+ */
+export declare function wrapFetchForRequestCompression(base: FetchImpl, model: Model): FetchImpl;
+/** Test hook: clears every per-host latch. */
+export declare function resetRequestCompressionForTesting(): void;

package/dist/types/utils/tool-call-arguments.d.ts

@@ -5,7 +5,8 @@ export declare function parseToolCallArguments(json: string | undefined): ToolCa
  * Native Responses `function_call.arguments` to persist for replay.
  *
  * {@link parseToolCallArguments} repairs some invalid JSON (e.g. `"name": ,`) and the tool runs with the
- * repaired value; replay drops a call whose stored arguments do not parse, orphaning its output (#14155).
+ * repaired value; replay must carry what was executed (#14155), not the {@link invalidToolCallArguments}
+ * diagnostic it substitutes for stored arguments that do not parse (#15568).
  * Returns `raw` when it already parses or the arguments were unrepairable, else the executed arguments.
  */
 export declare function replayableToolCallArguments(raw: string, executed: ToolCall["arguments"]): string;

package/dist/types/utils/transport-fetch.d.ts

@@ -12,6 +12,14 @@ import type { Api, FetchImpl, Model } from "../types.js";
  * layer (three PI_REQ_DEBUG dumps for one request).
  */
 export declare function transportFetch(model: Model<Api>, fetchImpl: FetchImpl | undefined): FetchImpl;
+/**
+ * Origin of the last inference request {@link model} actually sent, after
+ * every dispatch-time rewrite (credential endpoints, env overrides, regional
+ * hosts); `undefined` before its first request.
+ */
+export declare function lastDispatchOrigin(model: Model<Api>): string | undefined;
+/** Test hook: forgets every recorded dispatch origin. */
+export declare function resetDispatchOriginsForTesting(): void;
 /** Options-bag form of {@link transportFetch}; returns `options` untouched when its fetch is already built. */
 export declare function withTransportFetch<T extends {
     fetch?: FetchImpl;

package/dist/types/utils.d.ts

@@ -1,4 +1,5 @@
 import type { ResponseInput } from "./providers/openai-responses-wire.js";
+export { normalizeToolCallId } from "./providers/transform-messages.js";
 import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types.js";
 export { isRecord } from "@linxiraos/pi-utils";
 /**
@@ -9,7 +10,6 @@ export { isRecord } from "@linxiraos/pi-utils";
  */
 export declare function getHeaderCaseInsensitive(headers: Record<string, string> | undefined, headerName: string): string | undefined;
 export declare function normalizeSystemPrompts(systemPrompt: readonly string[] | string | undefined | null): string[];
-export declare function normalizeToolCallId(id: string): string;
 type ResponsesToolItemIdPrefix = "fc" | "ctc";
 /** Preserve opaque call IDs for Responses replay while normalizing or generating the separate item ID. */
 export declare function normalizeResponsesToolCallId(id: string, itemPrefix?: ResponsesToolItemIdPrefix): {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@linxiraos/pi-ai",
-	"version": "1.2.1",
+	"version": "1.3.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -145,18 +145,18 @@
 	},
 	"scripts": {
 		"check": "oxlint . && oxfmt --check --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts' && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check:types": "tsc -p tsconfig.json --noEmit",
 		"lint": "oxlint .",
 		"test": "bun test --parallel",
 		"fix": "oxlint --fix --fix-suggestions . && bun run fmt",
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@linxiraos/pi-omptype": "1.2.1",
-		"@linxiraos/pi-catalog": "1.2.1",
-		"@linxiraos/pi-natives": "1.2.1",
-		"@linxiraos/pi-utils": "1.2.1",
-		"@linxiraos/pi-wire": "1.2.1"
+		"@linxiraos/pi-omptype": "1.3.1",
+		"@linxiraos/pi-catalog": "1.3.1",
+		"@linxiraos/pi-natives": "1.3.1",
+		"@linxiraos/pi-utils": "1.3.1",
+		"@linxiraos/pi-wire": "1.3.1"
 	},
 	"devDependencies": {
 		"@types/bun": "1.4.3"

package/src/auth/cascade.ts

@@ -10,6 +10,7 @@ import type { CredentialPool } from "./pool";
 import type { CredentialSelector, OAuthResolutionResult } from "./select";
 import type {
 	AuthApiKeyOptions,
+	AuthPeekOptions,
 	AuthCredential,
 	AuthSource,
 	AuthSourceOptions,
@@ -275,9 +276,11 @@ export class KeyCascade implements KeysApi {
 	 * Used for model discovery where we only need to know if credentials exist
 	 * and get a best-effort token. GitHub Copilot's peek must preserve
 	 * enterprise routing metadata because discovery needs a structured
-	 * credential to reach the correct host.
+	 * credential to reach the correct host. With several stored accounts every
+	 * peek returns the same one, so credential-scoped discovery caches stay on
+	 * one namespace.
 	 */
-	async peek(provider: string): Promise<string | undefined> {
+	async peek(provider: string, options?: AuthPeekOptions): Promise<string | undefined> {
 		const runtimeKey = this.#deps.overrides.runtimeKey(provider);
 		if (runtimeKey) {
 			return runtimeKey;
@@ -292,19 +295,26 @@ export class KeyCascade implements KeysApi {
 
 		// Precedence: a deliberate OAuth/login credential wins, then an explicit env var,
 		// then a stored static api_key (which may be a stale broker-migrated copy) as a last resort.
-		const oauthSelection = this.#deps.selector.selectByType(provider, "oauth");
+		// Peek never refreshes, so only an unexpired OAuth access token is usable
+		// unless the caller only needs the account it names.
+		const now = Date.now();
+		const oauthSelection =
+			this.#deps.selector.selectByType(
+				provider,
+				"oauth",
+				undefined,
+				credential =>
+					credential.type === "oauth" && Number.isFinite(credential.expires) && credential.expires > now,
+			) ?? (options?.includeExpired ? this.#deps.selector.selectByType(provider, "oauth") : undefined);
 		if (oauthSelection) {
-			const expiresAt = oauthSelection.credential.expires;
-			if (Number.isFinite(expiresAt) && expiresAt > Date.now()) {
-				if (provider === "github-copilot") {
-					return JSON.stringify({
-						token: oauthSelection.credential.access,
-						enterpriseUrl: oauthSelection.credential.enterpriseUrl,
-						apiEndpoint: oauthSelection.credential.apiEndpoint,
-					});
-				}
-				return oauthSelection.credential.access;
+			if (provider === "github-copilot") {
+				return JSON.stringify({
+					token: oauthSelection.credential.access,
+					enterpriseUrl: oauthSelection.credential.enterpriseUrl,
+					apiEndpoint: oauthSelection.credential.apiEndpoint,
+				});
 			}
+			return oauthSelection.credential.access;
 		}
 
 		const loginApiKeySelection = this.#deps.selector.selectByType(

package/src/auth/pool.ts

@@ -182,7 +182,7 @@ export class CredentialPool implements CredentialsApi {
 	 * The store is shared across every zeta process, but the pool is an
 	 * in-process cache refreshed only by this process's own writes. Without
 	 * this a long-running session ranks a stale pool for its whole lifetime:
-	 * `zeta-c auth` in another terminal is invisible, rotation reports no usable
+	 * `zetacode auth` in another terminal is invisible, rotation reports no usable
 	 * sibling while a freshly added account sits unblocked in SQLite, and the
 	 * turn degrades to the fallback chain. The auth-broker path already polls;
 	 * direct-store sessions had no equivalent.
@@ -719,7 +719,7 @@ export class CredentialPool implements CredentialsApi {
 	}
 
 	/**
-	 * Disabled credential tombstones for display surfaces (`zeta-c usage`,
+	 * Disabled credential tombstones for display surfaces (`zetacode usage`,
 	 * broker `GET /v1/credentials/disabled`). Empty when the backing store
 	 * keeps no tombstones or the remote broker predates the endpoint.
 	 */
@@ -732,7 +732,7 @@ export class CredentialPool implements CredentialsApi {
 	 * Force the backing store to revalidate its credential snapshot, then
 	 * reload. Remote broker stores re-fetch the snapshot; local stores are
 	 * always current, so only the reload runs. Callers that pair live
-	 * per-credential data with stored identities (`zeta-c usage`) use this so a
+	 * per-credential data with stored identities (`zetacode usage`) use this so a
 	 * disk-cached snapshot cannot misattribute fresh reports.
 	 */
 	async revalidate(): Promise<void> {