@linxiraos/pi-ai 1.1.26 → 1.2.0

package/dist/types/judgment/question-file.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Judge questions authored as JSON files: `instructions` plus optional
+ * `criteria`, keyed by question id. A JSON import widens every string, so a
+ * question's kind follows from the shape of its `criteria` rather than a
+ * `type` field — the same rule at compile time ({@link QuestionFor}) and at
+ * load ({@link judgeQuestions}):
+ * - a list of levels, lowest first → {@link ScoreQuestion}
+ * - absent, or only `true`/`false` rubrics → {@link NoulQuestion}
+ * - any other labels → {@link ChoiceQuestion} over them; `{}` when the caller
+ *   supplies every label (table rows, labels shared with another question)
+ *
+ * Instructions may be Handlebars templates; {@link renderQuestion} fills them.
+ *
+ * @example
+ * ```ts ignore
+ * import graph from "./auto-graph.json" with { type: "json" };
+ * const QUESTIONS = judgeQuestions(graph);
+ * QUESTIONS.shading; // ChoiceQuestion<"shared" | "series" | "row">
+ * renderQuestion(QUESTIONS.order, { column: "latency" });
+ * ```
+ */
+import { prompt } from "@linxiraos/pi-utils";
+import type { ChoiceQuestion, NoulQuestion, Question, ScoreQuestion } from "./types.js";
+/** One question as a JSON question file writes it; {@link QuestionFor} gives its kind. */
+export interface QuestionSpec {
+    instructions: string;
+    criteria?: string[] | {
+        readonly [label: string]: string | null;
+    };
+}
+/** A JSON question file: {@link QuestionSpec}s keyed by question id. */
+export interface QuestionFile {
+    readonly [id: string]: QuestionSpec;
+}
+/** The question a {@link QuestionSpec} declares, with choice labels taken from its criteria keys. */
+export type QuestionFor<S extends QuestionSpec> = S extends {
+    criteria: string[];
+} ? ScoreQuestion : S extends {
+    criteria: infer C extends object;
+} ? [keyof C] extends [never] ? ChoiceQuestion : [keyof C] extends ["true" | "false"] ? NoulQuestion : ChoiceQuestion<Extract<keyof C, string>> : NoulQuestion;
+/** Every question a {@link QuestionFile} declares, keyed as in the file. */
+export type QuestionsFor<F extends QuestionFile> = {
+    [K in keyof F]: QuestionFor<F[K]>;
+};
+/**
+ * The typed questions of a JSON question file; answers to them come back typed
+ * through {@link JudgmentResult}.
+ * @throws when a score question lists fewer than two levels.
+ */
+export declare function judgeQuestions<F extends QuestionFile>(file: F): QuestionsFor<F>;
+/** `question` with its instructions rendered as a Handlebars template over `context`. */
+export declare function renderQuestion<Q extends Question>(question: Q, context: prompt.TemplateContext): Q;

package/dist/types/judgment/systemone.d.ts

@@ -0,0 +1,7 @@
+import { type JudgmentWire } from "./wire.js";
+/** TypeSafe's own route, shared by every System One server. */
+export declare const typesafeWire: JudgmentWire;
+/** OpenRouter Decisions: the System One body under `/api/alpha`. */
+export declare const openrouterDecisionsWire: JudgmentWire;
+/** Cloudflare Workers AI decision models (Clef) through the account-scoped `ai/run` route. */
+export declare const workersAiWire: JudgmentWire;

package/dist/types/judgment/types.d.ts

@@ -7,7 +7,7 @@
  * — about one {@link JudgmentState}. Every question in a request sees the same
  * state and is answered independently, so callers batch independent questions
  * into one call. The shape mirrors TypeSafe's System One API so the native
- * backend ({@link TypeSafeJudge}) forwards requests verbatim, while the text
+ * backend ({@link NativeJudge}) forwards requests verbatim, while the text
  * bridge ({@link TextJudge}) renders the same questions into keyword prompts
  * for an ordinary chat model.
  */
@@ -75,7 +75,7 @@ export interface JudgmentRequest<Q extends Questions = Questions> {
     questions: Q;
 }
 export interface JudgmentResult<Q extends Questions = Questions> {
-    /** Transport that produced the answers (`typesafe`, or the chat model's api). */
+    /** Transport that produced the answers (a judgment api such as `typesafe`, or the chat model's api). */
     api: string;
     provider: string;
     model: string;

package/dist/types/judgment/wire.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Wire dialects of the native judgment APIs: how {@link NativeJudge} addresses,
+ * encodes, and decodes one request for each API it serves. Internal to the
+ * judgment module; `native.ts` maps every judgment API to its dialect.
+ */
+import type { Usage } from "../types.js";
+import type { JudgmentRequest } from "./types.js";
+/** Where one attempt posts and which bearer token it sends. */
+export interface JudgmentTarget {
+    url: string;
+    token: string;
+}
+/** One decoded response. */
+export interface DecodedJudgment {
+    /** Model that answered, when the response names one. */
+    model: string | undefined;
+    /** Wire answers keyed by question id; {@link NativeJudge} checks each against its question's type. */
+    answers: Readonly<Record<string, unknown>>;
+    /** Question ids the model declined to answer. */
+    refused: readonly string[];
+    usage: Usage;
+}
+/** How one judgment API addresses, encodes, and decodes a request. */
+export interface JudgmentWire {
+    /**
+     * Target of one attempt made with credential `key` against `model`.
+     * Throws when the credential cannot address the endpoint (e.g. no account id).
+     */
+    target(baseUrl: string, model: string, key: string): JudgmentTarget;
+    /** Request body for `model`. */
+    encode(request: JudgmentRequest, model: string): unknown;
+    /** The response's answers and usage; `undefined` when the payload is not this API's response shape. */
+    decode(payload: unknown): DecodedJudgment | undefined;
+}
+/** `value` when it is a finite number. */
+export declare function finiteNumber(value: unknown): number | undefined;

package/dist/types/provider-details.d.ts

@@ -14,7 +14,7 @@ export interface ProviderDetailsContext {
     authMode?: string;
     /**
      * Human-readable description of the active credential, e.g.
-     * `"broker http://omp.internal:8765 · oauth #5 (foo@bar.com)"`.
+     * `"broker http://zeta.internal:8765 · oauth #5 (foo@bar.com)"`.
      * Rendered as a `Source` field; omitted when undefined.
      */
     credentialSource?: string;

package/dist/types/provider-session-state.d.ts

@@ -18,8 +18,8 @@
  *   siblings are endpoint-scoped and stay: `strictToolsDisabled`
  *   (grammar-too-large 400 for the model's tool schema),
  *   `replayUnsignedThinkingDisabled` / `thinkingReplayDisabled` (the endpoint
- *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks the API itself
- *   dropped).
+ *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a prefix-binding
+ *   400 made the client strip).
  * - **OpenAI Responses** — the `previous_response_id` chain baselines are
  *   account-scoped: a stored response belongs to the account that created it.
  *   Strict-tools / reasoning-effort fallbacks, replay warmup and the chaining

package/dist/types/providers/anthropic-client.d.ts

@@ -94,6 +94,13 @@ export interface AnthropicMessagesClientLike {
             create(params: MessageCreateParams, options?: AnthropicRequestOptions): unknown;
         };
     };
+    /**
+     * Endpoint the client targets, when it exposes one. SDK-style clients
+     * (`Anthropic`, `AnthropicVertex`) and {@link AnthropicMessagesClient}
+     * publish it; a client that exposes none keeps its transport opaque, and the
+     * provider must not assume the model's own routing on its behalf.
+     */
+    baseURL?: string;
 }
 export declare class AnthropicMessagesClient implements AnthropicMessagesClientLike {
     #private;
@@ -101,12 +108,15 @@ export declare class AnthropicMessagesClient implements AnthropicMessagesClientL
     readonly beta: {
         readonly messages: AnthropicMessages;
     };
+    /** Endpoint shared with the HTTP transport. */
+    get baseURL(): string;
     constructor(options: AnthropicClientOptions);
     request(path: string, params: MessageCreateParams, options?: AnthropicRequestOptions): AnthropicApiRequest;
 }
 /** Shared Anthropic HTTP transport for Messages and resource APIs. */
 export declare class AnthropicHttpClient {
     #private;
+    readonly baseURL: string;
     constructor(options: AnthropicClientOptions);
     request(method: "GET" | "POST", path: string, params?: unknown, options?: AnthropicRequestOptions): Promise<Response>;
 }

package/dist/types/providers/anthropic-state.d.ts

@@ -1,6 +1,8 @@
 import type { Api, Model, ProviderSessionState } from "../types.js";
 /** Root key for Anthropic's per-session provider state. */
 export declare const ANTHROPIC_PROVIDER_SESSION_STATE_KEY = "anthropic-messages";
+/** Caller-map anchor for session-scoped opaque injected clients. */
+export declare const ANTHROPIC_OPAQUE_CLIENT_ANCHOR_KEY = "anthropic-opaque-clients";
 /** Normalize an Anthropic base URL to its origin path without `/v1`. */
 export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
 /** Resolve the endpoint for a first-party Anthropic model without loading its provider implementation. */

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

@@ -1,4 +1,5 @@
-import type { AnthropicOutputEffort, FetchImpl, Message, Model, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types.js";
+import type { Effort } from "@linxiraos/pi-catalog/effort";
+import type { AnthropicCompactionRequest, AnthropicOutputEffort, FetchImpl, Message, Model, ServiceTier, SimpleStreamOptions, StreamFunction, StreamOptions, Usage } from "../types.js";
 import { type AnthropicFetchOptions, type AnthropicMessagesClientLike } from "./anthropic-client.js";
 import { type FallbackParam, type MessageParam, type TextBlockParam } from "./anthropic-wire.js";
 import { resolvesToOfficialAnthropicEndpoint, supportsAnthropicCompaction, supportsAnthropicCompactionOnClient } from "./anthropic-compaction.js";
@@ -134,6 +135,13 @@ export type AnthropicClientOptionsArgs = {
     thinkingEnabled?: boolean;
     thinkingDisplay?: AnthropicThinkingDisplay;
     disableStrictTools?: boolean;
+    /**
+     * Withhold the prompt-cache betas (see `buildClaudeCodeBetas`). Set when the
+     * request carries no breakpoint at all, and also when it carries breakpoints
+     * stripped of `ttl`/`scope`: both betas govern those options, so a body
+     * without them must advertise neither.
+     */
+    dropPromptCacheBetas?: boolean;
     fetch?: FetchImpl;
     maxRetryDelayMs?: number;
     sessionId?: string;
@@ -168,6 +176,12 @@ export type AnthropicClientOptionsResult = {
  * omitted there.
  */
 export declare function resolveAnthropicCustomHeadersForBaseUrl(baseUrl: string | undefined): Record<string, string> | undefined;
+/**
+ * Merge headers case-insensitively; later sources win and preserve their key casing.
+ * Undefined sources are ignored. Differently cased duplicates are removed so the
+ * Headers constructor cannot join competing values comma-separated on the wire.
+ */
+export declare function mergeHeaders(...headerSources: (Record<string, string> | undefined)[]): Record<string, string>;
 export type AnthropicUsageLike = {
     cache_creation?: {
         ephemeral_5m_input_tokens?: number | null;
@@ -209,10 +223,19 @@ export type AnthropicSystemBlock = {
 type SystemBlockOptions = {
     includeClaudeCodeInstruction?: boolean;
     extraInstructions?: string[];
-    /** Text of the first user message — used as fingerprint seed for the billing header. */
+    /** Text of the first conversational wire user turn, used as the billing fingerprint seed. */
     firstUserMessageText?: string;
-    /** Cache lifetime shared by the OAuth system breakpoint and later message breakpoints. */
+    /**
+     * Cache lifetime shared by the OAuth system breakpoint and later message
+     * breakpoints. Omitted → the identity block keeps its default `ephemeral`
+     * breakpoint; see `dropCacheControl` to emit none at all.
+     */
     cacheControl?: AnthropicCacheControl;
+    /**
+     * Emit no `cache_control` on any block: the endpoint rejected the field.
+     * Distinct from an undefined `cacheControl`, which only means "default".
+     */
+    dropCacheControl?: boolean;
 };
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];
@@ -234,6 +257,16 @@ export declare function budgetThinkingOutput(maxTokens: number | undefined, budg
     maxTokens: number;
     budgetTokens: number;
 };
+/**
+ * The effort whose thinking allowance an on-demand compaction request over
+ * `messages` gets. It sends no effort change of its own, so once an earlier
+ * request recorded an effort, the one it left in force applies, even when
+ * `requested` differs or is off. When that request named none, the API's
+ * per-model default applies, which is not known here: the request gets the
+ * largest effort's allowance (`max_tokens` is a cap, not spend). Without a
+ * recorded effort the request sets its own.
+ */
+export declare function resolveAnthropicCompactionEffort(model: Model<"anthropic-messages">, messages: readonly Message[], requested: Effort | undefined): Effort | undefined;
 /**
  * Whether the conversation has stopped being thinking-led, so routes with
  * `compat.stripThinkingHistory` drop the budget `thinking` config and replay
@@ -269,5 +302,7 @@ export declare function convertAnthropicMessages(messages: Message[], model: Mod
     dropAllThinking?: boolean;
     droppedThinkingBlocks?: ReadonlySet<string>;
     credentialId?: number;
+    /** On-demand compaction request: it ends inside the conversation, so it gets nothing live requests lack there. */
+    compactionRequest?: AnthropicCompactionRequest;
 }): AnthropicMessageParam[];
 export declare function normalizeAnthropicToolSchema(schema: unknown): unknown;

package/dist/types/providers/aws-credentials.d.ts

@@ -29,14 +29,10 @@ export interface CredentialResolveOptions {
     fetch?: FetchImpl;
 }
 export declare function resolveAwsCredentials(opts?: CredentialResolveOptions): Promise<ResolvedCredentials>;
-/** POSIX-shell-style tokenizer used by the AWS CLI for `credential_process`.
- *
- * Outside quotes a backslash escapes the next character. Inside single quotes
- * everything is literal (no escapes, cannot contain `'`). Inside double quotes
- * a backslash only escapes `$`, `` ` ``, `"`, and `\` — every other backslash
- * is preserved verbatim, which is what makes Windows paths like
- * `"C:\Program Files\tool\auth.exe"` survive tokenization. */
-export declare function tokenizeCredentialProcessCommand(cmd: string): string[];
+/** Split a `credential_process` command into argv the way botocore's
+ * `compat_shell_split` does: Windows command-line (CRT) rules on `win32`,
+ * POSIX shell rules everywhere else. */
+export declare function tokenizeCredentialProcessCommand(cmd: string, platform?: NodeJS.Platform): string[];
 /** Test/diagnostic helper — drops cached credentials. */
 export declare function clearAwsCredentialCache(): void;
 /**

package/dist/types/providers/connect-error-detail.d.ts

@@ -4,6 +4,15 @@
  * usable is present.
  */
 export declare function summarizeConnectErrorDetails(details: unknown): string | undefined;
+/**
+ * True when Cursor's `aiserver.v1.ErrorDetails` entry declares the failure
+ * retryable. Its JSON `debug` form carries `details.isRetryable` — set on
+ * upstream outages such as ERROR_OPENAI ("Unable to reach the model
+ * provider") whose bare `code: message` text (`unavailable: Error`)
+ * classifies as a hard failure on its own. Other detail types are ignored
+ * even when they share the `debug.details` shape.
+ */
+export declare function hasRetryableCursorErrorDetail(details: unknown): boolean;
 /**
  * Formats a Connect end-stream error object into a diagnosable message.
  * The "Connect error code: message" prefix is preserved exactly; detail

package/dist/types/providers/connect-frame.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Connect-protocol streaming envelope shared by the Cursor and Devin
+ * transports: 1 flag byte + 4-byte big-endian payload length + payload.
+ */
+/** Flag bit: payload is compressed with the negotiated encoding (gzip). */
+export declare const CONNECT_COMPRESSED_FLAG = 1;
+/** Flag bit: payload is the end-of-stream JSON trailer. */
+export declare const CONNECT_END_STREAM_FLAG = 2;
+/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
+export declare function frameConnectMessage(data: Uint8Array, flags?: number): Buffer;
+/** One decoded Connect envelope. */
+export interface ConnectFrame {
+    flags: number;
+    payload: Buffer;
+}
+/** Options for {@link ConnectFrameDecoder}. */
+export interface ConnectFrameDecoderOptions {
+    /**
+     * Payload cap: a length prefix above `maxPayloadBytes` throws `error(length)`
+     * before any of that payload is buffered. Uncapped when omitted.
+     */
+    limit?: {
+        maxPayloadBytes: number;
+        error: (length: number) => Error;
+    };
+}
+/**
+ * Incremental Connect frame decoder. Incoming chunks are kept as-is and a frame
+ * spanning several chunks is joined once, when the length the header announced
+ * has fully arrived — re-concatenating the pending bytes on every chunk made a
+ * multi-MB frame cost O(size × chunks).
+ *
+ * Payloads alias the chunk they came from whenever a frame fits in one chunk,
+ * so callers must not reuse chunk buffers they hand in.
+ */
+export declare class ConnectFrameDecoder {
+    #private;
+    constructor(options?: ConnectFrameDecoderOptions);
+    /**
+     * Buffer `chunk` (if any) and yield every frame now complete, in wire order.
+     * An oversize length prefix throws after the frames that precede it.
+     */
+    decode(chunk?: Uint8Array): Generator<ConnectFrame, void, undefined>;
+}

package/dist/types/providers/cursor/interaction-query.d.ts

@@ -7,8 +7,6 @@ type ProtoUnknownField = {
 interface CursorInteractionWriter {
     write(frame: Uint8Array): void;
 }
-/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
-export declare function frameConnectMessage(data: Uint8Array, flags?: number): Buffer;
 /** Well-formed protobuf-es `$unknown` entries on `message`; anything else on the bag is ignored. */
 export declare function protoUnknownFields(message: object): ProtoUnknownField[];
 /**

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

@@ -169,13 +169,13 @@ export declare function emptyGrepPatternRejection(pattern: string | undefined, g
  * so reparsing unconditionally would erase the arguments of every such block
  * caught open by a truncated stream.
  *
- * Server-owned blocks are also paired here. `connect-scm` and `todo` are
- * stamped {@link kCursorExecResolved} the moment they open, so `agent-loop.ts`
- * synthesizes no placeholder for them and only their `toolCallCompleted` frame
- * pairs a result. A transport that closes before that frame would leave the
- * call unpaired, and `buildSessionContext` strips a dangling call from every
- * rebuilt transcript — the interaction disappears. An interrupted result is
- * emitted instead.
+ * Server-owned blocks are also paired here. `connect-scm`, `todo` and
+ * `web-fetch` are stamped {@link kCursorExecResolved} the moment they open,
+ * so `agent-loop.ts` synthesizes no placeholder for them and only their
+ * `toolCallCompleted` frame pairs a result. A transport that closes before
+ * that frame would leave the call unpaired, and `buildSessionContext` strips
+ * a dangling call from every rebuilt transcript — the interaction disappears.
+ * An interrupted result is emitted instead.
  *
  * MCP blocks are excluded even when resolved: the exec dispatch that marked
  * them owns their result, and `drainInFlightDispatches` awaits it before this
@@ -228,7 +228,7 @@ export declare function processInteractionUpdate(update: any, output: AssistantM
 /**
  * Cursor AgentService reconstructs the model prompt from `requestContext.rules`,
  * not from the client-supplied `rootPromptMessagesJson` system blobs. Map each
- * ZETA system-prompt entry to a global CursorRule so always-apply rules survive
+ * OMP system-prompt entry to a global CursorRule so always-apply rules survive
  * that reconstruction.
  */
 export declare function buildCursorRequestContextRules(systemPrompt: readonly string[] | undefined): CursorRule[];

package/dist/types/providers/google-auth.d.ts

@@ -5,13 +5,16 @@
  * Sources, in priority order:
  *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange)
  *     or `type: "authorized_user"` (refresh-token exchange).
- *   2. `~/.config/gcloud/application_default_credentials.json` (user ADC, same authorized_user flow).
+ *   2. gcloud user ADC: `%APPDATA%\gcloud\application_default_credentials.json` on Windows,
+ *     `~/.config/gcloud/application_default_credentials.json` elsewhere (authorized_user flow).
  *   3. GCE / Cloud Run metadata server (`metadata.google.internal`).
  *
  * Tokens are cached per source key and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` before expiry
  * (default 60s). Concurrent callers waiting on a refresh share the same in-flight promise.
  */
 import type { FetchImpl } from "../types.js";
+/** gcloud's user ADC file: `%APPDATA%\gcloud\…` on Windows, `~/.config/gcloud/…` elsewhere. */
+export declare function userAdcPath(platform?: typeof process.platform, appData?: string | undefined): string;
 /**
  * Returns a Bearer access token suitable for the `Authorization` header on Vertex AI calls.
  * The token is cached in module scope and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` ms before it expires.

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

@@ -145,6 +145,22 @@ export declare function pushBlockEndEvent(block: TextContent | ThinkingContent,
  * before invoking — this helper does not mutate `output.content`.
  */
 export declare function pushToolCallEvents(toolCall: ToolCall, contentIndex: number, output: AssistantMessage, stream: AssistantMessageEventStream): void;
+/** How {@link GoogleTextBlocks} keeps thought text: healed of leaked fence delimiters (#8719), or as received. */
+export type GoogleThoughtText = "healed" | "verbatim";
+/**
+ * Folds streamed generateContent text and thought parts into text and thinking
+ * blocks, opening a new block whenever the part kind changes. A part's
+ * `thoughtSignature` stays on the block it belongs to; the empty text part
+ * Gemini sends after a reply's last chunk signs the open block.
+ */
+export declare class GoogleTextBlocks {
+    #private;
+    constructor(output: AssistantMessage, stream: AssistantMessageEventStream, thoughtText: GoogleThoughtText);
+    /** Folds one response part; parts without text are ignored. */
+    push(part: Part): void;
+    /** Ends the open block, releasing thinking text the fence stripper held back. */
+    close(): void;
+}
 /**
  * Append a new text- or thinking-block to `output.content` and push the matching
  * `text_start` / `thinking_start` event. `onBeforeStartEvent` lets the SSE consumer
@@ -153,6 +169,13 @@ export declare function pushToolCallEvents(toolCall: ToolCall, contentIndex: num
 export declare function startTextOrThinkingBlock(isThinking: true, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): ThinkingContent;
 export declare function startTextOrThinkingBlock(isThinking: false, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent;
 export declare function startTextOrThinkingBlock(isThinking: boolean, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent | ThinkingContent;
+/**
+ * Error for an in-band `error` frame in a 200 generateContent stream. Keeps the
+ * RPC status alongside the message: an in-band quota failure is classified
+ * from this text, and `RESOURCE_EXHAUSTED` is the only account-exhaustion
+ * signal some of these chunks carry (#13090).
+ */
+export declare function googleStreamChunkError(error: NonNullable<GenerateContentResponse["error"]>, provider: string): Error;
 /**
  * Drives the chunked `generateContentStream` iterator into an `AssistantMessage` and
  * the corresponding `AssistantMessageEventStream`. Shared between `streamGoogle` and
@@ -163,7 +186,7 @@ export declare function startTextOrThinkingBlock(isThinking: boolean, output: As
  * pushing `start`/`done`/`error` events, and the surrounding try/catch that translates
  * thrown errors into `output.stopReason`/`errorMessage`.
  *
- * This helper handles: the chunk loop, currentBlock flush transitions, usage metadata
+ * This helper handles: the chunk loop, text/thinking blocks ({@link GoogleTextBlocks}), usage metadata
  * decoding (`calculateCost` included), tool-call id collision avoidance, finish-reason
  * mapping, and the abort/stop-reason post-checks that re-throw to bubble into the
  * caller's catch.
@@ -176,8 +199,6 @@ export declare function consumeGoogleStream<T extends GoogleApiType>(args: {
     options: {
         signal?: AbortSignal;
     } | undefined;
-    /** Vertex preserves `textSignature` on streamed text deltas; google-generative-ai does not. */
-    retainTextSignature?: boolean;
     onFirstToken?: () => void;
 }): Promise<void>;
 /**
@@ -210,7 +231,6 @@ export declare function streamGoogleGenAI<T extends "google-generative-ai" | "go
     model: Model<T>;
     options: GoogleSharedStreamOptions | undefined;
     api: T;
-    retainTextSignature?: boolean;
     prepare: () => GoogleGenAIRequestPlan | Promise<GoogleGenAIRequestPlan>;
 }): AssistantMessageEventStream;
 /**

package/dist/types/providers/inference-headers.d.ts

@@ -7,6 +7,12 @@ export interface InferenceHeaderOptions {
 }
 /** Set a header unless the map already contains that field under any casing. */
 export declare function setHeaderIfAbsent(headers: Record<string, string>, name: string, value: string): void;
+/**
+ * Label a request with the conversation id under the model's resolved
+ * `compat.sessionHeader` (KDL `session-header`). A header the caller or config
+ * already set wins; without a conversation id nothing is sent.
+ */
+export declare function applySessionHeader(headers: Record<string, string> | Headers, compat: object | undefined, sessionId: string | undefined): void;
 /**
  * Project omp's identity and authoritative conversation id onto the headers
  * understood by the active inference protocol and host.

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

@@ -41,7 +41,7 @@
  *   // Inspect calls afterwards.
  *   expect(mock.calls).toHaveLength(2);
  */
-import type { AnthropicFallbackCreditHandle, Api, Context, Model, SimpleStreamOptions, StopDetails, StopReason, Usage } from "../types.js";
+import type { AnthropicFallbackCreditHandle, Api, Context, Model, ServiceTier, SimpleStreamOptions, StopDetails, StopReason, Usage } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 /** The API string this provider serves. */
 export declare const MOCK_API: "mock";
@@ -78,6 +78,8 @@ export interface MockResponse {
     usage?: Partial<Omit<Usage, "cost">> & {
         cost?: Partial<Usage["cost"]>;
     };
+    /** Service tier the mock reports serving the turn, as a real provider's response echo would. */
+    serviceTier?: ServiceTier;
     /** Pre-set responseId. */
     responseId?: string;
     /** If set, the stream emits a terminal error event instead of completing. */

package/dist/types/providers/openai-codex/request-transformer.d.ts

@@ -78,6 +78,8 @@ export interface RequestBody {
  * explicit option; normal inference defaults to the full Responses contract.
  */
 export declare function resolveCodexResponsesLite(requested: boolean | undefined): boolean;
+/** Wire tier of the model's lowest effort, which a `minimizeEffort` request runs at. */
+export declare function lowestCodexWireEffort(model: Model<"openai-codex-responses">): ReasoningConfig["effort"] | undefined;
 /**
  * Repair both halves of unpaired tool exchanges so the Responses input grammar
  * stays valid — the API rejects either orphan with a 400:

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

@@ -148,7 +148,7 @@ export declare function buildTransformedCodexRequestBody(model: Model<"openai-co
  */
 export declare function openCodexCompactionEventStream(model: Model<"openai-codex-responses">, body: OpenAICodexCompactionBody, options: OpenAICodexCompactionStreamOptions): Promise<AsyncGenerator<Record<string, unknown>>>;
 export declare const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses">;
-export declare function prewarmOpenAICodexResponses(model: Model<"openai-codex-responses">, options?: Pick<OpenAICodexResponsesOptions, "apiKey" | "headers" | "sessionId" | "signal" | "preferWebsockets" | "providerSessionState" | "responsesLite">): Promise<void>;
+export declare function prewarmOpenAICodexResponses(model: Model<"openai-codex-responses">, options?: Pick<OpenAICodexResponsesOptions, "apiKey" | "headers" | "sessionId" | "signal" | "preferWebsockets" | "providerSessionState" | "responsesLite" | "serviceTier">): Promise<void>;
 export interface OpenAICodexTransportDetails {
     websocketPreferred: boolean;
     lastTransport?: CodexTransport;

package/dist/types/providers/openai-configuration-update.d.ts

@@ -1,6 +1,6 @@
 /**
  * Mid-conversation reasoning effort via `configuration_update` input items
- * (GPT-6 Astra; `model.compat.supportsConfigurationUpdate`).
+ * (GPT-6 family; `model.compat.supportsConfigurationUpdate`).
  *
  * The request-level `reasoning.effort` is pinned to the value of the session's
  * first request so the cached prompt prefix survives an effort change. Each
@@ -12,10 +12,12 @@
  * planning.
  *
  * Used by both the platform Responses provider and the Codex provider; the
- * state lives in each provider's session state, keyed per conversation.
+ * state lives in each provider's session state, keyed per conversation. A side
+ * request plans against a copy of its parent conversation's state (see
+ * {@link resolveOpenAIEffortControlState}), so it sends the parent's prefix.
  *
- * Wire constraints (verified against the Codex backend): only `gpt-6-astra`
- * accepts the item type, consecutive updates are rejected, and
+ * Wire constraints (OpenAI reasoning guide): the GPT-6 family supports the item
+ * in standard (not `pro`) reasoning mode, adjacent updates are rejected, and
  * `/responses/compact` rejects histories containing them — compaction
  * requests are built outside this planner and never carry the items.
  */
@@ -35,16 +37,21 @@ interface EffortTransition<TEffort extends string> {
 }
 /** Per-conversation effort baseline and recorded transitions. */
 export interface OpenAIEffortControlState<TEffort extends string = string> {
+    sessionId: string;
     baseEffort?: TEffort;
     currentEffort?: TEffort;
     transitions: EffortTransition<TEffort>[];
 }
-export declare function createOpenAIEffortControlState<TEffort extends string>(): OpenAIEffortControlState<TEffort>;
+export declare function createOpenAIEffortControlState<TEffort extends string>(sessionId: string): OpenAIEffortControlState<TEffort>;
 /**
- * Fetch (or create) the control state for one conversation from a provider's
- * bounded per-session map, refreshing its LRU slot.
+ * Control state a Responses or Codex request plans against. A side request
+ * (`parentSessionId`) gets a throwaway copy of its parent's state, fresh when
+ * the parent has none: it replays the parent's updates, and its own effort
+ * change never reaches the parent. Other requests get their session's state.
  */
-export declare function getOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, key: string): OpenAIEffortControlState<TEffort>;
+export declare function resolveOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, keyOf: (sessionId: string) => string, sessionId: string, parentSessionId: string | undefined): OpenAIEffortControlState<TEffort>;
+/** Release one conversation's effort state from the Responses and Codex `releaseSession` implementations. */
+export declare function releaseOpenAIEffortControlSession<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, sessionId: string): void;
 interface AnchorableItem {
     type?: string | null;
     role?: string;
@@ -57,8 +64,10 @@ interface AnchorableItem {
  *
  * `input` is the freshly built transcript for this request, without any
  * `configuration_update` items. `requested` is the wire effort the caller
- * would otherwise send at the request level. Returns the effort to send at the
- * request level (`requested` on the first request, the baseline afterwards).
+ * would otherwise send at the request level. `minimized` replaces it once a
+ * baseline exists, where the change rides an update and keeps the cached
+ * prefix; a request that sets the baseline runs at `requested`. Returns the
+ * effort to send at the request level (the baseline).
  */
-export declare function planStableOpenAIEffort<TItem extends AnchorableItem, TEffort extends string>(state: OpenAIEffortControlState<TEffort>, input: Array<TItem | ConfigurationUpdateItem>, requested: TEffort): TEffort;
+export declare function planStableOpenAIEffort<TItem extends AnchorableItem, TEffort extends string>(state: OpenAIEffortControlState<TEffort>, input: Array<TItem | ConfigurationUpdateItem>, requested: TEffort, minimized?: TEffort): TEffort;
 export {};