@prometheus-ai/ai 0.5.4 → 0.5.8

package/dist/types/providers/amazon-bedrock.d.ts

@@ -6,8 +6,13 @@
  * No `@aws-sdk/*`, no `@smithy/*`, no `proxy-agent`. Proxies are honored via
  * Bun's native `HTTPS_PROXY` support.
  */
-import type { Effort } from "../model-thinking";
+import type { Effort } from "@prometheus-ai/catalog/effort";
+import { ProviderHttpError } from "../errors";
 import type { StreamFunction, StreamOptions, ThinkingBudgets } from "../types";
+/** Non-2xx response (or in-stream exception event) from the Bedrock runtime API. */
+export declare class BedrockApiError extends ProviderHttpError {
+    readonly name = "BedrockApiError";
+}
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 export interface BedrockOptions extends StreamOptions {
     region?: string;
@@ -27,11 +32,12 @@ export interface BedrockOptions extends StreamOptions {
      * - `"omitted"`: thinking content is suppressed; the encrypted signature still
      *   travels back for multi-turn continuity.
      *
-     * Starting with Claude Opus 4.7 the Anthropic API default is `"omitted"`, which
-     * leaves callers waiting on a silent stream during long reasoning runs (issue
-     * #1373). We default to `"summarized"` so adaptive-thinking models that accept
-     * the field keep producing visible thinking deltas. Older adaptive-thinking
-     * models (Opus 4.6, Sonnet 4.6+) reject the field, so we omit it for them.
+     * Starting with Claude Opus 4.7 and Claude Fable/Mythos 5 the Anthropic API
+     * default is `"omitted"`, which leaves callers waiting on a silent stream during
+     * long reasoning runs (issue #1373). We default to `"summarized"` so adaptive-
+     * thinking models that accept the field keep producing visible thinking deltas.
+     * Older adaptive-thinking models (Opus 4.6, Sonnet 4.6+) reject the field, so
+     * we omit it for them.
      */
     thinkingDisplay?: BedrockThinkingDisplay;
 }

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

@@ -1,3 +1,4 @@
+import { ProviderHttpError } from "../errors";
 import type { FetchImpl } from "../types";
 import type { MessageCreateParamsStreaming } from "./anthropic-wire";
 /** Per-request options accepted by {@link AnthropicMessages.create}. */
@@ -11,7 +12,9 @@ export interface AnthropicRequestOptions {
 /**
  * Extra `RequestInit` fields merged into every fetch call. Bun extends
  * `RequestInit` with a `tls` option used for the Claude Code TLS profile and
- * Foundry mTLS.
+ * Foundry mTLS. Core request fields (`method`, `headers`, `body`, `signal`)
+ * are owned by the client and cannot be overridden from here — the timeout
+ * controller's signal in particular must always win.
  */
 export type AnthropicFetchOptions = RequestInit & {
     tls?: {
@@ -22,6 +25,8 @@ export type AnthropicFetchOptions = RequestInit & {
         cert?: string;
         key?: string;
     };
+    /** Bun extension: see {@link FetchWithRetryOptions.timeout} — `false` disables Bun's native fetch TTFT timeout (issue #2422). */
+    timeout?: number | false;
 };
 export interface AnthropicClientOptions {
     /** Sent as `X-Api-Key` unless the header is already present in `defaultHeaders`. */
@@ -37,8 +42,7 @@ export interface AnthropicClientOptions {
     fetchOptions?: AnthropicFetchOptions;
 }
 /** Non-2xx response from the Anthropic API. */
-export declare class AnthropicApiError extends Error {
-    readonly status: number;
+export declare class AnthropicApiError extends ProviderHttpError {
     readonly headers: Headers;
     readonly requestId: string | null;
     constructor(status: number, message: string, headers: Headers);
@@ -52,6 +56,9 @@ export declare class AnthropicConnectionError extends Error {
 export declare class AnthropicConnectionTimeoutError extends Error {
     constructor();
 }
+/** Server-suggested delay (`retry-after-ms`, then `retry-after` seconds or HTTP date). */
+export declare function retryDelayFromHeaders(headers: Headers | undefined): number | undefined;
+export declare function calculateAnthropicRetryDelayMs(attempt: number): number;
 /**
  * Lazy in-flight request handle. The HTTP request starts on the first
  * `asResponse()` call; subsequent calls return the same promise.

package/dist/types/providers/anthropic-messages-server-schema.d.ts

@@ -5,9 +5,9 @@
  * `.refine(...)` so the error mentions them explicitly.
  *
  * Used by `anthropic-messages.ts:parseRequest` to validate the inbound JSON
- * before walking it into @prometheus-ai/ai's canonical `Context`.
+ * before walking it into Prometheus AI's canonical `Context`.
  */
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ContentBlockParam, ImageBlockParam, MessageCreateParams, MessageParam, TextBlockParam, Tool, ToolChoice } from "./anthropic-wire";
 export declare const cacheControlSchema: z.ZodObject<{
     type: z.ZodLiteral<"ephemeral">;

package/dist/types/providers/anthropic-messages-server.d.ts

@@ -1,14 +1,14 @@
 import type { AssistantMessage, AssistantMessageEventStream } from "../types";
 /**
- * Anthropic Messages API (https://docs.anthropic.com/en/api/messages) ↔ @prometheus-ai/ai
+ * Anthropic Messages API (https://docs.anthropic.com/en/api/messages) ↔ Prometheus AI
  * gateway translation. Inbound: foreign HTTP body → prometheus Context. Outbound:
  * prometheus AssistantMessage[Stream] → Anthropic-shaped JSON / SSE.
  */
-import type { AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
+import type { AuthGatewayStreamControl, AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
 export type { ParsedRequest };
 export declare function parseRequest(body: unknown, headers?: Headers): ParsedRequest;
 export declare function encodeResponse(message: AssistantMessage, requestedModelId: string): Record<string, unknown>;
-export declare function encodeStream(events: AssistantMessageEventStream, requestedModelId: string): ReadableStream<Uint8Array>;
+export declare function encodeStream(events: AssistantMessageEventStream, requestedModelId: string, _options?: ParsedRequest["options"], control?: AuthGatewayStreamControl): ReadableStream<Uint8Array>;
 /**
  * Anthropic error envelope: `{ type: "error", error: { type, message } }`.
  * See https://docs.anthropic.com/en/api/errors. Returned as a `Response` so

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

@@ -1,12 +1,12 @@
 /**
  * Anthropic Messages API wire types.
  *
- * Hand-maintained against https://docs.anthropic.com/en/api/messages so @prometheus-ai/ai
+ * Hand-maintained against https://docs.anthropic.com/en/api/messages so Prometheus AI
  * does not depend on `@anthropic-ai/sdk` for type information. Only the shapes
  * this package actually reads or writes are modeled; fields we never touch are
  * intentionally omitted. Names mirror the SDK so call sites read the same.
  *
- * Unlike the SDK, beta fields @prometheus-ai/ai uses (`speed`, `context_management`,
+ * Unlike the SDK, beta fields Prometheus AI uses (`speed`, `context_management`,
  * `output_config.effort`/`task_budget`, `thinking.display`, cache-control
  * `scope`, tool `strict`/`eager_input_streaming`, mid-conversation `system`
  * role) are first-class here instead of being patched in via casts.
@@ -165,7 +165,7 @@ export type MessageCreateParams = {
 export type MessageCreateParamsStreaming = MessageCreateParams & {
     stream: true;
 };
-export type StopReason = "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "pause_turn" | "refusal" | "sensitive";
+export type StopReason = "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "pause_turn" | "refusal" | "sensitive" | "model_context_window_exceeded";
 export type CacheCreation = {
     ephemeral_5m_input_tokens?: number | null;
     ephemeral_1h_input_tokens?: number | null;

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

@@ -14,7 +14,6 @@ export type AnthropicHeaderOptions = {
 };
 export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
 export declare function buildBetaHeader(baseBetas: readonly string[], extraBetas: readonly string[]): string;
-export declare function isAnthropicApiBaseUrl(baseUrl?: string): boolean;
 export declare function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<string, string>;
 type AnthropicCacheControl = NonNullable<TextBlockParam["cache_control"]>;
 /**
@@ -26,9 +25,12 @@ type AnthropicCacheControl = NonNullable<TextBlockParam["cache_control"]>;
  */
 export declare function clearAnthropicFastModeFallback(providerSessionState: Map<string, ProviderSessionState> | undefined): void;
 export declare function isAnthropicFastModeUnsupportedError(error: unknown): boolean;
-export declare const claudeCodeVersion = "2.1.160";
+export declare const claudeCodeVersion = "2.1.165";
+export declare const claudeAgentSdkVersion = "0.3.165";
+export declare const claudeClientVersion = "1.11187.4";
 export declare const claudeToolPrefix: string;
-export declare const claudeCodeSystemInstruction = "You are Claude Code, Anthropic's official CLI for Claude.";
+export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
+export declare const CLAUDE_CODE_MAX_OUTPUT_TOKENS = 64000;
 export declare function mapStainlessOs(platform: string): "MacOS" | "Windows" | "Linux" | "FreeBSD" | `Other::${string}`;
 export declare function mapStainlessArch(arch: string): "x64" | "arm64" | "x86" | `other::${string}`;
 export declare const claudeCodeHeaders: {
@@ -40,27 +42,54 @@ export declare const claudeCodeHeaders: {
     "X-Stainless-Arch": "arm64" | "x64" | "x86" | `other::${string}`;
     "X-Stainless-OS": "FreeBSD" | "Linux" | "MacOS" | "Windows" | `Other::${string}`;
     "X-Stainless-Timeout": string;
+    "anthropic-client-platform": string;
+    "anthropic-client-version": string;
 };
+/**
+ * Wraps a fetch implementation to patch the Claude Code billing-header `cch`
+ * attestation into outgoing request bodies. Bodies without the placeholder
+ * pass through untouched, so installing it on every OAuth flow is safe.
+ */
+export declare function wrapFetchForCch(base: FetchImpl): FetchImpl;
 export declare function isClaudeCloakingUserId(userId: string): boolean;
 export declare function generateClaudeCloakingUserId(): string;
-export declare const applyClaudeToolPrefix: (name: string, prefixOverride?: string) => string;
-export declare const stripClaudeToolPrefix: (name: string, prefixOverride?: string) => string;
+export declare function deriveClaudeDeviceId(installId: string, accountId?: string): string;
+/**
+ * Resolve the `metadata.user_id` field for an Anthropic Messages request.
+ *
+ * For API-key tokens, an explicit caller-supplied `userId` is forwarded
+ * verbatim and `undefined` yields no metadata. For OAuth tokens the value
+ * must match the Claude Code attribution shape (`isClaudeCloakingUserId` or
+ * the `{session_id, account_uuid?, device_id?}` JSON envelope) — anything
+ * else is dropped and a fresh Claude-Code-style JSON id is generated from
+ * `sessionId`/`accountId` so attribution stays consistent across the main
+ * streaming path and provider-specific request builders (e.g. web search).
+ */
+export declare function resolveAnthropicMetadataUserId(userId: unknown, isOAuthToken: boolean, sessionId?: string, accountId?: string): string | undefined;
+export declare const applyClaudeToolPrefix: (name: string) => string;
+export declare const stripClaudeToolPrefix: (name: string) => string;
 export type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
 export type AnthropicThinkingDisplay = "summarized" | "omitted";
 export interface AnthropicOptions extends StreamOptions {
     /**
      * Enable extended thinking.
-     * For Opus 4.6+: uses adaptive thinking (Claude decides when/how much to think).
-     * For older models: uses budget-based thinking with thinkingBudgetTokens.
+     * For adaptive-capable models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5):
+     * uses adaptive thinking (Claude decides when/how much to think). For older
+     * models: uses budget-based thinking with thinkingBudgetTokens.
      */
     thinkingEnabled?: boolean;
     /**
      * Token budget for extended thinking (older models only).
-     * Ignored for Opus 4.6+ which uses adaptive thinking.
+     * Ignored for adaptive-capable models.
      */
     thinkingBudgetTokens?: number;
     /**
-     * Effort level for adaptive thinking (Opus 4.6+ only).
+     * Upstream wire model id override for collapsed effort-tier variants.
+     * Serialized as `requestModelId ?? model.requestModelId ?? model.id`.
+     */
+    requestModelId?: string;
+    /**
+     * Effort level for adaptive thinking.
      * Controls how much thinking Claude allocates:
      * - "max": Always thinks with no constraints
      * - "high": Always thinks, deep reasoning (default)
@@ -117,7 +146,6 @@ export type AnthropicClientOptionsArgs = {
     hasTools?: boolean;
     thinkingEnabled?: boolean;
     thinkingDisplay?: AnthropicThinkingDisplay;
-    onSseEvent?: AnthropicOptions["onSseEvent"];
     fetch?: FetchImpl;
     claudeCodeSessionId?: string;
 };
@@ -155,9 +183,8 @@ export type AnthropicUsageLike = {
 };
 /**
  * Capture Anthropic's optional cache-creation TTL breakdown and server-tool-use
- * counters into the harness Usage shape. Only sets fields that were reported, so
- * a `message_delta` that omits `cache_creation` does not clobber the breakdown
- * established at `message_start`.
+ * counters into the harness Usage shape. Omitted/null fields are no-ops; explicit
+ * zero-valued objects clear prior extras from earlier stream usage snapshots.
  */
 export declare function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void;
 export declare const streamAnthropic: StreamFunction<"anthropic-messages">;
@@ -178,29 +205,9 @@ export declare function normalizeExtraBetas(betas?: string[] | string): string[]
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
 /**
  * A single Anthropic conversation turn, including the mid-conversation
- * `system` role (Opus 4.8+).
+ * `system` role (Opus 4.8+ and Fable/Mythos 5).
  */
 export type AnthropicMessageParam = MessageParam;
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean): AnthropicMessageParam[];
-/**
- * Normalize a JSON Schema node for Anthropic tool `input_schema`.
- *
- * Applies the full whitelist semantics from the Anthropic Python SDK's
- * `lib/_parse/_transform.py::transform_schema`:
- *
- * 1. Universal keys (`$ref`, `$defs`, `type`, `anyOf`/`oneOf`/`allOf`, `enum`, `const`,
- *    `description`, `title`, `default`, `nullable`) are preserved on every node.
- * 2. Per-type keys are kept additively (object → `properties`/`required`/`additionalProperties`,
- *    array → `items`/`prefixItems` plus `minItems` only when 0 or 1, string → `format`
- *    only when in the supported value set).
- * 3. Everything else is demoted into the node's `description` as `\n\n{key: value, ...}`
- *    so the model still sees the constraint as a natural-language hint.
- *
- * Object nodes default to `additionalProperties: false`, but explicit open-map
- * declarations (`additionalProperties: true` or a schema literal — Zod's
- * `z.record(z.string(), z.unknown())` produces `{}`) are preserved. The strict-mode
- * pass downstream demotes those shapes to non-strict instead of fabricating a closed
- * object, so callers like the resolve tool keep working open-map semantics.
- */
 export declare function normalizeAnthropicToolSchema(schema: unknown): unknown;
 export {};

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

@@ -41,3 +41,11 @@ export declare function resolveAwsCredentials(opts?: CredentialResolveOptions):
 export declare function tokenizeCredentialProcessCommand(cmd: string): string[];
 /** Test/diagnostic helper — drops cached credentials. */
 export declare function clearAwsCredentialCache(): void;
+/**
+ * Drop the cache entry for one profile/region. Called by the Bedrock provider on
+ * 401/403 responses so stale credentials are re-resolved instead of served until restart.
+ */
+export declare function invalidateAwsCredentialCache(opts?: {
+    profile?: string;
+    region?: string;
+}): void;

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

@@ -1,4 +1,5 @@
 import type { ServiceTier, StreamFunction, StreamOptions, ToolChoice } from "../types";
+export declare function parseAzureDeploymentNameMap(value: string | undefined): Map<string, string>;
 export interface AzureOpenAIResponsesOptions extends StreamOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
     reasoningSummary?: "auto" | "detailed" | "concise" | null;

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

@@ -1,3 +1,4 @@
+import { ProviderHttpError } from "../errors";
 import type { Context, Model, StreamFunction, StreamOptions } from "../types";
 import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "./google-shared";
 import { type GoogleThinkingLevel } from "./google-shared";
@@ -6,6 +7,10 @@ import { type GoogleThinkingLevel } from "./google-shared";
  * `import { GoogleThinkingLevel } from "./google-gemini-cli"` callers keep working.
  */
 export type { GoogleThinkingLevel };
+/** Non-2xx response (or in-stream error chunk) from the Cloud Code Assist API. */
+export declare class GeminiCliApiError extends ProviderHttpError {
+    readonly name = "GeminiCliApiError";
+}
 export interface GoogleGeminiCliOptions extends StreamOptions {
     /**
      * Tool selection mode. String forms map directly to Gemini
@@ -29,10 +34,26 @@ export interface GoogleGeminiCliOptions extends StreamOptions {
         budgetTokens?: number;
         /** Thinking level. Use for Gemini 3 models (LOW/HIGH for Pro, MINIMAL/LOW/MEDIUM/HIGH for Flash). */
         level?: GoogleThinkingLevel;
+        /**
+         * Explicit wire suppression when `enabled` is false. Cloud Code Assist
+         * re-applies the per-id baked server default when thinkingConfig is
+         * omitted, so models with `thinking.suppressWhenOff` must send
+         * `includeThoughts: false` plus a MINIMAL level (or zero budget).
+         */
+        suppress?: {
+            level: GoogleThinkingLevel;
+        } | {
+            budget: number;
+        };
     };
+    /**
+     * Upstream wire model id override for collapsed effort-tier variants.
+     * Serialized as `requestModelId ?? model.requestModelId ?? model.id`.
+     */
+    requestModelId?: string;
     projectId?: string;
 }
-export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders, getGeminiCliUserAgent, } from "./google-gemini-headers";
+export { ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION, ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders, getGeminiCliUserAgent, } from "@prometheus-ai/catalog/wire/gemini-headers";
 interface ParsedGeminiCliCredentials {
     accessToken: string;
     projectId: string;

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

@@ -1,12 +1,17 @@
 /**
  * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
  */
+import { ProviderHttpError } from "../errors";
 import type { AssistantMessage, Context, FetchImpl, Model, StopReason, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall } from "../types";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { normalizeSchemaForGoogle } from "../utils/schema";
 import type { Content, FinishReason, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, Part } from "./google-types";
 export type { Content, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, ThinkingConfig, } from "./google-types";
 export { normalizeSchemaForGoogle };
+/** Non-2xx response (or in-stream error chunk) from the Google Generative Language / Vertex API. */
+export declare class GoogleApiError extends ProviderHttpError {
+    readonly name = "GoogleApiError";
+}
 type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vertex";
 /**
  * Thinking level for Gemini 3 models. Mirrors Google's `ThinkingLevel` enum values.
@@ -92,6 +97,23 @@ export declare function mapStopReason(reason: FinishReason): StopReason;
  * Map string finish reason to our StopReason (for raw API responses).
  */
 export declare function mapStopReasonString(reason: string): StopReason;
+/**
+ * Bounded retries for the well-known Gemini "empty response" failure: a benign
+ * `finishReason: STOP` carrying only an empty/whitespace text part and no tool call.
+ * Shared by the public/Vertex `streamGoogleGenAI` path and the Cloud Code Assist
+ * (`google-gemini-cli`/`google-antigravity`) provider so both apply the same policy.
+ */
+export declare const MAX_EMPTY_STREAM_RETRIES = 2;
+export declare const EMPTY_STREAM_BASE_DELAY_MS = 500;
+/**
+ * Whether a completed Google assistant message carries content worth delivering.
+ *
+ * A tool call or any non-whitespace text counts as meaningful. An empty/whitespace-only
+ * text part — or thinking that never produced an answer — is the "empty response" failure:
+ * delivered as-is the agent loop has nothing to act on and silently halts, so the request
+ * must be retried instead of surfaced.
+ */
+export declare function hasMeaningfulGoogleContent(output: AssistantMessage): boolean;
 export declare function nextToolCallId(name: string): string;
 /**
  * Push the appropriate `text_end` / `thinking_end` event for the given block.

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

@@ -128,11 +128,23 @@ export interface UsageMetadata {
     totalTokenCount?: number;
     cachedContentTokenCount?: number;
 }
+/** Prompt-level safety feedback; `blockReason` is set (with no candidates) when the prompt is blocked. */
+export interface PromptFeedback {
+    blockReason?: string;
+    blockReasonMessage?: string;
+    [key: string]: unknown;
+}
 /** Single SSE chunk's parsed JSON body. */
 export interface GenerateContentResponse {
     candidates?: Candidate[];
     usageMetadata?: UsageMetadata;
     modelVersion?: string;
     responseId?: string;
-    promptFeedback?: Record<string, unknown>;
+    promptFeedback?: PromptFeedback;
+    /** In-band stream failure (quota, internal error) delivered as a final JSON event. */
+    error?: {
+        code?: number;
+        message?: string;
+        status?: string;
+    };
 }

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

@@ -2,7 +2,7 @@
  * Mock provider for tests.
  *
  * Implements `Model<"mock">` + `streamMock` so test code can drive
- * pi-agent-core / streamSimple-shaped consumers without an HTTP client.
+ * agent-core / streamSimple-shaped consumers without an HTTP client.
  *
  * Usage:
  *
@@ -41,7 +41,7 @@
  *   // Inspect calls afterwards.
  *   expect(mock.calls).toHaveLength(2);
  */
-import type { Api, Context, Model, SimpleStreamOptions, StopReason, Usage } from "../types";
+import type { Api, Context, Model, SimpleStreamOptions, StopDetails, StopReason, Usage } from "../types";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 /** The API string this provider serves. */
 export declare const MOCK_API: "mock";
@@ -67,6 +67,10 @@ export interface MockResponse {
     content?: ReadonlyArray<MockContent>;
     /** Stop reason. Defaults to `"toolUse"` when content has tool calls, else `"stop"`. */
     stopReason?: StopReason;
+    /** Structured terminal stop classification, e.g. Anthropic refusal metadata. */
+    stopDetails?: StopDetails | null;
+    /** Error text paired with an explicit `"error"` stop reason. */
+    errorMessage?: string;
     /** Usage stats. Missing fields default to 0; missing `cost.total` is recomputed from components. */
     usage?: Partial<Omit<Usage, "cost">> & {
         cost?: Partial<Usage["cost"]>;
@@ -142,6 +146,7 @@ export declare class MockModel implements Model<MockApi> {
     readonly cost: Model["cost"];
     readonly contextWindow: number;
     readonly maxTokens: number;
+    readonly compat: undefined;
     /** Recorded calls in invocation order. */
     readonly calls: MockCall[];
     iterator?: Iterator<MockHandler> | AsyncIterator<MockHandler>;
@@ -167,7 +172,7 @@ export declare class MockModel implements Model<MockApi> {
 export declare function isMockModel(model: Model<Api>): model is MockModel;
 /** Construct a mock model. */
 export declare function createMockModel(options?: MockModelOptions): MockModel;
-/** Stream function for `Model<"mock">`. Matches the @prometheus-ai/ai per-provider stream signature. */
+/** Stream function for `Model<"mock">`. Matches the Prometheus AI per-provider stream signature. */
 export declare function streamMock(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
 /** Convenience: register the mock provider with the global custom API registry. */
 export declare function registerMockApi(sourceId?: string): void;

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

@@ -1,6 +1,12 @@
+import { ProviderHttpError } from "../errors";
 import type { StreamFunction, StreamOptions, ToolChoice } from "../types";
+/** Non-2xx response from the Ollama `/api/chat` endpoint. */
+export declare class OllamaApiError extends ProviderHttpError {
+    readonly name = "OllamaApiError";
+}
 export interface OllamaChatOptions extends StreamOptions {
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    disableReasoning?: boolean;
     toolChoice?: ToolChoice;
 }
 export declare const streamOllama: StreamFunction<"ollama-chat">;

package/dist/types/providers/openai-chat-server-schema.d.ts

@@ -7,8 +7,8 @@
  * non-strict defaults (e.g. `stream_options.include_obfuscation`) — does not
  * trip 400s on shapes we simply ignore.
  */
-import type { ChatCompletionContentPart, ChatCompletionCreateParams, ChatCompletionMessageParam, ChatCompletionMessageToolCall, ChatCompletionTool, ChatCompletionToolChoiceOption } from "openai/resources/chat/completions";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
+import type { ChatCompletionContentPart, ChatCompletionCreateParams, ChatCompletionMessageParam, ChatCompletionMessageToolCall, ChatCompletionTool, ChatCompletionToolChoiceOption } from "./openai-chat-wire";
 export declare const textPartSchema: z.ZodObject<{
     type: z.ZodLiteral<"text">;
     text: z.ZodString;
@@ -16,7 +16,7 @@ export declare const textPartSchema: z.ZodObject<{
 /**
  * OpenAI documents `image_url` as either `{ url: string, detail?: ... }` or —
  * older clients — a bare string. Accept both shapes; downstream we extract a
- * URL. `detail` is accepted for forward-compat but currently dropped (@prometheus-ai/ai's
+ * URL. `detail` is accepted for forward-compat but currently dropped (Prometheus AI's
  * `ImageContent` has no detail field — TODO: plumb through if/when added).
  */
 export declare const imagePartSchema: z.ZodObject<{
@@ -283,6 +283,7 @@ export declare const assistantMessageSchema: z.ZodObject<{
             arguments: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>>;
+    reasoning_content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export declare const toolMessageSchema: z.ZodObject<{
     role: z.ZodLiteral<"tool">;
@@ -489,6 +490,7 @@ export declare const messageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             arguments: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>>;
+    reasoning_content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>, z.ZodObject<{
     role: z.ZodLiteral<"tool">;
     content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -700,6 +702,7 @@ export declare const openaiChatRequestSchema: z.ZodObject<{
                 arguments: z.ZodString;
             }, z.core.$strip>;
         }, z.core.$strip>>>;
+        reasoning_content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>, z.ZodObject<{
         role: z.ZodLiteral<"tool">;
         content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{

package/dist/types/providers/openai-chat-server.d.ts

@@ -1,13 +1,13 @@
 /**
- * Parsed inbound OpenAI chat-completions request, ready to feed into @prometheus-ai/ai
+ * Parsed inbound OpenAI chat-completions request, ready to feed into Prometheus AI
  * `stream(model, context, options)`.
  */
-import type { AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
+import type { AuthGatewayStreamControl, AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
 import type { AssistantMessage, AssistantMessageEventStream } from "../types";
 export type { ParsedRequest };
 export declare function parseRequest(body: unknown, headers?: Headers): ParsedRequest;
 export declare function encodeResponse(message: AssistantMessage, requestedModelId: string): Record<string, unknown>;
-export declare function encodeStream(events: AssistantMessageEventStream, requestedModelId: string, options?: ParsedRequest["options"]): ReadableStream<Uint8Array>;
+export declare function encodeStream(events: AssistantMessageEventStream, requestedModelId: string, options?: ParsedRequest["options"], control?: AuthGatewayStreamControl): ReadableStream<Uint8Array>;
 /**
  * OpenAI chat-completions error envelope:
  *   `{ error: { message, type } }`