@gajae-code/ai 0.1.1

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

@@ -0,0 +1,3 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage";
+export declare const claudeUsageProvider: UsageProvider;
+export declare const claudeRankingStrategy: CredentialRankingStrategy;

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

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

package/dist/types/usage/github-copilot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GitHub Copilot usage provider.
+ *
+ * Normalizes Copilot quota usage into the shared UsageReport schema.
+ */
+import type { UsageProvider } from "../usage";
+export declare const githubCopilotUsageProvider: UsageProvider;

package/dist/types/usage/google-antigravity.d.ts

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

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

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

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

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

package/dist/types/usage/openai-codex.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage";
+export declare const openaiCodexUsageProvider: UsageProvider;
+export declare const codexRankingStrategy: CredentialRankingStrategy;

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

@@ -0,0 +1 @@
+export declare const toNumber: (value: unknown) => number | undefined;

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

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

package/dist/types/usage.d.ts

@@ -0,0 +1,258 @@
+/**
+ * Usage reporting types for provider quota/limit endpoints.
+ *
+ * Provides a normalized schema to represent multiple limit windows, model tiers,
+ * and shared quotas across providers.
+ */
+import * as z from "zod/v4";
+import type { Provider } from "./types";
+export type UsageUnit = "percent" | "tokens" | "requests" | "usd" | "minutes" | "bytes" | "unknown";
+export type UsageStatus = "ok" | "warning" | "exhausted" | "unknown";
+/** Time window for a limit (e.g. 5h, 7d, monthly). */
+export interface UsageWindow {
+    /** Stable identifier (e.g. "5h", "7d", "monthly"). */
+    id: string;
+    /** Human label (e.g. "5 Hour", "7 Day"). */
+    label: string;
+    /** Window duration in milliseconds, when known. */
+    durationMs?: number;
+    /** Absolute reset timestamp in milliseconds since epoch. */
+    resetsAt?: number;
+}
+/** Quantitative usage data. */
+export interface UsageAmount {
+    /** Amount used in the given unit. */
+    used?: number;
+    /** Maximum limit in the given unit. */
+    limit?: number;
+    /** Remaining amount in the given unit. */
+    remaining?: number;
+    /** Fraction used (0..1). */
+    usedFraction?: number;
+    /** Fraction remaining (0..1). */
+    remainingFraction?: number;
+    /** Unit for the amounts (percent, tokens, etc.). */
+    unit: UsageUnit;
+}
+/** Scope metadata describing what the limit applies to. */
+export interface UsageScope {
+    provider: Provider;
+    accountId?: string;
+    projectId?: string;
+    orgId?: string;
+    modelId?: string;
+    tier?: string;
+    windowId?: string;
+    shared?: boolean;
+}
+/** Normalized limit entry for a single window or quota bucket. */
+export interface UsageLimit {
+    /** Stable identifier for this limit entry. */
+    id: string;
+    /** Human label for display. */
+    label: string;
+    scope: UsageScope;
+    window?: UsageWindow;
+    amount: UsageAmount;
+    status?: UsageStatus;
+    notes?: string[];
+}
+/** Aggregated usage report for a provider. */
+export interface UsageReport {
+    provider: Provider;
+    fetchedAt: number;
+    limits: UsageLimit[];
+    metadata?: Record<string, unknown>;
+    raw?: unknown;
+}
+export declare const usageUnitSchema: z.ZodEnum<{
+    bytes: "bytes";
+    minutes: "minutes";
+    percent: "percent";
+    requests: "requests";
+    tokens: "tokens";
+    unknown: "unknown";
+    usd: "usd";
+}>;
+export declare const usageStatusSchema: z.ZodEnum<{
+    exhausted: "exhausted";
+    ok: "ok";
+    unknown: "unknown";
+    warning: "warning";
+}>;
+export declare const usageWindowSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    resetsAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const usageAmountSchema: z.ZodObject<{
+    used: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    remaining: z.ZodOptional<z.ZodNumber>;
+    usedFraction: z.ZodOptional<z.ZodNumber>;
+    remainingFraction: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodEnum<{
+        bytes: "bytes";
+        minutes: "minutes";
+        percent: "percent";
+        requests: "requests";
+        tokens: "tokens";
+        unknown: "unknown";
+        usd: "usd";
+    }>;
+}, z.core.$strip>;
+export declare const usageScopeSchema: z.ZodObject<{
+    provider: z.ZodString;
+    accountId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    orgId: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodString>;
+    windowId: z.ZodOptional<z.ZodString>;
+    shared: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const usageLimitSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    scope: z.ZodObject<{
+        provider: z.ZodString;
+        accountId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        orgId: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        tier: z.ZodOptional<z.ZodString>;
+        windowId: z.ZodOptional<z.ZodString>;
+        shared: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    window: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        resetsAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    amount: z.ZodObject<{
+        used: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        remaining: z.ZodOptional<z.ZodNumber>;
+        usedFraction: z.ZodOptional<z.ZodNumber>;
+        remainingFraction: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodEnum<{
+            bytes: "bytes";
+            minutes: "minutes";
+            percent: "percent";
+            requests: "requests";
+            tokens: "tokens";
+            unknown: "unknown";
+            usd: "usd";
+        }>;
+    }, z.core.$strip>;
+    status: z.ZodOptional<z.ZodEnum<{
+        exhausted: "exhausted";
+        ok: "ok";
+        unknown: "unknown";
+        warning: "warning";
+    }>>;
+    notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const usageReportSchema: z.ZodObject<{
+    provider: z.ZodString;
+    fetchedAt: z.ZodNumber;
+    limits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        scope: z.ZodObject<{
+            provider: z.ZodString;
+            accountId: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            orgId: z.ZodOptional<z.ZodString>;
+            modelId: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodString>;
+            windowId: z.ZodOptional<z.ZodString>;
+            shared: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        window: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            durationMs: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        amount: z.ZodObject<{
+            used: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            remaining: z.ZodOptional<z.ZodNumber>;
+            usedFraction: z.ZodOptional<z.ZodNumber>;
+            remainingFraction: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodEnum<{
+                bytes: "bytes";
+                minutes: "minutes";
+                percent: "percent";
+                requests: "requests";
+                tokens: "tokens";
+                unknown: "unknown";
+                usd: "usd";
+            }>;
+        }, z.core.$strip>;
+        status: z.ZodOptional<z.ZodEnum<{
+            exhausted: "exhausted";
+            ok: "ok";
+            unknown: "unknown";
+            warning: "warning";
+        }>>;
+        notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    raw: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/** Optional logger for usage fetchers. */
+export interface UsageLogger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+}
+/** Credential bundle for usage endpoints. */
+export interface UsageCredential {
+    type: "api_key" | "oauth";
+    apiKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    accountId?: string;
+    projectId?: string;
+    email?: string;
+    enterpriseUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Parameters provided to a usage fetcher. */
+export interface UsageFetchParams {
+    provider: Provider;
+    credential: UsageCredential;
+    baseUrl?: string;
+    signal?: AbortSignal;
+}
+/** Shared runtime utilities for fetchers. */
+export interface UsageFetchContext {
+    fetch: typeof fetch;
+    logger?: UsageLogger;
+    retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+}
+/** Provider implementation for fetching usage information. */
+export interface UsageProvider {
+    id: Provider;
+    fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null>;
+    supports?(params: UsageFetchParams): boolean;
+}
+/** Strategy for usage-based credential ranking. Providers implement this to opt into smart credential selection. */
+export interface CredentialRankingStrategy {
+    /** Extract the primary (short) and secondary (long) window limits from a usage report. */
+    findWindowLimits(report: UsageReport): {
+        primary?: UsageLimit;
+        secondary?: UsageLimit;
+    };
+    /** Fallback window durations (ms) when limits don't specify durationMs. */
+    windowDefaults: {
+        primaryMs: number;
+        secondaryMs: number;
+    };
+    /** Optional: priority boost for specific credential states (e.g., fresh 5h ticker start). */
+    hasPriorityBoost?(primary: UsageLimit | undefined): boolean;
+}

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

@@ -0,0 +1,19 @@
+export interface AbortSourceTracker {
+    requestAbortController: AbortController;
+    requestSignal: AbortSignal;
+    abortLocally(reason: Error): Error;
+    getLocalAbortReason(): Error | undefined;
+    wasCallerAbort(): boolean;
+}
+/**
+ * Tracks whether a merged request signal was aborted by the caller or by provider-local logic.
+ *
+ * Caller aborts always take priority. When both the caller and a local watchdog fire near
+ * each other, the merged `requestSignal.reason` reflects whichever AbortController called
+ * `.abort()` first — but ordering is racy and not meaningful for upstream consumers. What
+ * matters is intent: if the caller's signal aborted, the request was cancelled by the
+ * caller, and any local watchdog reason is incidental and **MUST NOT** be surfaced as a
+ * retryable transient error (which would cause auto-retry to re-enter streaming and leave
+ * the UI showing a spinner the user already tried to cancel).
+ */
+export declare function createAbortSourceTracker(callerSignal?: AbortSignal): AbortSourceTracker;

package/dist/types/utils/anthropic-auth.d.ts

@@ -0,0 +1,31 @@
+/** Auth configuration for Anthropic */
+export interface AnthropicAuthConfig {
+    apiKey: string;
+    baseUrl: string;
+    isOAuth: boolean;
+}
+export declare function resolveAnthropicBaseUrlFromEnv(): string | undefined;
+/**
+ * Checks if a token is an OAuth token by looking for sk-ant-oat prefix.
+ */
+export declare function isOAuthToken(apiKey: string): boolean;
+/**
+ * Build an {@link AnthropicAuthConfig} from an already-resolved API key.
+ *
+ * `apiKey` is whatever the caller chose for `Authorization`/`x-api-key` —
+ * usually `authStorage.getApiKey("anthropic")`. `baseUrl` overrides the
+ * env-derived base; pass `undefined` to fall back to FOUNDRY/ANTHROPIC env
+ * resolution and finally `DEFAULT_BASE_URL`.
+ *
+ * `isOAuth` is derived from the token prefix so the helper stays pure: callers
+ * never have to thread the OAuth flag through their own resolution logic.
+ */
+export declare function buildAnthropicAuthConfig(apiKey: string, baseUrl?: string): AnthropicAuthConfig;
+/**
+ * Builds HTTP headers for Anthropic API requests (search variant).
+ */
+export declare function buildAnthropicSearchHeaders(auth: AnthropicAuthConfig): Record<string, string>;
+/**
+ * Builds the full API URL for Anthropic messages endpoint.
+ */
+export declare function buildAnthropicUrl(auth: AnthropicAuthConfig): string;

package/dist/types/utils/discovery/antigravity.d.ts

@@ -0,0 +1,61 @@
+import type { Model } from "../../types";
+/**
+ * Raw model metadata returned by Antigravity's `fetchAvailableModels` endpoint.
+ */
+export interface AntigravityDiscoveryApiModel {
+    displayName?: string;
+    supportsImages?: boolean;
+    supportsThinking?: boolean;
+    thinkingBudget?: number;
+    recommended?: boolean;
+    maxTokens?: number;
+    maxOutputTokens?: number;
+    model?: string;
+    apiProvider?: string;
+    modelProvider?: string;
+    isInternal?: boolean;
+    supportsVideo?: boolean;
+}
+/**
+ * Grouping metadata used by Antigravity to surface recommended model ids.
+ */
+export interface AntigravityDiscoveryAgentModelGroup {
+    modelIds?: string[];
+}
+/**
+ * Sort/group metadata used by Antigravity to surface recommended model ids.
+ */
+export interface AntigravityDiscoveryAgentModelSort {
+    groups?: AntigravityDiscoveryAgentModelGroup[];
+}
+/**
+ * Response payload returned by Antigravity's `fetchAvailableModels` endpoint.
+ */
+export interface AntigravityDiscoveryApiResponse {
+    models?: Record<string, AntigravityDiscoveryApiModel>;
+    agentModelSorts?: AntigravityDiscoveryAgentModelSort[];
+}
+/**
+ * Options for fetching Antigravity discovery models.
+ */
+export interface FetchAntigravityDiscoveryModelsOptions {
+    /** OAuth access token used as `Authorization: Bearer <token>`. */
+    token: string;
+    /** Optional endpoint override. Defaults to Antigravity fallback endpoints. */
+    endpoint?: string;
+    /** Deprecated and ignored for antigravity discovery parity. */
+    project?: string;
+    /** Optional user agent override. */
+    userAgent?: string;
+    /** Optional abort signal for request cancellation. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetcher?: typeof fetch;
+}
+/**
+ * Fetches discoverable Antigravity models and normalizes them into canonical model entries.
+ *
+ * Returns `null` on network/payload/auth failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchAntigravityDiscoveryModels(options: FetchAntigravityDiscoveryModelsOptions): Promise<Model<"google-gemini-cli">[] | null>;

package/dist/types/utils/discovery/codex.d.ts

@@ -0,0 +1,38 @@
+import type { Model } from "../../types";
+/**
+ * Fetch options for OpenAI code provider model discovery.
+ */
+export interface CodexModelDiscoveryOptions {
+    /** OAuth access token used for `Authorization: Bearer ...`. */
+    accessToken: string;
+    /** ChatGPT account id value used for `chatgpt-account-id` header. */
+    accountId?: string;
+    /** Base URL for OpenAI code backend backend. Defaults to `https://chatgpt.com/backend-api`. */
+    baseUrl?: string;
+    /** Optional client version attached as `client_version` query parameter. */
+    clientVersion?: string;
+    /** Optional endpoint path candidates. Defaults to `/OpenAI code backend/models`, then `/models`. */
+    paths?: readonly string[];
+    /** Additional headers merged on top of required OpenAI code backend headers. */
+    headers?: Record<string, string>;
+    /** Abort signal for network request cancellation. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetchFn?: typeof fetch;
+    /** Optional registry fetch implementation override for client version lookup. */
+    registryFetchFn?: typeof fetch;
+}
+/**
+ * Normalized OpenAI code backend discovery response.
+ */
+export interface CodexModelDiscoveryResult {
+    models: Model<"openai-codex-responses">[];
+    etag?: string;
+}
+/**
+ * Fetches model metadata from OpenAI code backend backend and normalizes it for pi model management.
+ *
+ * Returns `null` when no supported model-list route can be fetched/parsed.
+ * Returns `{ models: [] }` when a route succeeds but yields no usable models.
+ */
+export declare function fetchCodexModels(options: CodexModelDiscoveryOptions): Promise<CodexModelDiscoveryResult | null>;

package/dist/types/utils/discovery/cursor.d.ts

@@ -0,0 +1,23 @@
+import type { Model } from "../../types";
+/**
+ * Options for fetching dynamic Cursor models from `GetUsableModels`.
+ */
+export interface CursorModelDiscoveryOptions {
+    /** Cursor access token used for bearer authentication. */
+    apiKey: string;
+    /** Optional Cursor API base URL override. */
+    baseUrl?: string;
+    /** Optional client version override sent as `x-cursor-client-version`. */
+    clientVersion?: string;
+    /** Optional request timeout in milliseconds. */
+    timeoutMs?: number;
+    /** Optional list of custom Cursor model ids to include in request context. */
+    customModelIds?: string[];
+}
+/**
+ * Fetches Cursor models through `GetUsableModels` and normalizes them into canonical model entries.
+ *
+ * Returns `null` on request/decode failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchCursorUsableModels(options: CursorModelDiscoveryOptions): Promise<Model<"cursor-agent">[] | null>;

package/dist/types/utils/discovery/gemini.d.ts

@@ -0,0 +1,25 @@
+import type { Model } from "../../types";
+/**
+ * Configuration for Google Generative AI model discovery.
+ */
+export interface GeminiDiscoveryOptions {
+    /** API key for the Google Generative AI public endpoint. */
+    apiKey: string;
+    /** Optional endpoint override for testing or proxying. */
+    baseUrl?: string;
+    /** Optional requested page size for model listing. */
+    pageSize?: number;
+    /** Maximum number of pages to request before stopping pagination. */
+    maxPages?: number;
+    /** Optional abort signal for HTTP requests. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetch?: typeof fetch;
+}
+/**
+ * Fetches and normalizes Google Generative AI models from the public models endpoint.
+ *
+ * Returns `null` on transport/protocol failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchGeminiModels(options: GeminiDiscoveryOptions): Promise<Model<"google-generative-ai">[] | null>;

package/dist/types/utils/discovery/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./antigravity";
+export * from "./codex";
+export * from "./gemini";
+export * from "./openai-compatible";

package/dist/types/utils/discovery/openai-compatible.d.ts

@@ -0,0 +1,72 @@
+import type { Api, Model, Provider } from "../../types";
+/**
+ * Minimal OpenAI-style model entry shape consumed by discovery.
+ *
+ * Providers may return additional fields; this type only captures
+ * fields that are useful for generic normalization.
+ */
+export interface OpenAICompatibleModelRecord {
+    id?: unknown;
+    name?: unknown;
+    object?: unknown;
+    owned_by?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Tolerant envelope for OpenAI-compatible `/models` responses.
+ *
+ * Common providers return `{ data: [...] }`, but variants such as
+ * `{ models: [...] }`, `{ result: [...] }`, or direct arrays are also
+ * accepted during extraction.
+ */
+export interface OpenAICompatibleModelsEnvelope {
+    data?: unknown;
+    models?: unknown;
+    result?: unknown;
+    items?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Context passed to custom OpenAI-compatible model mappers.
+ */
+export interface OpenAICompatibleModelMapperContext<TApi extends Api> {
+    api: TApi;
+    provider: Provider;
+    baseUrl: string;
+}
+/**
+ * Options for fetching and normalizing OpenAI-compatible `/models` catalogs.
+ */
+export interface FetchOpenAICompatibleModelsOptions<TApi extends Api> {
+    /** API type assigned to normalized models. */
+    api: TApi;
+    /** Provider id assigned to normalized models. */
+    provider: Provider;
+    /** Provider base URL used for both fetch and normalized model records. */
+    baseUrl: string;
+    /** Optional bearer token for Authorization header. */
+    apiKey?: string;
+    /** Additional request headers. */
+    headers?: Record<string, string>;
+    /** Optional AbortSignal for request cancellation. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for testing/custom runtimes. */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Optional post-normalization filter.
+     * Return false to skip a model.
+     */
+    filterModel?: (entry: OpenAICompatibleModelRecord, model: Model<TApi>) => boolean;
+    /**
+     * Optional mapper override for provider-specific quirks.
+     * Return null to skip a model.
+     */
+    mapModel?: (entry: OpenAICompatibleModelRecord, defaults: Model<TApi>, context: OpenAICompatibleModelMapperContext<TApi>) => Model<TApi> | null;
+}
+/**
+ * Fetches and normalizes an OpenAI-compatible `/models` catalog.
+ *
+ * Returns `null` on transport/protocol failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchOpenAICompatibleModels<TApi extends Api>(options: FetchOpenAICompatibleModelsOptions<TApi>): Promise<Model<TApi>[] | null>;

package/dist/types/utils/event-stream.d.ts

@@ -0,0 +1,28 @@
+import type { AssistantMessage, AssistantMessageEvent } from "../types";
+export declare class EventStream<T, R = T> implements AsyncIterable<T> {
+    #private;
+    queue: T[];
+    waiting: Array<{
+        resolve: (value: IteratorResult<T>) => void;
+        reject: (err: unknown) => void;
+    }>;
+    done: boolean;
+    finalResultPromise: Promise<R>;
+    resolveFinalResult: (result: R) => void;
+    rejectFinalResult: (err: unknown) => void;
+    isComplete: (event: T) => boolean;
+    extractResult: (event: T) => R;
+    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
+    push(event: T): void;
+    deliver(event: T): void;
+    end(result?: R): void;
+    endWaiting(): void;
+    fail(err: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    result(): Promise<R>;
+}
+export declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+    constructor();
+    push(event: AssistantMessageEvent): void;
+    end(result?: AssistantMessage): void;
+}

package/dist/types/utils/fireworks-model-id.d.ts

@@ -0,0 +1,10 @@
+export declare function toFireworksPublicModelId(modelId: string): string;
+export declare function toFireworksWireModelId(modelId: string): string;
+/**
+ * Fire Pass exposes its Kimi K2.6 Turbo subscription through a dedicated router
+ * endpoint at `accounts/fireworks/routers/<id>` rather than the `models/` namespace.
+ * We keep a friendly public id (e.g. `kimi-k2.6-turbo`) in the catalog and translate
+ * to the wire form (`accounts/fireworks/routers/kimi-k2p6-turbo`) at request time.
+ */
+export declare function toFirepassPublicModelId(modelId: string): string;
+export declare function toFirepassWireModelId(modelId: string): string;

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

@@ -0,0 +1 @@
+export declare function isFoundryEnabled(): boolean;

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

@@ -0,0 +1,22 @@
+/**
+ * Patch `globalThis.fetch` to advertise HTTP/2 in TLS ALPN, with transparent
+ * HTTP/1.1 fallback when the server doesn't negotiate `h2`.
+ *
+ * Bun's HTTP/2 client is gated on `BUN_FEATURE_FLAG_EXPERIMENTAL_HTTP2_CLIENT`,
+ * read by the native runtime before any JS executes; assigning to
+ * `process.env` from inside JS is a no-op. Per-request `protocol: "http2"`
+ * activates h2 over TLS ALPN and rejects with `error.code === "HTTP2Unsupported"`
+ * if the server picks anything else, so we catch and retry without the hint.
+ *
+ * Some HTTPS endpoints (e.g. corporate API gateways behind reverse proxies)
+ * advertise h2 via ALPN but then refuse or reset the connection at the HTTP/2
+ * framing layer. Bun surfaces these as `ConnectionRefused`, `ConnectionReset`,
+ * or `ConnectionClosed` rather than `HTTP2Unsupported`, so we treat those
+ * codes as h2-fallback triggers as well.
+ *
+ * Bun negotiates h2 via ALPN over TLS only (no h2c), so plain `http://` URLs
+ * skip the attempt entirely — avoids the throw/retry round-trip for localhost.
+ *
+ * Idempotent.
+ */
+export declare function installH2Fetch(): void;