@oh-my-pi/pi-ai 18.12.6 → 18.13.0

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 ## [Unreleased]
 
+## [18.13.0] - 2026-10-26
+
+### Breaking Changes
+
+- `OpenAIRequestSetupModel` now requires the catalog-policy fields (`api`, `reasoning`), so callers building a reduced model for `resolveOpenAIRequestSetup` must pass them ([#16988](https://github.com/can1357/oh-my-pi/pull/16988) by [@rafalopilowski1](https://github.com/rafalopilowski1))
+
+### Added
+
+- Added `PI_ANTHROPIC_API_VERSION=2026-10-21` to send Anthropic API version 2026-10-21 to the official Anthropic API; sampling parameters are omitted under that version, which rejects them ([#16706](https://github.com/can1357/oh-my-pi/pull/16706) by [@H4vC](https://github.com/H4vC))
+- OpenCode Go requests on lanes that opt into shared prompt caching send an explicit prompt-cache key as `x-opencode-session`, so Task siblings, forks and their parent reuse one gateway cache; custom providers declaring `providerType: "opencode-go"` get the same OpenCode headers ([#16988](https://github.com/can1357/oh-my-pi/pull/16988) by [@rafalopilowski1](https://github.com/rafalopilowski1))
+
+### Changed
+
+- Reduced the CPU spent preparing tool schemas on every model call, so requests with many tools start faster ([#16780](https://github.com/can1357/oh-my-pi/pull/16780) by [@yuzu-octopus](https://github.com/yuzu-octopus))
+- Fixed tool schema normalization modifying the caller's schema in place, which added the folded `const` value to a tool's own `enum` array ([#16780](https://github.com/can1357/oh-my-pi/pull/16780) by [@yuzu-octopus](https://github.com/yuzu-octopus))
+- Google Antigravity requests now carry the same request labels as the official 2.26.0 client (`cascade_id`, `root_cascade_id`, `request_id`, `used_non_gemini_model`), and image model lookup sends the account's project ([#17012](https://github.com/can1357/oh-my-pi/pull/17012) by [@apoc](https://github.com/apoc))
+- Google Antigravity requests now send each model tier's own `model_enum` label, output cap and thinking setting from the serving account's model list, as the official client does: Claude 5.5 and Gemini 4 Argon tiers send a thinking level, Gemini 3.8 Flash tiers the tier's thinking budget ([#17012](https://github.com/can1357/oh-my-pi/pull/17012) by [@apoc](https://github.com/apoc))
+- Google Antigravity requests now number conversation steps like the official client (the first request is step 1, and each model turn and tool result adds one), send `Accept-Encoding: gzip` without an explicit `Accept`, and no longer send the Claude thinking beta header to Claude 5.5 ([#17012](https://github.com/can1357/oh-my-pi/pull/17012) by [@apoc](https://github.com/apoc))
+
+### Fixed
+
+- Anthropic-compatible endpoints that require a `thinking` block on every turn of the current turn no longer replay a 400 when the history holds a turn an upstream answered without reasoning; the serializer pads those turns ([#16739](https://github.com/can1357/oh-my-pi/pull/16739) by [@lz37](https://github.com/lz37))
+- Fixed an Anthropic stream that a gateway or proxy cuts after `message_start`, substituting an in-band `error` frame, being reported as a completed-turn provider failure instead of a retryable stream truncation ([#16990](https://github.com/can1357/oh-my-pi/pull/16990) by [@Maziar123](https://github.com/Maziar123))
+- Fixed Kimi Code, Z.AI, and ClinePass usage polls logging a warning every poll for accounts without a metered plan ([#17057](https://github.com/can1357/oh-my-pi/pull/17057) by [@trukhinyuri](https://github.com/trukhinyuri))
+- Fixed Codex usage showing no limits for credit-billed ChatGPT Business/Enterprise seats: `/wham/usage` returns `rate_limit: null` for them, and their per-user credit cap (`spend_control.individual_limit`) is now reported as a `Spend cap (credits)` limit that also gates chat requests when no plan windows exist ([#16973](https://github.com/can1357/oh-my-pi/pull/16973) by [@DusKing1](https://github.com/DusKing1))
+- Fixed overlapping OpenAI Codex requests in the same session (e.g. concurrent auth-gateway requests) closing the WebSocket another request was still streaming on; the later request now goes over SSE ([#16812](https://github.com/can1357/oh-my-pi/pull/16812) by [@Abelo9996](https://github.com/Abelo9996))
+- Fixed Codex WebSocket turns dying with `unsupported_native_inflight_message` when the native turn lane was still busy; the turn is now retried as an independent full-context request instead of surfacing the error ([#17065](https://github.com/can1357/oh-my-pi/pull/17065) by [@AgileInnov8tor](https://github.com/AgileInnov8tor))
+- Fixed OpenRouter native failures appearing as successful empty stops and malformed Responses being replayed before corrective recovery; metadata permission/rate-limit failures no longer trigger malformed-response recovery ([#17063](https://github.com/can1357/oh-my-pi/pull/17063) by [@martijnberger](https://github.com/martijnberger))
+- Fixed Xiaomi MiMo API-key login failing with `Unsupported model mimo-v2.5` after the V2.5 retirement ([#16727](https://github.com/can1357/oh-my-pi/pull/16727) by [@LiPu-jpg](https://github.com/LiPu-jpg))
+- Fixed Xiaomi MiMo login rejecting `ttp-` Token Plan keys with `401 Invalid API Key`; they now validate against the regional Token Plan hosts like `tp-` keys ([#17045](https://github.com/can1357/oh-my-pi/issues/17045))
+- Fixed Xiaomi MiMo Token Plan login reporting `401 Invalid API Key` when the key's own region rejected the probe for another reason; that region's actual error is now shown ([#17045](https://github.com/can1357/oh-my-pi/issues/17045))
+- Fixed non-streaming requests reporting a missing API key when the credential resolver actually failed, hiding auth broker, OAuth and network outages behind "No API key" ([#16655](https://github.com/can1357/oh-my-pi/pull/16655) by [@adi-IL](https://github.com/adi-IL))
+- Fixed Claude subagents with large structured output schemas failing with `Schemas contains too many optional parameters` ([#16887](https://github.com/can1357/oh-my-pi/pull/16887) by [@alphastorm](https://github.com/alphastorm))
+- Fixed auth-gateway requests failing when a client requests an unsupported thinking effort; the gateway now uses the nearest supported tier ([#16671](https://github.com/can1357/oh-my-pi/pull/16671) by [@codyw912](https://github.com/codyw912))
+- Fixed Codex requests failing with `array schema must define items` when a tool or a task's `outputSchema` declares an array without `items` ([#16886](https://github.com/can1357/oh-my-pi/pull/16886) by [@alphastorm](https://github.com/alphastorm))
+- Fixed Anthropic tools whose parameters are a root `anyOf`/`oneOf`/`allOf` of objects being sent as an empty closed object that only accepts `{}`; variant properties now fold into the root `input_schema` ([#16630](https://github.com/can1357/oh-my-pi/issues/16630))
+- Fixed OAuth logins failing with `invalid_grant` after a token refresh took longer than 10 seconds: the refresh now finishes in the background and saves the provider's new refresh token ([#16291](https://github.com/can1357/oh-my-pi/pull/16291) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed a tool call from a Claude model that declined mid-response still running after its server-side fallback model took over ([#16250](https://github.com/can1357/oh-my-pi/pull/16250) by [@will-bogusz](https://github.com/will-bogusz))
+- Added 1h prompt caching on Factory Droid's Claude models (Anthropic, Vertex, Bedrock and Azure upstreams) when you set cache retention to long, and cache warming plus cache-timed idle compaction on those models ([#16296](https://github.com/can1357/oh-my-pi/pull/16296) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed Factory Droid accounts whose login token lacks an organization getting 401 "User not affiliated with an organization" on every request: omp now resolves the account's organization at login and refresh ([#14061](https://github.com/can1357/oh-my-pi/issues/14061)) ([#16257](https://github.com/can1357/oh-my-pi/pull/16257) by [@will-bogusz](https://github.com/will-bogusz))
+- Added image generation and editing through a Factory Droid login: `generate_image` runs Factory's GPT Image 2.5, GPT Image 2.5 Flare and Gemini 3 Pro Image, with up to 16 reference images for GPT Image edits ([#16316](https://github.com/can1357/oh-my-pi/pull/16316) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed OpenAI-compatible chat completions with Anthropic-style prompt caching (`cacheControlFormat: "anthropic"`, e.g. OpenRouter Claude) re-sending a turn's tool calls and results uncached on every tool-loop request; the cache breakpoint now advances onto the latest tool result ([#16845](https://github.com/can1357/oh-my-pi/issues/16845))
+- Fixed native Google (`google-generative-ai`, `google-vertex`) requests failing with `The operation timed out.` after ~5 minutes of slow prefill even when `providers.streamFirstEventTimeoutSeconds` allowed longer ([#16991](https://github.com/can1357/oh-my-pi/issues/16991))
+- Fixed `model.loopGuard` settings being ignored for providers routed through the shared option mapping, such as `openai-responses` models from `models.yml` ([#11129](https://github.com/can1357/oh-my-pi/issues/11129), [#16963](https://github.com/can1357/oh-my-pi/pull/16963) by [@SipgateSteffenPaul](https://github.com/SipgateSteffenPaul))
+- Fixed Google Antigravity's Gemini 4 Argon weekly bucket sharing the generic "Gemini" label with the shared Gemini weekly bucket, leaving usage rows indistinguishable; the Argon bucket now reads "Gemini (Argon)" ([#16790](https://github.com/can1357/oh-my-pi/issues/16790))
+- Fixed Anthropic API-key requests with thinking off failing with 400 "context_management: Extra inputs are not permitted" on Claude Opus 5.5 and Fable 5.1, and on Claude Haiku 5.5 after an effort change (for example a retry fallback from a model without reasoning) ([#17047](https://github.com/can1357/oh-my-pi/pull/17047) by [@sjawhar](https://github.com/sjawhar))
+- Fixed every GitLab Duo Agent request failing with 4400 "Flow configuration failed security validation" when a context file (such as an `AGENTS.md`) contains an HTML comment ([#17044](https://github.com/can1357/oh-my-pi/pull/17044) by [@trukhinyuri](https://github.com/trukhinyuri))
+- Fixed a GitLab Duo Agent session that GitLab rejects on close (WebSocket 4000–4999) ending as an empty answer that was silently retried three times; it now ends with an error naming GitLab's reason and HTTP status ([#17044](https://github.com/can1357/oh-my-pi/pull/17044) by [@trukhinyuri](https://github.com/trukhinyuri))
+- Fixed Cursor GitHub and Google logins never getting an account email ([#17048](https://github.com/can1357/oh-my-pi/pull/17048) by [@trukhinyuri](https://github.com/trukhinyuri))
+- Fixed Cursor X Subscription usage treating the weekly Grok/Composer pool as third-party budget; third-party models are now metered by prepaid credit ([#17048](https://github.com/can1357/oh-my-pi/pull/17048) by [@trukhinyuri](https://github.com/trukhinyuri))
+- Fixed Google models (`google-generative-ai`, `google-vertex`, `google-gemini-cli`/Antigravity) running out of output on small `maxTokens` requests with reasoning on, ending with thinking only and no answer; the requested `maxTokens` now leaves room for thinking on top, as on other providers ([#16943](https://github.com/can1357/oh-my-pi/pull/16943) by [@Mouriya-Emma](https://github.com/Mouriya-Emma))
+
 ## [18.12.5] - 2026-10-21
 
 ### Added
@@ -2266,51 +2318,4 @@
 
 - Fixed local llama.cpp (and any local OpenAI-compatible server rendering the Qwen3.6+ chat template) re-processing the full prompt every new user message even with `replayReasoningContent` enabled (#3541 follow-up to #3528). Sending `reasoning_content` alone wasn't enough: Qwen3's chat template strips `<think>...</think>` from any assistant turn whose index is `<= last_query_index`, so the moment a new user message (the user's next prompt, or the auto-learn capture-at-stop nudge) lands, every prior assistant turn becomes "older" and is re-rendered without the `<think>` block — diverging from the generation tokens still in the slot's KV cache. The chat-completions encoder now emits `preserve_thinking: true` for Qwen thinking dialects on local servers, route-split the same way the existing `enable_thinking` emission is: the `qwen` dialect rides the top-level field (llama.cpp's `--jinja` hook and Alibaba Cloud Model Studio's compatible-mode), the `qwen-chat-template` dialect (NVIDIA NIM, vLLM/SGLang's chat-template-kwargs path) rides only `chat_template_kwargs.preserve_thinking` because NIM's request schema is `additionalProperties: false` and rejects unknown top-level fields (#2299). The emission is hoisted above the `reasoning.enabled` gate so it fires for THREE cases the original gating missed: (1) runtime-discovered local Qwen models that ship with `reasoning: false` because the upstream `/v1/models` doesn't advertise the capability (same gotcha #3532 fixed for `replayReasoningContent`), (2) caller-disabled reasoning (`/think off`) — the kwarg is a history-rendering knob, not a per-turn thinking switch, and the slot still holds `<think>` tokens from earlier turns, and (3) forced-tool-choice / DeepSeek-style auto-disable. Qwen3.6+ then renders `<think>...</think>` for every assistant turn regardless of position, and the next-turn render matches the cached generation tokens. ([#3541](https://github.com/can1357/oh-my-pi/issues/3541))
 
-## [16.1.22] - 2026-06-26
-
-### Fixed
-
-- Fixed llama.cpp / LM Studio / vLLM (and any local OpenAI-compatible server on a loopback or RFC1918 baseUrl) re-processing the full prompt on every assistant continuation when the prior turn produced `reasoning_content`: the `openai-completions` encoder dropped the preserved `thinking` block on re-serialization for compat profiles without `requiresReasoningContentForToolCalls` / `thinkingFormat: "zai"`, so the chat template re-rendered the assistant turn without `<think>…</think>` and the rendered tokens diverged from the slot's KV cache state. The auto-learn capture-at-stop nudge made it reproduce on every turn. The encoder now replays preserved thinking as `reasoning_content` (honoring the streamed signature when it identifies a recognized wire field — `reasoning_content` / `reasoning` / `reasoning_text` — and falling back to the configured `reasoningContentField` for opaque signatures) whenever the new `compat.replayReasoningContent` flag is set, and the cross-API `transformMessages` predicate (`openAICompletionsReplaysUnsignedThinking`) honors the same flag ahead of the `model.reasoning` gate so a switch into a discovered local target (where the spec carries `reasoning: false` because the upstream `/models` endpoints don't advertise the capability) still preserves the prior turn's thinking block as signature-stripped reasoning instead of demoting it to conversation text. The chat-template-rendered prefix stays byte-stable across turns and llama.cpp's prefix KV cache survives. ([#3528](https://github.com/can1357/oh-my-pi/issues/3528))
-
-## [16.1.21] - 2026-06-26
-
-### Fixed
-
-- Restored the `pollOAuthDeviceCodeFlow` export from `@oh-my-pi/pi-ai/oauth` so legacy provider extensions can reuse the host OAuth device-code poller. ([#3508](https://github.com/can1357/oh-my-pi/issues/3508))
-
-## [16.1.20] - 2026-06-25
-
-### Fixed
-
-- Fixed Ollama/Ollama Cloud native chat responses that finish with `done_reason: "length"` and no assistant content surfacing as a normal empty stop; they now become a context-window error instead of entering empty-stop retry recovery. ([#3464](https://github.com/can1357/oh-my-pi/issues/3464))
-- Fixed direct Anthropic Claude Sonnet/Haiku 4.5 requests serializing `output_config.effort`. The catalog classification (`packages/catalog/src/model-thinking.ts`) drove the `anthropic-budget-effort` branch in `buildParams`, which Anthropic's first-party Messages API rejects on Sonnet/Haiku 4.5 with HTTP 400 `This model does not support the effort parameter.` Sonnet/Haiku 4.5 now use plain `thinking.budget_tokens`; Opus 4.5 still emits `output_config.effort` because Anthropic supports it there. ([#3497](https://github.com/can1357/oh-my-pi/issues/3497))
-
-## [16.1.19] - 2026-06-25
-
-### Fixed
-
-- Fixed Ollama/llama.cpp chat payloads serializing user-attributed mid-conversation developer messages (auto-learn capture nudge, advisor cards, file-mention companions) as `system` turns; they now serialize as `user` so llama.cpp can reuse the warm prompt prefix instead of forcing full re-processing. Agent-owned developer reminders (`attribution: "agent"` — empty/unexpected-stop retries, checkpoint rewind warning, todo reminders) keep their `system` priority. ([#3456](https://github.com/can1357/oh-my-pi/issues/3456))
-- Fixed prior-turn reasoning being lost on cross-API provider switches: when a session moved from an Anthropic-compatible 3p endpoint to an OpenAI-compatible one (Z.AI Anthropic → Z.AI OpenAI, Kimi Anthropic → Kimi OpenAI, DeepSeek, OpenCode-hosted reasoning models, or any custom `models.yaml` switch that crosses API types), the cross-API path of `transformMessages` text-demoted every prior `thinking` block, so the next request shipped the reasoning chain as plain conversation `content` instead of structured `reasoning_content` — losing it as reasoning context and re-billing it. `convertMessages` now threads the request-time resolved compat into `transformMessages`, which preserves the prior reasoning as a native, signature-stripped `thinking` block whenever that resolved target accepts `reasoning_content` as a continuation hint (`requiresReasoningContentForToolCalls` — including the `whenThinking` policy OpenCode reactivates for thinking-on requests, #1071/#1484 — or `thinkingFormat: "zai"`); the `openai-completions` encoder surfaces those blocks via `reasoningContentField`, with a new branch for Z.AI-format hosts (Z.AI, Zhipu, Moonshot Kimi, Xiaomi MiMo) that accept but don't require the field. Targets that can't replay unsigned reasoning (encrypted reasoning blobs, signed thought parts, non-reasoning models, thinking-disabled OpenCode) still text-demote so the reasoning survives as conversation context. ([#3437](https://github.com/can1357/oh-my-pi/pull/3437), [#3439](https://github.com/can1357/oh-my-pi/pull/3439) by [@roboomp](https://github.com/roboomp); [#3433](https://github.com/can1357/oh-my-pi/issues/3433), [#3434](https://github.com/can1357/oh-my-pi/issues/3434))
-- Fixed Bedrock cross-region inference profiles routing to `us-east-1` regardless of their geo prefix: a profile such as `eu.anthropic.claude-…` (or `apac.`/`au.`/`jp.`) sent to the hardcoded `us-east-1` endpoint returned HTTP 400 `The provided model identifier is invalid`. `streamBedrock` now derives the runtime region from the profile's geo prefix — honoring an ambient `AWS_REGION`/`AWS_DEFAULT_REGION` only when it can serve that geo and falling back to the geo's default region otherwise — while explicit per-request and ARN-embedded regions still win and region-agnostic `global.` profiles stay unchanged.
-- Fixed malformed tool calls (empty `name`) wedging entire sessions in HTTP 400 loops: when a model occasionally emits `{ "name": "", "arguments": "{}" }` (observed: GLM-5.2 + thinking on long turns), the agent rejected the call at execution time with `Tool  not found`, but the malformed block plus its error `toolResult` stayed in conversation history and every subsequent request 400'd on `tool_use.name`/`tool_calls[i].function.name` validation until the user ran `/clear`. `transformMessages` — the canonical sanitize boundary every provider passes through — now drops `toolCall` blocks with empty/whitespace `name`, pairs them with their `toolResult` messages only inside the same assistant→tool-result window (per-id FIFO queue cleared at non-result boundaries, so stale malformed calls without a result cannot consume later valid duplicate-id outputs), and drops the assistant turn when it has no replayable content left. Defensive (provider-agnostic, fires regardless of model), idempotent (no-op on a clean history), and self-healing (one round-trip after the fix lands sanitizes an already-poisoned session). ([#3458](https://github.com/can1357/oh-my-pi/issues/3458))
-
-## [16.1.18] - 2026-06-25
-
-### Added
-
-- Added `listOAuthAccounts` for retrieving a read-only list of stored OAuth account identities
-- Added `getOAuthAccessAt` to resolve an OAuth token exclusively for a specific account position
-
-### Changed
-
-- Refactored OAuth token persistence and disable logic to use stable credential IDs instead of positional indices to prevent race conditions during concurrent updates
-- Updated OAuth failure classification to treat 403 status codes, rate limits, and network errors as transient, preventing unnecessary credential invalidation
-
-### Fixed
-
-- Fixed Codex Responses Lite staying enabled for image prompts, which caused GPT/Codex image turns to be rejected as `Invalid value: 'input_image'`; image-bearing Codex requests now fall back to the full Responses transport. ([#3421](https://github.com/can1357/oh-my-pi/issues/3421))
-- Fixed the auth-broker background refresher disabling OAuth credentials unconditionally (`disableCredentialById`) on a definitive refresh failure, so a credential another process or a fresh login rotated mid-refresh could be torn down even though the stored row already held a valid token. The definitive-failure teardown now happens inside `AuthStorage.refreshCredentialById` via the same compare-and-set the in-stream and usage-probe paths use — it disables only when the persisted row still matches the credential the refresh actually attempted, and reloads on a CAS loss; the refresher now only logs.
-- Fixed OAuth refresh persisting the rotated token by a positional index captured before the refresh `await`. A concurrent disable could reorder or shrink a provider's credential array while the refresh was in flight, landing the new token on the wrong row (or silently dropping it) and leaving accounts with a stale refresh token that failed — and was then disabled — on the next cycle. Refresh persistence, selection-index resync, and CAS-disable now address the row by id across `forceRefreshCredentialById`, candidate preflight, and in-stream selection (`#replaceCredentialById` / `#disableCredentialByIdIfMatches`).
-- Fixed `isDefinitiveOAuthFailure` treating a bare HTTP 403 (and generic `unauthorized` / access-token-expired wording) as a definitive credential failure, which permanently disabled healthy OAuth accounts on WAF, egress rate-limit, permission, and account-verification responses. Bare 403, rate limits (429), gateway/5xx, and more network errors (`ECONNRESET`, `ETIMEDOUT`, `EAI_AGAIN`, …) are now classified transient; only explicit dead-grant errors (`invalid_grant`, `invalid_token`, `unauthorized_client`, revoked, `refresh token … expired`) or a bare 401 tear the credential down.
-
-Older entries are archived in [packages/ai/CHANGELOG.md@7a5f1425b9bd](https://github.com/can1357/oh-my-pi/blob/7a5f1425b9bd79c3c74ae1d8946782b0494c8aa9/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@917a36589039](https://github.com/can1357/oh-my-pi/blob/917a365890396071a959dfd2865a3538518ef717/packages/ai/CHANGELOG.md).

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

@@ -560,6 +560,7 @@ export interface StoredOAuthRefreshOptions<T extends OAuthCredential = OAuthCred
     signal?: AbortSignal;
     keepCredentialOnRefreshFailure?: boolean | ((error: unknown) => boolean);
     onRefreshFailure?: (error: unknown) => void;
+    /** How long the caller waits (for the lease and the exchange); the exchange itself runs on until its backstop. */
     refreshTimeoutMs?: number;
     refresh: (credential: T, signal?: AbortSignal) => Promise<OAuthCredentials>;
     mergeRefreshedCredential?: (credential: T, refreshed: OAuthCredentials) => T;

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

@@ -111,6 +111,9 @@ export declare function resolveNextAuthRetryKey(state: AuthRetryKeyState, resolv
  *   enters sibling rotation. Ordinary 401/auth failures get one refresh-same,
  *   then rotate through distinct siblings; 403/usage-limit failures skip the
  *   refresh and rotate directly.
+ * - A resolver that throws on the initial resolve surfaces its cause (a
+ *   broker/OAuth/network failure) instead of reading as a missing key; only a
+ *   resolver that resolves without a credential is a "No API key" case.
  *
  * Used by non-streaming consumers (image generation, web search, completion
  * helpers). The streaming driver in `stream.ts` implements the same policy with

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

@@ -54,10 +54,13 @@ export declare class AnthropicConnectionTimeoutError extends Error {
     constructor();
 }
 /**
- * A malformed Anthropic SSE stream envelope — events arriving out of order
- * (before `message_start`) or otherwise violating the message-event grammar.
- * The message is prefixed with {@link STREAM_ENVELOPE_ERROR_PREFIX} so the
- * shared envelope predicates classify it.
+ * A malformed or truncated Anthropic SSE stream envelope — events arriving out
+ * of order (before `message_start`), a retryable in-band `error` frame that ends
+ * the message before its terminal frame, or otherwise a stream that never
+ * reached that frame. A deterministic provider rejection keeps its
+ * completed-turn error instead. The message is prefixed with
+ * {@link STREAM_ENVELOPE_ERROR_PREFIX} so the shared envelope predicates
+ * classify it.
  */
 export declare class AnthropicStreamEnvelopeError extends Error {
     constructor(detail: string);

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

@@ -108,6 +108,13 @@ export declare function isStreamReadErrorText(text: string): boolean;
  *  `stopDetails.explanation` so loop-level salvage can classify it after the
  *  original `Error` instance is gone. */
 export declare function isStreamEnvelopeErrorText(text: string): boolean;
+/** Persisted-text form of a truncated stream envelope: an
+ *  `Anthropic stream envelope error:` diagnostic naming the frame the stream
+ *  never reached (`before message_start|delta|stop`). Covers both a connection
+ *  that dies inside an open envelope and an in-band `error` frame that a
+ *  gateway or proxy substitutes for the cut, so turn recovery can classify the
+ *  family by its envelope marker instead of per-gateway wording. */
+export declare function isStreamEnvelopeTruncationText(text: string): boolean;
 export declare function classify(error: unknown, api?: Api): number;
 /**
  * Whether an error (or message string) classifies as an account usage/quota

package/dist/types/images/factory-droid.d.ts

@@ -0,0 +1,21 @@
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+/** Reference images Factory's JSON edits contract accepts per request. */
+export declare const FACTORY_DROID_MAX_EDIT_IMAGES = 16;
+/** Decoded bytes the CLI accepts per reference image. */
+export declare const FACTORY_DROID_MAX_REFERENCE_BYTES: number;
+/**
+ * Factory Droid `generate_image` transport, mirroring the CLI: GPT Image
+ * models call the proxy's OpenAI Images routes, a prompt alone on
+ * `/images/generations` and reference images inline on `/images/edits`
+ * (Factory converts `input_images` to upstream multipart); Gemini image
+ * models call the native Gemini route asking for TEXT and IMAGE output. Both
+ * carry chat's client identity. The Droid identity rides the proxy-only
+ * `instructions` field, or opens the Gemini system instruction ahead of the
+ * CLI's generate or edit directive.
+ *
+ * A 200 without an image (a Gemini prompt block, an empty data array) throws
+ * a response error, which ends the tool's chain like other malformed
+ * responses; HTTP rejections throw provider HTTP errors, which advance it.
+ */
+export declare function generateFactoryDroidImage(model: Model<"factory-droid-agent">, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;

package/dist/types/images/google-generative-ai.d.ts

@@ -1,3 +1,36 @@
 import type { Model } from "@oh-my-pi/pi-catalog/types";
 import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+interface GeminiPart {
+    text?: string;
+    inlineData?: {
+        data?: string;
+        mimeType?: string;
+    };
+}
+/** One `generateContent` response, or one chunk of its SSE stream. */
+export interface GeminiImageResponse {
+    candidates?: Array<{
+        content?: {
+            parts?: GeminiPart[];
+        };
+        finishReason?: string;
+    }>;
+    usageMetadata?: {
+        promptTokenCount?: number;
+        candidatesTokenCount?: number;
+        totalTokenCount?: number;
+    };
+}
+/** The user turn of a Gemini image request: reference images first, then the prompt. */
+export declare function geminiImageContents(request: ImageGenerationRequest): Array<{
+    role: "user";
+    parts: GeminiPart[];
+}>;
+/**
+ * Collect images, text and usage from a response or its stream chunks: parts
+ * within a response are separate paragraphs, chunks continue the same text,
+ * and the last usage report stands.
+ */
+export declare function geminiImageResult(responses: Iterable<GeminiImageResponse>): ImageGenerationResult;
 export declare function generateGoogleImage(model: Model, request: ImageGenerationRequest, options: ImageGenerationOptions): Promise<ImageGenerationResult>;
+export {};

package/dist/types/images/index.d.ts

@@ -1,5 +1,6 @@
 import { type Api, type ImageGenerationApi, type Model } from "@oh-my-pi/pi-catalog/types";
 import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
+export * from "./factory-droid.js";
 export * from "./google-antigravity.js";
 export * from "./google-generative-ai.js";
 export * from "./openai-hosted.js";

package/dist/types/images/shared.d.ts

@@ -11,6 +11,7 @@ export declare function usageFromWire(value: unknown): Usage;
 export declare function imageBaseUrl(model: Model): string;
 export declare function modelHeaders(model: Model, signal?: AbortSignal): Promise<Record<string, string>>;
 export declare function errorMessage(rawText: string): string;
+export declare function parseImageApiResponse(model: Model, response: Response): Promise<unknown>;
 /** Request URL, or a builder for routes that depend on the bearer (xAI's `XAI_BASE_URL` rule). */
 type ImageRequestUrl = string | ((bearer: string) => string);
 export declare function postJson(options: {

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

@@ -326,15 +326,25 @@ export type AnthropicMessageParam = MessageParam;
  * before the compaction block, so the assistant turn carrying it may open
  * the conversation; the request must send the compaction beta (the stream
  * entry point adds it whenever such a payload is present).
+ *
+ * `opts.thinkingEnabled` — the CURRENT request enables thinking. Combined with
+ * `model.compat.requiresThinkingPresence` this pads assistant turns that carry
+ * no thinking block at all (see the guard below).
  */
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, opts?: {
     serverSideFallbackEnabled?: boolean;
     replayCompaction?: boolean;
     replayLegacyCompaction?: boolean;
     dropAllThinking?: boolean;
+    thinkingEnabled?: 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[];
+/**
+ * Normalize a tool parameter schema into an Anthropic `input_schema`: root
+ * combinators fold into the root object ({@link foldAnthropicRootCombinators}),
+ * then {@link normalizeAnthropicToolSchemaNode} applies the keyword whitelist.
+ */
 export declare function normalizeAnthropicToolSchema(schema: unknown): unknown;

package/dist/types/providers/factory-droid.d.ts

@@ -1,5 +1,7 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
-import type { ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types.js";
+import { type FactoryDroidWire } from "@oh-my-pi/pi-catalog/wire/factory-droid";
+import type { OAuthRequestIdentity } from "../auth/types.js";
+import type { Api, Model, ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types.js";
 export interface FactoryDroidOptions extends StreamOptions {
     reasoning?: Effort;
     disableReasoning?: boolean;
@@ -10,4 +12,25 @@ export interface FactoryDroidOptions extends StreamOptions {
     /** OMP-native response verbosity (responses wire `text.verbosity`). */
     textVerbosity?: "low" | "medium" | "high";
 }
+/** Wires that carry Factory's `generate_image` models. */
+export type FactoryDroidImageWire = Extract<FactoryDroidWire, "openai-responses" | "google-generate">;
+/** Endpoint, identity headers and system identity for one Factory image request. */
+export interface FactoryDroidImageRoute {
+    /** `openai-responses` rides the Images API beside Responses; `google-generate` the native Gemini route. */
+    wire: FactoryDroidImageWire;
+    baseUrl: string;
+    headers: Record<string, string>;
+    /** Droid identity the proxy requires: the Images `instructions` field or the Gemini system instruction. */
+    identity: string;
+}
+/**
+ * Bind an image request to the same client identity chat sends: the CLI's
+ * Images and Gemini image calls reuse its chat request headers for the
+ * model's upstream, and the proxy runs the same Droid identity check.
+ */
+export declare function factoryDroidImageRoute(model: Model<"factory-droid-agent">, token: string, sessionId: string | undefined, 
+/** Account identity of the credential serving this attempt; host, org and upstream follow it. */
+identity: OAuthRequestIdentity | undefined): FactoryDroidImageRoute;
+/** Whether a catalog model runs on the Factory Droid transport. */
+export declare function isFactoryDroidModel(model: Model<Api>): model is Model<"factory-droid-agent">;
 export declare const streamFactoryDroid: StreamFunction<"factory-droid-agent">;

package/dist/types/providers/google-gemini-cli.d.ts

@@ -58,14 +58,17 @@ export interface AntigravityProviderSessionState extends ProviderSessionState {
     /**
      * Per-conversation request-envelope identity that mirrors the real
      * Antigravity client. `sessionId` is the signed-decimal session id;
-     * `agentId`/`trajectoryId` are UUIDs; `stepIndex` is the monotonic step
-     * counter; `lastExecutionId` is the prior response id echoed as
-     * `labels.last_execution_id`.
+     * `agentId`/`trajectoryId` are UUIDs (`agentId` doubles as
+     * `labels.cascade_id`/`root_cascade_id`); `stepIndex` is the last
+     * requestId step (monotonic); `requestCount` counts envelopes already built for the trajectory
+     * (`labels.request_id` suffix); `lastExecutionId` is the prior response id
+     * echoed as `labels.last_execution_id`.
      */
     agentId?: string;
     trajectoryId?: string;
     sessionId?: string;
     stepIndex?: number;
+    requestCount?: number;
     lastExecutionId?: string;
 }
 export declare function getAntigravityProviderSessionState(providerSessionState: Map<string, ProviderSessionState> | undefined): AntigravityProviderSessionState | undefined;
@@ -75,6 +78,7 @@ interface ParsedGeminiCliCredentials {
     refreshToken?: string;
     expiresAt?: number;
     email?: string;
+    accountId?: string;
 }
 export declare function parseGeminiCliCredentials(apiKeyRaw: string): ParsedGeminiCliCredentials;
 export declare function shouldRefreshGeminiCliCredentials(expiresAt: number | undefined, isAntigravity: boolean, nowMs?: number): boolean;
@@ -114,4 +118,6 @@ interface CloudCodeAssistRequest {
     requestId?: string;
 }
 export declare const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli">;
-export declare function buildRequest(model: Model<"google-gemini-cli">, context: Context, projectId: string, options?: GoogleGeminiCliOptions, isAntigravity?: boolean): CloudCodeAssistRequest;
+export declare function buildRequest(model: Model<"google-gemini-cli">, context: Context, projectId: string, options?: GoogleGeminiCliOptions, isAntigravity?: boolean, 
+/** Serving credential's account key; selects its discovered Antigravity request constants. */
+accountKey?: string): CloudCodeAssistRequest;

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

@@ -1,10 +1,42 @@
 /** Shared inference request identity headers. */
+import type { CatalogPolicyInputs } from "@oh-my-pi/pi-catalog/types";
 /** Options controlling provider and protocol inference headers. */
 export interface InferenceHeaderOptions {
+    /**
+     * Credential-bearing provider id. Wire decisions (protocol session
+     * headers, OpenCode attribution) resolve against the declared backend
+     * instead — see {@link providerType}.
+     */
     provider: string;
+    /**
+     * Declared backend identity for a custom provider (`providerType ?? provider`,
+     * the same target the catalog policy cascade resolves). Carried through so
+     * a credential-bearing custom provider declared as an OpenCode backend
+     * gets that backend's wire headers while auth and registry keep using
+     * {@link provider}.
+     */
+    providerType?: string;
     protocol: "anthropic" | "google" | "openai";
     sessionId?: string;
+    /**
+     * Shared prompt-cache affinity key (see {@link resolveOpenCodeGoCacheAffinity}).
+     * Carried only by `x-opencode-session` on the `opencode-go` backend;
+     * protocol-native session headers and every other backend keep `sessionId`.
+     */
+    cacheAffinity?: string;
 }
+/**
+ * Shared prompt-cache affinity for the OpenCode Go backend: on lanes opted
+ * into KDL `shared-prompt-cache`, related requests (Task siblings, forks,
+ * explicit-key callers) warm and hit the gateway's prefix cache under one
+ * shared key, so Go's session header carries that key instead of the
+ * conversation id.
+ *
+ * `promptCacheKey` MUST be an explicit, already retention-gated cache key —
+ * never the sessionId-derived fallback. The backend identity is
+ * `providerType ?? provider`; catalog policy is the only opt-in authority.
+ */
+export declare function resolveOpenCodeGoCacheAffinity(model: CatalogPolicyInputs, promptCacheKey: string | undefined): string | undefined;
 /** 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;
 /**

package/dist/types/providers/native-finish-reason.d.ts

@@ -0,0 +1,2 @@
+/** Recognize explicit upstream failures without rejecting new vendor finish reasons. */
+export declare function getNativeFinishReasonError(nativeFinishReason: unknown): string | undefined;

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

@@ -1,5 +1,5 @@
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
-import type { OpenAICompat, OpenAIReasoningDisableMode, OpenAIStreamMarkupHealingPattern, OpenRouterRouting, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenAISharedCompat, VercelGatewayRouting } from "@oh-my-pi/pi-catalog/types";
+import type { CatalogPolicyInputs, OpenAICompat, OpenAIReasoningDisableMode, OpenAIStreamMarkupHealingPattern, OpenRouterRouting, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenAISharedCompat, VercelGatewayRouting } from "@oh-my-pi/pi-catalog/types";
 import { type Api, type AssistantMessage, type CacheRetention, type ComputerToolCallMetadata, type Context, type ImageContent, type Message, type MessageAttribution, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ThinkingContent, type Tool, type ToolCall, type ToolResultMessage, type Usage } from "../types.js";
 export type { OpenAIPromptCacheOptions } from "../types.js";
 import { kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols.js";
@@ -24,7 +24,15 @@ export interface OpenAIStrictToolsState {
         disabledModelScopes: Set<string>;
     };
 }
-export interface OpenAIRequestSetupModel extends OpenAIModelIdentity {
+/**
+ * The model a request setup may be built from: the transport facts it reads
+ * plus every fact the catalog policy cascade reads ({@link CatalogPolicyInputs}).
+ * `api` is required — the Go sibling cache-affinity rules are all `on-api`
+ * scoped, so a reduced model that omits it used to typecheck and silently
+ * leave the family header off. Callers handing a reduced model object must
+ * pass the real policy inputs; there is no default, inference, or fallback.
+ */
+export interface OpenAIRequestSetupModel extends OpenAIModelIdentity, CatalogPolicyInputs {
     headers?: Record<string, string>;
     premiumMultiplier?: number;
     compat?: Pick<ResolvedOpenAISharedCompat, "promptCacheSessionHeader" | "sessionHeader">;
@@ -49,6 +57,15 @@ export interface OpenAIRequestSetupOptions {
     };
     sessionId?: string;
     promptCacheSessionId?: string;
+    /**
+     * Explicit prompt-cache identity only, never the sessionId fallback:
+     * callers set it from the already-resolved `promptCacheSessionId` when an
+     * explicit `promptCacheKey` was supplied, and leave it unset otherwise.
+     * Feeds the Go sibling cache-affinity header so an ordinary conversation
+     * id (especially one long enough to normalize to a `pc_` hash) can never
+     * flip `x-opencode-session` on opted-in lanes.
+     */
+    promptCacheAffinityKey?: string;
 }
 export interface OpenAIRequestSetup {
     copilotPremiumRequests: number | undefined;

package/dist/types/providers/openrouter-generation.d.ts

@@ -0,0 +1,16 @@
+import type { FetchImpl } from "../types.js";
+/**
+ * Responses can normalize upstream failures to completed without exposing the
+ * native reason. Only a metadata-lag 404 with non-reasoning output usage triggers
+ * inferred malformed-response recovery; usage does not confirm the native reason.
+ * Other diagnostic failures leave the original empty-stop recovery unchanged.
+ */
+export declare function readOpenRouterGenerationError(args: {
+    baseUrl: string;
+    headers: Record<string, string>;
+    responseId: string;
+    outputTokens?: number;
+    reasoningTokens?: number;
+    fetch?: FetchImpl;
+    signal: AbortSignal;
+}): Promise<string | undefined>;

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

@@ -13,13 +13,15 @@ export declare function pollCursorAuth(uuid: string, verifier: string): Promise<
 }>;
 export declare function loginCursor(onAuthUrl: (url: string) => void, onPollStart?: () => void): Promise<OAuthCredentials>;
 export declare function loginCursorHook(callbacks: OAuthController): Promise<OAuthCredentials>;
-export declare function refreshCursorToken(refreshToken: string): Promise<OAuthCredentials>;
+export declare function refreshCursorToken(refreshToken: string, signal?: AbortSignal): Promise<OAuthCredentials>;
 export declare function refreshCursorHook(credentials: OAuthCredentials, signal?: AbortSignal): Promise<OAuthCredentials>;
 /** Request headers that present `accessToken` to cursor.com as its user's web session. */
 export declare function cursorSessionHeaders(userId: string, accessToken: string): Record<string, string>;
+/** Unary Connect RPC call with an empty message, authenticated by `accessToken` as a bearer token. */
+export declare function cursorConnectRequest(accessToken: string, signal?: AbortSignal): RequestInit;
 /**
- * Email of the Cursor account that owns `accessToken`, read from its cursor.com
- * profile. Undefined when the token names no user or the profile names another.
+ * Email of the Cursor account that owns `accessToken`, read from Cursor's account profile.
+ * Undefined when the token names no subject or the profile names another.
  */
 export declare function fetchCursorAccountEmail(accessToken: string, fetchImpl?: FetchImpl, signal?: AbortSignal): Promise<string | undefined>;
 export declare function extractCursorAccessTokenUserId(accessToken: string): string | undefined;

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

@@ -4,8 +4,8 @@
  * Xiaomi MiMo provides OpenAI-compatible models via
  * https://api.xiaomimimo.com/v1.
  *
- * Standard Xiaomi login accepts both pay-as-you-go keys and regional `tp-...`
- * keys, probing the regional Token Plan clusters in fallback order.
+ * Standard Xiaomi login accepts both pay-as-you-go keys and regional Token Plan
+ * (`tp-...`/`ttp-...`) keys, probing the regional Token Plan clusters in fallback order.
  */
 import type { OAuthController } from "./types.js";
 /**

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

@@ -8,9 +8,10 @@ import type { CredentialRankingStrategy, UsageProvider, UsageReport } from "../u
  * Prefer a *usable* overall bucket; if overall is absent/disabled/malformed,
  * fall through to plan rails (`autoPercentUsed` / `apiPercentUsed`). Always
  * consider on-demand afterward so a valid on-demand meter is not dropped when
- * the included plan bucket is empty.
+ * the included plan bucket is empty. X Subscription payloads take
+ * {@link parseUnifiedUsage}; `weeklyResetsAt` is its pool's next reset.
  */
-export declare function parseCursorIndividualUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
+export declare function parseCursorIndividualUsage(payload: unknown, fetchedAt?: number, weeklyResetsAt?: number): UsageReport | null;
 export declare function parseCursorUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
 /** Routes Cursor credential ranking and reserve checks through the requested model's billing pool. */
 export declare const cursorRankingStrategy: CredentialRankingStrategy;

package/dist/types/utils/schema/json-schema-validator.d.ts

@@ -18,7 +18,25 @@ export interface JsonSchemaValidationResult {
 }
 /** The unique discriminator-selected branch, or undefined when selection is ambiguous or absent. */
 export declare function getTagSelectedUnionBranch(branches: readonly unknown[], value: unknown): unknown;
-/** Whether any same-instance schema declaration or constraint owns this property name. */
+/**
+ * Whether any same-instance schema declaration or constraint owns this property name.
+ *
+ * The answer depends on exactly two things: the property name, and the content
+ * of the JSON-Schema graph reachable from the root. The cache is keyed by BOTH
+ * — the root's object identity (through {@link stamp}, the repo's
+ * identity-keyed side table) and the property name within it — so two
+ * schemas asking about the same name keep separate answers, and one schema
+ * asked about two names keeps two answers.
+ *
+ * The root identity covers the graph because the schema graphs reaching this
+ * function are already treated as immutable for the lifetime of their
+ * identity: `toolWireSchema` memoizes the wire schema against the tool's
+ * parameters, and `stripSchemaDescriptions`, `tryEnforceStrictSchema` and
+ * `memoizedInjectIntentIntoSchema` already memoize derived values against
+ * that same wire-schema object. A graph mutated in place after production
+ * would already hand those three a stale answer; this cache adds no new
+ * assumption beyond the ones the schema pipeline already relies on.
+ */
 export declare function schemaDefinesProperty(schema: unknown, key: string): boolean;
 export declare function validateJsonSchemaValue(schema: unknown, value: unknown, root?: unknown): JsonSchemaValidationResult;
 /** Validate a subschema using its complete schema's local-reference context. */

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

@@ -113,8 +113,15 @@ export declare function sanitizeSchemaForGrammar(schema: JsonObject): JsonObject
 /**
  * OpenAI Responses rejects `oneOf` in tool schemas even when strict mode is
  * disabled, and rejects every schema node with `type: "object"` unless it has
- * a `properties` member. Normalize only schema-valued positions so literal
- * payloads under `enum`, `const`, `default`, and `examples` remain unchanged.
+ * a `properties` member. Codex opts into repairing arrays without `items` with
+ * explicit open `items: true`, including the default open tail after
+ * `prefixItems`, which makes strict adaptation fall back to non-strict.
+ * The repair is off by default: other Responses routes include grammar
+ * backends that cannot compile boolean subschemas. If `unevaluatedItems`
+ * appears in any schema position, repair is disabled for the whole tool:
+ * references and composition can carry evaluated-item effects across subtrees.
+ * Normalize only schema-valued positions so literal payloads under `enum`,
+ * `const`, `default`, and `examples` remain unchanged.
  *
  * Identity-preserving: returns the input reference unchanged when no rewrite
  * occurred so callers can dedupe via reference equality (and the strict-mode
@@ -122,12 +129,14 @@ export declare function sanitizeSchemaForGrammar(schema: JsonObject): JsonObject
  * concatenated (the wire payload accepts a single union; preserving both
  * would not survive).
  */
-export declare function sanitizeSchemaForOpenAIResponses(schema: JsonObject): JsonObject;
+export declare function sanitizeSchemaForOpenAIResponses(schema: JsonObject, options?: {
+    repairArrayItems?: boolean;
+}): JsonObject;
 /**
  * Alias for {@link sanitizeSchemaForOpenAIResponses} matching the
  * `normalizeSchemaFor*` dispatcher naming used elsewhere in this module.
  */
-export declare const normalizeSchemaForOpenAIResponses: (schema: JsonObject) => JsonObject;
+export declare const normalizeSchemaForOpenAIResponses: typeof sanitizeSchemaForOpenAIResponses;
 /**
  * First pass of strict-mode preparation.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.12.6",
+	"version": "18.13.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.12.6",
-		"@oh-my-pi/pi-catalog": "18.12.6",
-		"@oh-my-pi/pi-natives": "18.12.6",
-		"@oh-my-pi/pi-utils": "18.12.6",
-		"@oh-my-pi/pi-wire": "18.12.6"
+		"@oh-my-pi/omptype": "18.13.0",
+		"@oh-my-pi/pi-catalog": "18.13.0",
+		"@oh-my-pi/pi-natives": "18.13.0",
+		"@oh-my-pi/pi-utils": "18.13.0",
+		"@oh-my-pi/pi-wire": "18.13.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"