@oh-my-pi/pi-ai 18.0.10 → 18.1.0

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [18.1.0] - 2026-09-01
+
+### Added
+
+- Added an optional `completeSimple` callback that observes every result, including results from internal thinking-loop retries.
+- Added compatibility options for Anthropic-compatible proxies that reject `context_management` and OpenAI Responses proxies that provide incomplete reasoning-summary streams.
+- Added ClinePass API-key authentication via the official `CLINE_API_KEY` environment variable, with account validation, actionable subscription and quota errors, support for eligible ClinePass model rosters, and rolling quota-window reporting in `omp usage`.
+- Added Devin router-model support, including assignment of the concrete model before each request, routed-model metadata, credit usage reporting, and plan, quota-window, and account details through `omp usage`.
+
+### Changed
+
+- Provider behavior is now driven by each model's resolved compatibility, identity, thinking, and behavior policies rather than model-name matching, improving support for model-specific request formatting, vision, reasoning, routing, pricing, and quota handling.
+- Devin integrations now use the current released CLI identity and support parallel tool calls when the model declares that capability.
+
+### Fixed
+
+- Fixed OpenAI remote-compaction replay for persisted sessions, allowing sessions with previously stored compaction items to resume successfully.
+- Fixed Cursor Fable requests failing when advertised tools used JSON Schema composition keywords.
+- Fixed Z.AI (GLM Coding Plan) browser sign-in by using the registered CLI callback address.
+- Fixed OpenAI Codex/Responses tool results being lost when composite call identifiers could not be paired with the corresponding assistant call.
+- Fixed native OpenAI Responses history replay becoming stuck on malformed or truncated function-call arguments; invalid history items are now discarded so the session can recover.
+
+## [18.0.11] - 2026-08-29
+
+### Fixed
+
+- Fixed automatic session retries for Anthropic-compatible streams that end prematurely without a completion signal.
+- Fixed Gemini 3.x tool-call continuations through OpenAI-compatible endpoints.
+- Fixed credential fallback for HTTP 402 payment-required and deactivated-workspace responses, preventing them from being misclassified as quota exhaustion.
+- Fixed Perplexity email sign-in for accounts protected by authenticator-based two-factor authentication.
+- Fixed Qianfan API-key login validation for keys that cannot access the validation model.
+- Fixed Z.AI browser sign-in to report an occupied callback port before opening the browser.
+
 ## [18.0.9] - 2026-08-28
 
 ### Fixed
@@ -2004,7 +2037,7 @@
 - Fixed Anthropic-compatible proxies that omit `usage`/`delta` objects from `message_start`/`message_delta`/`content_block_*` envelopes crashing the turn with an unretryable `TypeError`; the missing payloads now degrade to logged envelope anomalies like every other malformed-frame case.
 - Fixed `applyPromptCaching` placing `cache_control` on `thinking`/`redacted_thinking` blocks — Anthropic rejects that with a 400. A thinking-only assistant turn inside the trailing cache window (e.g. followed by the synthetic `Continue.` pad) no longer receives a breakpoint.
 - Fixed consecutive `assistant` params reaching the wire when an empty user/developer turn between two assistant turns was dropped by the converter (e.g. an empty "nudge" submission after a length-truncated reply); Anthropic 400s on non-alternating assistant turns, and the broken triple replayed on every subsequent request. A `user: "Continue."` separator is now inserted, mirroring the trailing-prefill fallback.
-- Fixed `supportsAdaptiveThinkingDisplay` misparsing bare dated Opus ids: `claude-opus-4-20250514` (Opus 4.0) parsed as minor `20250514` ≥ 4.7, which silently dropped the `interleaved-thinking-2025-05-14` beta for API-key Opus 4.0 requests.
+- Fixed adaptive-display classification misparsing bare dated Opus ids: `claude-opus-4-20250514` (Opus 4.0) parsed as minor `20250514` ≥ 4.7, which silently dropped the `interleaved-thinking-2025-05-14` beta for API-key Opus 4.0 requests.
 - Fixed `output_config.effort` shipping without the `effort-2025-11-24` beta on thinking-off requests against adaptive-only Claude models (the effort:"low" pin), and the mid-conversation `system` role shipping without `mid-conversation-system-2026-04-07` on API-key and OAuth-utility requests; both betas are now added whenever the request can carry the corresponding field.
 - Fixed GitHub Copilot anthropic-messages requests going out with no `Content-Type` and no `anthropic-version` header — the copilot branch builds its headers from scratch and Bun's fetch does not default `Content-Type` for string bodies. Both headers are now pinned to match every other branch.
 - Fixed Anthropic client/provider retry multiplication: with the first-event watchdog disabled (`PI_STREAM_FIRST_EVENT_TIMEOUT_MS=0`), the client's internal `maxRetries: 5` reactivated and stacked with the provider loop's 3 retries — up to 24 wire attempts with double backoff. The provider now pins per-request `maxRetries: 0` unconditionally.

package/dist/types/auth-storage.d.ts

@@ -3,7 +3,7 @@ import type { OAuthAuthInfo, OAuthController, OAuthCredentials, OAuthProviderId
 import type { Provider } from "./types.js";
 import type { ClientUsageIdentity, ClientUsageReport, ClientUsageSummary, CredentialRankingStrategy, ObservedUsageEntry, UsageHistoryEntry, UsageHistoryQuery, UsageLogger, UsageProvider, UsageReport } from "./usage.js";
 import { type CodexResetConsumeCode, type CodexResetCredit } from "./usage/openai-codex-reset.js";
-export { isSqliteBusyError, isSqliteCorruptionError, SqliteAuthCredentialStore, } from "./auth/sqlite-credential-store.js";
+export { isSqliteBusyError, isSqliteCorruptionError, SqliteAuthCredentialStore } from "./auth/sqlite-credential-store.js";
 export type ApiKeyCredential = {
     type: "api_key";
     key: string;

package/dist/types/error/flags.d.ts

@@ -80,6 +80,13 @@ export declare function isGrammarError(error: unknown): boolean;
  * Accessor for {@link Flag.FastModeUnsupported}.
  */
 export declare function isFastModeUnsupported(error: unknown): boolean;
+/**
+ * Cline's gateway gates some roster entries (certain free-tier models) to its
+ * own product surfaces with a 403. The API key is valid — the restriction is
+ * per-model client policy — so it must neither rotate sibling credentials (they
+ * fail identically) nor surface as an auth failure.
+ */
+export declare function isClinePassSurfaceGateMessage(errorMessage: string | undefined): boolean;
 /**
  * GitHub Copilot 400 `model_not_supported` response for a model advertised by
  * `/models` — transient fleet skew, not a malformed request. Reads the

package/dist/types/error/rate-limit.d.ts

@@ -24,13 +24,15 @@ export declare function calculateRateLimitBackoffMs(reason: RateLimitReason): nu
 /**
  * HTTP status codes that, absent richer body classification, represent an
  * account-local usage cap rather than a bad credential or a transient blip.
- * HTTP 402 Payment Required is categorically an account-billing cap (xAI
+ * HTTP 402 Payment Required represents an account-billing cap (xAI
  * Grok Build "usage balance exhausted", DeepSeek "Insufficient Balance",
- * OpenRouter credit exhaustion) — never a transient blip or bad credential.
- * Always combine with {@link isUsageLimitOutcome} when a message is available
- * — a 429 carrying transient rate-limit wording is NOT a usage cap.
+ * OpenRouter credit exhaustion) when opaque, payment/deactivation/balance-worded,
+ * or QUOTA_EXHAUSTED/CONCURRENT_LIMIT, while informative non-quota 402s (e.g.
+ * endpoint subscription requirements) remain non-usage-limits. Always combine
+ * with {@link isUsageLimitOutcome} when a message is available.
  */
 export declare function isUsageLimitStatus(status: number | undefined): boolean;
+export declare function is402BillingCapBody(message: string | undefined): boolean;
 /**
  * Returns true for failures that should burn one credential and rotate to a
  * sibling account. Decision tree:
@@ -43,13 +45,13 @@ export declare function isUsageLimitStatus(status: number | undefined): boolean;
  *     empty JSON, HTTP framing only) → rotate conservatively: the server
  *     gave us nothing else to go on.
  *  4. Body has content → defer to {@link parseRateLimitReason}. `QUOTA_EXHAUSTED`
- *     rotates; for the categorical 402 billing cap a `CONCURRENT_LIMIT` body
- *     also rotates (the cap is concurrent-worded but the status is still an
- *     exhausted billing cap). `RATE_LIMIT_EXCEEDED` (`Too many requests`,
- *     per-minute caps), `MODEL_CAPACITY_EXHAUSTED` (`Service overloaded`),
- *     `SERVER_ERROR`, and `UNKNOWN` (`Please retry in 5s`) stay in the
- *     provider's own backoff layer so transient 429s don't burn sibling
- *     credentials.
+ *     rotates; for a 402 status a `CONCURRENT_LIMIT` body also rotates (the cap
+ *     is concurrent-worded but the status is an exhausted billing cap).
+ *     `RATE_LIMIT_EXCEEDED` (`Too many requests`, per-minute caps),
+ *     `MODEL_CAPACITY_EXHAUSTED` (`Service overloaded`), `SERVER_ERROR`, and
+ *     `UNKNOWN` (e.g. "A subscription is required for this endpoint" or
+ *     "Please retry in 5s") stay in the provider's own backoff / failure
+ *     layer so transient or non-quota responses don't burn sibling credentials.
  */
 export declare function isUsageLimitOutcome(status: number | undefined, message: string | undefined): boolean;
 /**
@@ -78,6 +80,6 @@ export declare function isAccountScopedCapText(message: string): boolean;
 /**
  * A concurrency cap on a non-billing status is shed-and-backoff, not
  * credential-rotatable. This mirrors the exclusion in {@link isUsageLimitOutcome}
- * for the 403 auth-retry entry points. A 402 remains a categorical billing cap.
+ * for the 403 auth-retry entry points. A 402 remains an account-billing cap.
  */
 export declare function isConcurrencyCapExclusion(status: number | undefined, message: string | undefined): boolean;

package/dist/types/providers/gitlab-duo.d.ts

@@ -1,27 +1,7 @@
+import { getGitLabDuoModels } from "@oh-my-pi/pi-catalog/provider-models";
 import type { Api, Context, Model, SimpleStreamOptions } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
-type GitLabProvider = "anthropic" | "openai";
-type GitLabOpenAIApiType = "chat" | "responses";
-export type GitLabModelMapping = {
-    provider: GitLabProvider;
-    model: string;
-    openaiApiType?: GitLabOpenAIApiType;
-    name: string;
-    reasoning: boolean;
-    input: ("text" | "image")[];
-    cost: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-    };
-    contextWindow: number;
-    maxTokens: number;
-};
-export declare const MODEL_MAPPINGS: Record<string, GitLabModelMapping>;
-export declare function getModelMapping(modelId: string): GitLabModelMapping | undefined;
-export declare function getGitLabDuoModels(): Model<Api>[];
+export { getGitLabDuoModels };
 export declare function clearGitLabDuoDirectAccessCache(): void;
 export declare function isGitLabDuoModel(model: Model<Api>): boolean;
 export declare function streamGitLabDuo(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
-export {};

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

@@ -13,7 +13,7 @@ import type { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { type OpenAIAnthropicApiFormat, type OpenAIAnthropicShimOptions } from "./openai-anthropic-shim.js";
 export type KimiApiFormat = OpenAIAnthropicApiFormat;
 export interface KimiOptions extends OpenAIAnthropicShimOptions {
-    /** Explicit API format override. Defaults to the model's discovered protocol. */
+    /** Explicit API format override. Defaults to the model's resolved protocol policy. */
     format?: KimiApiFormat;
 }
 /**

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

@@ -150,6 +150,7 @@ export declare class MockModel implements Model<MockApi> {
     readonly contextWindow: number;
     readonly maxTokens: number;
     readonly compat: undefined;
+    readonly identity: Model["identity"];
     /** Recorded calls in invocation order. */
     readonly calls: MockCall[];
     iterator?: Iterator<MockHandler> | AsyncIterator<MockHandler>;

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

@@ -20,6 +20,7 @@ export declare const NO_AUTH_SENTINEL = "N/A";
 export interface OpenAIModelIdentity {
     provider: string;
     id: string;
+    identity?: Model["identity"];
     baseUrl?: string;
 }
 export interface OpenAIStrictToolsScope {
@@ -68,7 +69,7 @@ export interface OpenAIRequestSetup {
 export declare function resolveOpenAIRequestSetup(model: OpenAIRequestSetupModel, options: OpenAIRequestSetupOptions): OpenAIRequestSetup;
 export declare function applyOpenAIServiceTier(params: {
     service_tier?: ServiceTier | null | undefined;
-}, serviceTier: ServiceTier | null | undefined, model: Pick<Model, "provider" | "api" | "id">): void;
+}, serviceTier: ServiceTier | null | undefined, model: Pick<Model, "provider" | "api" | "identity">): void;
 /**
  * Adjust resolved cost by the service tier OpenAI actually billed — parity with
  * Codex (`applyCodexServiceTierPricing`), but with the standard (non-Codex)
@@ -77,9 +78,9 @@ export declare function applyOpenAIServiceTier(params: {
  * Responses biller) so an echoed `service_tier` from an Azure/OpenRouter/Copilot
  * proxy can never skew those costs.
  */
-export declare function applyOpenAIResponsesServiceTierCost(model: Pick<Model, "provider">, usage: AssistantMessage["usage"], responseServiceTier: unknown, requestServiceTier: ServiceTier | null | undefined): void;
-/** Reconcile token-price estimates with OpenRouter's authoritative account charge. */
-export declare function applyOpenRouterReportedCost(model: Pick<Model, "provider">, usage: Usage, rawUsage: unknown): void;
+export declare function applyOpenAIResponsesServiceTierCost(model: Pick<Model, "provider" | "serviceTierCost">, usage: AssistantMessage["usage"], responseServiceTier: unknown, requestServiceTier: ServiceTier | null | undefined): void;
+/** Reconcile token-price estimates with a gateway's authoritative account charge. */
+export declare function applyProviderReportedCost(model: Pick<Model, "provider">, usage: Usage, rawUsage: unknown): void;
 export interface OpenAIUsageAccountingInput {
     promptTokens: number;
     outputTokens: number;
@@ -112,7 +113,6 @@ export declare function clearOpenAIStrictToolsState(state: OpenAIStrictToolsStat
 export declare function getOpenAIStrictToolsScope(model: OpenAIModelIdentity, resolvedBaseUrl: string | undefined): OpenAIStrictToolsScope;
 export declare function isStrictToolsDisabledForScope(state: OpenAIStrictToolsState | undefined, scope: OpenAIStrictToolsScope | undefined): boolean;
 export declare function disableStrictToolsForScope(state: OpenAIStrictToolsState | undefined, scope: OpenAIStrictToolsScope | undefined): void;
-export declare function isOpenRouterAnthropicModel(model: OpenAIModelIdentity): boolean;
 /**
  * Append an OpenRouter routing-variant suffix (e.g. `:nitro`, `:floor`, `:online`, `:exacto`)
  * to a model id when no explicit variant is already present. A variant is considered
@@ -240,8 +240,8 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
     };
     reasoning?: {
         effort?: string;
-    } | {
-        enabled: false;
+        enabled?: boolean;
+        max_tokens?: number;
     };
     venice_parameters?: {
         disable_thinking?: boolean;
@@ -262,6 +262,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
 export interface ChatCompletionsReasoningOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     disableReasoning?: boolean;
+    thinkingBudgets?: Partial<Record<Effort, number>>;
 }
 export type OpenAICompatEndpoint = "chat-completions" | "responses";
 export type OpenAIReasoningDisableReason = "caller" | "forced-tool-choice" | "tool-choice" | "not-requested";
@@ -348,9 +349,9 @@ export declare function disableChatCompletionsReasoningForDialect(params: OpenAI
  * Provider-specific Chat Completions output clamp.
  *
  * Most OpenAI-compatible endpoints retain the conservative 64k ceiling from
- * {@link resolveOpenAIOutputTokenParam}. Z.AI/GLM-5.2 reasoning and native
- * Moonshot K3 explicitly accept their full advertised model caps, so those
- * routes clamp to `model.maxTokens` instead.
+ * {@link resolveOpenAIOutputTokenParam}. ClinePass, Z.AI/GLM-5.2 reasoning,
+ * and native Moonshot K3 explicitly accept their full advertised model caps,
+ * so those routes clamp to `model.maxTokens` instead.
  */
 export declare function resolveOpenAICompletionsOutputClamp(model: Model<"openai-completions">, compat: ResolvedOpenAICompat): number | undefined;
 /**
@@ -645,7 +646,7 @@ type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK"
  * can let the upstream apply its own default instead of 400-ing on `maxTokens` values that
  * reflect the model's context window rather than the upstream output limit.
  */
-export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, model: Pick<Model, "provider" | "api" | "id" | "omitMaxOutputTokens" | "maxTokens"> & {
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, model: Pick<Model, "provider" | "api" | "id" | "omitMaxOutputTokens" | "maxTokens" | "identity"> & {
     compat: Pick<ResolvedOpenAISharedCompat, "supportsSamplingParams" | "supportsPenaltyAndStopParams">;
 }): void;
 type ReasoningOptions = {
@@ -654,6 +655,15 @@ type ReasoningOptions = {
     disableReasoning?: boolean;
     toolChoice?: unknown;
 };
+/**
+ * Resolve the caller's reasoning-summary request against catalog compat.
+ * Hosts that reject `reasoning.summary` get an explicit `null` (wire omission)
+ * whenever reasoning is engaged, so the policy never fills the `"auto"` default.
+ */
+export declare function resolveReasoningSummaryOption(model: Model<"openai-responses" | "azure-openai-responses" | "openai-codex-responses">, options: {
+    reasoning?: string;
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+} | undefined): "auto" | "detailed" | "concise" | null | undefined;
 export interface ApplyResponsesCompatPolicyOptions {
     reasoningSummary?: "auto" | "detailed" | "concise" | null;
     mapEffort?: (effort: string) => string;

package/dist/types/providers/vision-guard.d.ts

@@ -6,32 +6,6 @@ export declare function partitionVisionContent(content: ReadonlyArray<TextConten
     omittedImages: boolean;
 };
 export declare function joinTextWithImagePlaceholder(text: string, omittedImages: boolean): string;
-/**
- * Detect known text-only Qwen models served via Alibaba DashScope's consumer
- * `compatible-mode` endpoint that the upstream chat-completions API rejects
- * multimodal content arrays for. The compatible-mode endpoint also serves
- * multimodal Qwen SKUs without `vl` in the id (e.g. `qwen3.7-plus`), so this
- * guard only covers families verified to be text-only for issue #1859:
- * `qwen*-coder*` and `qwen*-max` up to and including `qwen3.7-max`.
- *
- * Qwen-Max became multimodal at `qwen3.8-max` (image input, issue #8019), so
- * `-max` SKUs at version 3.8 or newer are excluded — otherwise the override
- * would strip images from a genuinely vision-capable flagship (issue #8305).
- *
- * Used as a defensive override in `convertMessages` so a misconfigured custom
- * provider (issue #1859) can't drive the request into an unrecoverable 400.
- */
-export declare function isDashscopeCompatibleModeTextOnlyQwen(model: Model<"openai-completions">): boolean;
-/**
- * Detect known text-only DeepSeek models served via OpenAI-compatible Chat
- * Completions endpoints whose server-side deserializers reject `image_url`
- * content parts with HTTP 400 (`unknown variant \`image_url\`, expected \`text\``).
- *
- * Used as a defensive override in `convertMessages` so misconfigured model
- * definitions or user overrides (e.g. `models.yml` claiming `input: [text, image]`)
- * do not crash the session with an unrecoverable 400.
- */
-export declare function isTextOnlyDeepSeek(model: Model<"openai-completions">): boolean;
 /**
  * Evaluates whether an OpenAI-compatible Chat Completions model genuinely
  * supports multimodal image inputs on the wire. Defensive guards override

package/dist/types/registry/api-key-login.d.ts

@@ -11,6 +11,10 @@ type ChatCompletionsValidation = {
     provider: string;
     baseUrl: string;
     model: string;
+    /** Treat an authenticated 401 (`invalid_model`) as a valid key. */
+    tolerateModelDenied?: boolean;
+    maxTokensField?: "max_tokens" | "max_completion_tokens";
+    maxTokens?: number;
 };
 type AnthropicMessagesValidation = {
     kind: "anthropic-messages";

package/dist/types/registry/api-key-validation.d.ts

@@ -4,8 +4,11 @@ type OpenAICompatibleValidationOptions = {
     apiKey: string;
     baseUrl: string;
     model: string;
+    maxTokensField?: "max_tokens" | "max_completion_tokens";
+    maxTokens?: number;
     signal?: AbortSignal;
     fetch?: FetchImpl;
+    tolerateModelDenied?: boolean;
 };
 type AnthropicCompatibleValidationOptions = {
     provider: string;

package/dist/types/registry/cline-pass.d.ts

@@ -0,0 +1,7 @@
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+export declare const loginClinePass: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const clinePassProvider: {
+    readonly id: "cline-pass";
+    readonly name: "ClinePass";
+    readonly login: (callbacks: OAuthLoginCallbacks) => Promise<string>;
+};

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

@@ -69,6 +69,10 @@ declare const ALL: ({
     readonly id: "cerebras";
     readonly name: "Cerebras";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "cline-pass";
+    readonly name: "ClinePass";
+    readonly login: (callbacks: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "cloudflare-ai-gateway";
     readonly name: "Cloudflare AI Gateway";
@@ -365,7 +369,7 @@ declare const ALL: ({
     readonly id: "zai-coding-plan";
     readonly name: "Z.AI (GLM Coding Plan · Sign in)";
     readonly storeCredentialsAs: "zai";
-    readonly callbackPort: 54548;
+    readonly callbackPort: 9999;
     readonly pasteCodeFlow: true;
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string | import("./oauth/index.js").OAuthCredentials>;
 } | {

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

@@ -9,7 +9,7 @@ export declare const zaiCodingPlanProvider: {
     readonly id: "zai-coding-plan";
     readonly name: "Z.AI (GLM Coding Plan · Sign in)";
     readonly storeCredentialsAs: "zai";
-    readonly callbackPort: 54548;
+    readonly callbackPort: 9999;
     readonly pasteCodeFlow: true;
     readonly login: (cb: OAuthLoginCallbacks) => Promise<string | import("./oauth/index.js").OAuthCredentials>;
 };

package/dist/types/stream.d.ts

@@ -46,7 +46,10 @@ export declare function listProvidersWithEnvKey(): string[];
 export declare function stream<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): AssistantMessageEventStream;
 export declare function complete<TApi extends Api>(model: Model<TApi>, context: Context, options?: OptionsForApi<TApi>): Promise<AssistantMessage>;
 export declare function streamSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
-export declare function completeSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): Promise<AssistantMessage>;
+export declare function completeSimple<TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions & {
+    /** Receives every completed result, including results retried by the thinking-loop guard. */
+    onAttempt?: (message: AssistantMessage) => void;
+}): Promise<AssistantMessage>;
 export declare const OUTPUT_FALLBACK_BUFFER = 4000;
 export declare const ANTHROPIC_THINKING: Record<Effort, number>;
 export declare function mapAnthropicToolChoice(choice?: ToolChoice): AnthropicOptions["toolChoice"];

package/dist/types/types.d.ts

@@ -103,7 +103,7 @@ export type ServiceTierFamily = "openai" | "anthropic" | "google";
  * models mid-session.
  */
 export type ServiceTierByFamily = Partial<Record<ServiceTierFamily, ServiceTier>>;
-type ServiceTierModel = Pick<Model, "provider" | "api" | "id">;
+type ServiceTierModel = Pick<Model, "provider" | "api" | "identity">;
 /**
  * Classify a model into the service-tier family whose knob governs it, or
  * `undefined` when the model exposes no serving-priority control.
@@ -120,7 +120,7 @@ export declare function serviceTierFamily(model: ServiceTierModel): ServiceTierF
  * Reduce a per-family tier map to the single wire tier for `model` — the entry
  * for the model's family, or `undefined` when the model has no family.
  */
-export declare function resolveModelServiceTier(tiers: ServiceTierByFamily | null | undefined, model: Pick<Model, "provider" | "api" | "id">): ServiceTier | undefined;
+export declare function resolveModelServiceTier(tiers: ServiceTierByFamily | null | undefined, model: ServiceTierModel): ServiceTier | undefined;
 /**
  * True when the tier should be sent on the wire as the provider's service-tier
  * request field. `auto` is never forwarded — it is OpenAI's implicit default, so
@@ -139,7 +139,7 @@ export declare function shouldSendServiceTier(serviceTier: ServiceTier | null |
  * Google-family upstreams. Bedrock/Vertex Claude and OpenRouter Anthropic
  * models do not realize priority and return `false`.
  */
-export declare function realizesPriorityServiceTier(serviceTier: ServiceTier | null | undefined, model: Pick<Model, "provider" | "api" | "id">): boolean;
+export declare function realizesPriorityServiceTier(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel): boolean;
 /**
  * Premium-request weight contributed by a priority request to a provider that
  * realizes it and bills extra. Mirrors GitHub Copilot's `premiumRequests`
@@ -152,7 +152,7 @@ export declare function realizesPriorityServiceTier(serviceTier: ServiceTier | n
  * Copilot-premium semantics — as are Bedrock/Vertex Claude, where priority is
  * silently dropped.
  */
-export declare function getPriorityPremiumRequests(serviceTier: ServiceTier | null | undefined, model: Pick<Model, "provider" | "api" | "id">): number;
+export declare function getPriorityPremiumRequests(serviceTier: ServiceTier | null | undefined, model: ServiceTierModel): number;
 /**
  * Coerce a persisted service-tier value to a {@link ServiceTierByFamily}. Newer
  * sessions store the family map directly; legacy sessions stored a single
@@ -760,6 +760,8 @@ export interface AssistantMessage {
      * providers that expose no such field.
      */
     upstreamProvider?: string;
+    /** Provider-reported concrete model when a router selected one for this turn. */
+    upstreamModel?: string;
     usage: Usage;
     stopReason: StopReason;
     stopDetails?: StopDetails | null;

package/dist/types/usage/cline-pass.d.ts

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

package/dist/types/usage/devin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Devin (Codeium Cascade) account plan + credit usage provider.
+ *
+ * Devin ships no REST usage endpoint: plan tier, credit balances, the
+ * daily/weekly quota windows and the account identity all come back from the
+ * single `SeatManagementService/GetUserStatus` unary Connect RPC the native CLI
+ * issues at startup. The request body is raw (unframed) protobuf carrying the
+ * CLI identity metadata plus the session token; the backend gates the CLI
+ * surface on that identity tuple.
+ */
+import type { UsageProvider } from "../usage.js";
+export declare const devinUsageProvider: UsageProvider;

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

@@ -1,3 +1,12 @@
+/**
+ * GPT-5 Harmony-header leakage detection and recovery.
+ *
+ * Background and policy: see `docs/ERRATA-GPT5-HARMONY.md`. This module
+ * implements §3 of that document: detection by signal fusion, plus a
+ * truncate-and-resume primitive for the `edit` tool when its input is in
+ * hashline DSL form. Other tools and surfaces fall through to
+ * abort-and-retry handled by the agent loop.
+ */
 import type { AssistantMessage, Model, ToolCall } from "../types.js";
 /**
  * Escape reserved Harmony control tokens in arbitrary text so it can be
@@ -59,10 +68,10 @@ export interface HarmonyRecoveredToolCall {
     removed: string;
 }
 /**
- * Whether to run leak detection on responses from this model. We default-on
- * for every openai-codex model rather than enumerating ids, so a future
- * gpt-5.6 (or whatever) doesn't silently bypass the mitigation. Detection
- * itself is cheap; the cost of missing a leak on a new model is not.
+ * Whether to run leak detection on responses from this model. The default-on policy
+ * lives on the harmony-leak-mitigation axis in providers/openai-codex.kdl.
+ * It targets the provider rather than enumerating model ids so future models
+ * do not silently bypass this cheap mitigation.
  */
 export declare function isHarmonyLeakMitigationTarget(model: Model): boolean;
 export declare function signalListLabel(signals: readonly HarmonySignal[]): string;

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

@@ -47,3 +47,22 @@ export declare function finalizeErrorMessage(error: unknown, rawRequestDump: Raw
  *       do NOT reuse the auth-failed string (which triggers credential removal).
  */
 export declare function rewriteCopilotError(errorMessage: string, error: unknown, provider: string): string;
+/**
+ * Rewrite error messages for ClinePass request failures. Gated to the
+ * cline-pass provider: the "model not found" marker is too generic to match
+ * for other hosts.
+ *
+ * not-subscribed (400) = the key is valid but the account has no ClinePass
+ *        subscription; free-tier models remain usable on the same key.
+ * org restriction (400) = organization accounts cannot use individual
+ *        inference subscriptions; a personal-account key is required.
+ * model-not-found (400) = roster rotation removed the model since selection;
+ *        the fix is reselection, not retry. (Quota windows — "clinepass
+ *        limit", "free limit reached on model" — are classified upstream in
+ *        error/rate-limit and need no rewrite.)
+ * surface-gate (403) = the model is restricted to Cline's official clients.
+ *        Requests carry the mirrored CLI identity headers, so reaching this
+ *        means Cline's gate policy changed; the classifier exempts it from
+ *        credential rotation (sibling keys fail identically).
+ */
+export declare function rewriteClinePassError(errorMessage: string, provider: string): string;

package/dist/types/utils/schema/normalize.d.ts

@@ -40,6 +40,16 @@ export declare function copySchemaWithout(schema: JsonObject, combiner: string):
  * create new anyOf in merged subtrees after child normalization already ran.
  */
 export declare function stripResidualCombiners(value: unknown, epoch?: number): unknown;
+/**
+ * Project a tool's wire schema onto the subset Cursor's MCP tool catalog
+ * accepts. Cursor rejects the entire request with a provider 400 when any
+ * advertised schema carries a composition keyword (issue #10432); this removes
+ * `anyOf`/`oneOf`/`allOf` everywhere while preserving representable guidance and
+ * only ever widening acceptance, so every input the canonical schema accepts is
+ * still accepted by the advertised projection. The canonical schema (used for
+ * execution-time argument validation) is never mutated.
+ */
+export declare function sanitizeSchemaForCursor(schema: JsonObject): JsonObject;
 export declare function normalizeSchema(value: unknown, options: NormalizeSchemaOptions): unknown;
 export declare function normalizeSchemaForGoogle(value: unknown): unknown;
 export declare function normalizeSchemaForCCA(value: unknown): unknown;

package/dist/types/utils/schema/strict-tool-validation.d.ts

@@ -10,12 +10,12 @@
  *
  * xAI additionally rejects a leftover *root* `anyOf`/`oneOf` whose branches
  * are not objects ("tool parameter root must be an object type"). That class
- * is opt-in via {@link FindStrictToolSchemaViolationOptions.rejectXaiRootObjectUnion}
+ * is opt-in via {@link FindStrictToolSchemaViolationOptions.rejectRootObjectUnion}
  * so OpenAI/Azure/Codex keep valid object-root unions.
  */
 export interface FindStrictToolSchemaViolationOptions {
-    /** xAI (paid + OAuth) only: leftover object-root unions 400 the whole turn. */
-    rejectXaiRootObjectUnion?: boolean;
+    /** Reject leftover object-root unions; xAI (paid + OAuth) 400s the whole turn when they remain. */
+    rejectRootObjectUnion?: boolean;
 }
 /**
  * Walk a tool parameter schema for OpenAI-strict `enum`/`const`-vs-`type`

package/dist/types/utils/stream-markup-healing.d.ts

@@ -6,6 +6,7 @@
  * dialect scanners used by owned in-band tool calling; this file keeps the
  * provider-facing compatibility wrapper and model/provider gating.
  */
+import type { Model } from "../types.js";
 export interface HealedToolCall {
     readonly id: string;
     readonly name: string;
@@ -73,10 +74,6 @@ export declare class StreamMarkupHealing {
     /** True once any configured tool-call section/envelope has fully closed. */
     get sectionClosed(): boolean;
 }
-/** Cheap model/provider gate for Kimi-K2 chat-template token leaks. */
-export declare function modelMayLeakKimiToolCalls(provider: string, modelId: string): boolean;
-/** Cheap model/provider gate for DeepSeek DSML envelope leaks. */
-export declare function modelMayLeakDsmlToolCalls(provider: string, modelId: string): boolean;
 /**
  * Pick the leaked-markup healer for an OpenAI-compatible / Ollama visible-text
  * stream. Kimi chat-template tokens and DeepSeek DSML envelopes need their
@@ -84,4 +81,4 @@ export declare function modelMayLeakDsmlToolCalls(provider: string, modelId: str
  * patterns run the generic {@link ThinkingInbandScanner}, so leaked reasoning
  * idioms (e.g. a Gemini ` ```thinking ` fence on OpenRouter) are always healed.
  */
-export declare function getStreamMarkupHealingPattern(provider: string, modelId: string): StreamMarkupHealingPattern;
+export declare function getStreamMarkupHealingPattern(model: Model<"ollama-chat">): StreamMarkupHealingPattern;

package/dist/types/utils/thinking-loop.d.ts

@@ -5,12 +5,9 @@ import { AssistantMessageEventStream } from "./event-stream.js";
  *  classifiers treat it as a transient (retryable) stop without bespoke rules. */
 export declare const THINKING_LOOP_ERROR_MARKER = "Thinking loop detected";
 /**
- * True when `model.id` belongs to a family guarded by the semantic loop
- * heuristics: Gemini, DeepSeek, or Grok. Exact suffix-cycle detection applies to
- * every enabled model independently of this predicate.
- *
- * Model identity is derived only from its id; provider and compatibility metadata
- * do not opt opaque aliases into semantic detection.
+ * True when resolved compatibility policy enables semantic loop heuristics for
+ * this model. Exact suffix-cycle detection applies to every enabled model
+ * independently of this predicate.
  */
 export declare function isLoopGuardedModel(model: Model<Api>, options?: StreamOptions): boolean;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.0.10",
+	"version": "18.1.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -29,18 +29,18 @@
 	"main": "./src/index.ts",
 	"types": "./dist/types/index.d.ts",
 	"scripts": {
-		"check": "biome check . && bun run check:types",
+		"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",
-		"lint": "biome lint .",
+		"lint": "oxlint .",
 		"test": "bun test --parallel",
-		"fix": "biome check --write --unsafe .",
-		"fmt": "biome format --write ."
+		"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": {
-		"@oh-my-pi/omptype": "18.0.10",
-		"@oh-my-pi/pi-catalog": "18.0.10",
-		"@oh-my-pi/pi-utils": "18.0.10",
-		"@oh-my-pi/pi-wire": "18.0.10"
+		"@oh-my-pi/omptype": "18.1.0",
+		"@oh-my-pi/pi-catalog": "18.1.0",
+		"@oh-my-pi/pi-utils": "18.1.0",
+		"@oh-my-pi/pi-wire": "18.1.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth-broker/client.ts

@@ -445,7 +445,7 @@ export class AuthBrokerClient {
 	): Promise<Response> {
 		const auth = opts.auth ?? true;
 		const url = `${this.#baseUrl}${path}`;
-		const headers: Record<string, string> = { Accept: "application/json", ...(opts.headers ?? {}) };
+		const headers: Record<string, string> = { Accept: "application/json", ...opts.headers };
 		if (auth) headers.Authorization = `Bearer ${this.#token}`;
 		let payload: string | undefined;
 		if (opts.body !== undefined) {