@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/src/providers/opencode-headers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Adds OpenCode's per-conversation routing header before API dispatch.
+ */
+import type { ProviderStreams } from "../types.ts";
+export declare function withOpenCodeSessionHeader(streams: ProviderStreams): ProviderStreams;

package/dist/src/providers/opencode-headers.js

@@ -0,0 +1,6 @@
+import {
+  withOpenCodeSessionHeader2
+} from "../../chunks/account-limits-cache-fht68jp2.js";
+export {
+  withOpenCodeSessionHeader2 as withOpenCodeSessionHeader
+};

package/dist/src/providers/opencode.d.ts

@@ -0,0 +1,14 @@
+import type { Provider } from "../models-types.ts";
+export type OpenCodeApi = "anthropic-messages" | "google-generative-ai" | "openai-completions" | "openai-responses";
+/**
+ * OpenCode models route to several upstream APIs whose long-retention windows differ
+ * (1h on Anthropic, 24h on OpenAI), and some catalog entries do not support long
+ * retention at all, so the providers publish only the floor every route guarantees.
+ */
+export declare const OPENCODE_PROMPT_CACHE: {
+    minimumRetentionMs: {
+        short: number;
+        long: number;
+    };
+};
+export declare function opencodeProvider(): Provider<OpenCodeApi>;

package/dist/src/providers/opencode.js

@@ -0,0 +1,23 @@
+import {
+  OPENCODE_PROMPT_CACHE2,
+  opencodeProvider2
+} from "../../chunks/account-limits-cache-nbkyhs6v.js";
+import"../../chunks/account-limits-cache-x9fvb3s5.js";
+import"../../chunks/account-limits-cache-fht68jp2.js";
+import"../../chunks/account-limits-cache-q1ebtvet.js";
+import"../../chunks/account-limits-cache-eyx1jcxc.js";
+import"../../chunks/account-limits-cache-zqdb4yh4.js";
+import"../../chunks/account-limits-cache-6x05n06z.js";
+import"../../chunks/account-limits-cache-ykbqsvv6.js";
+import"../../chunks/account-limits-cache-90c9c2eb.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-7z9s8j16.js";
+import"../../chunks/account-limits-cache-9wqk28n5.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+export {
+  OPENCODE_PROMPT_CACHE2 as OPENCODE_PROMPT_CACHE,
+  opencodeProvider2 as opencodeProvider
+};

package/dist/src/providers/openrouter.d.ts

@@ -0,0 +1,2 @@
+import type { Provider } from "../models-types.ts";
+export declare function openrouterProvider(): Provider<"openai-completions">;

package/dist/src/providers/openrouter.js

@@ -0,0 +1,19 @@
+import {
+  openrouterProvider2
+} from "../../chunks/account-limits-cache-pfa86y8e.js";
+import"../../chunks/account-limits-cache-ydq8p8qp.js";
+import"../../chunks/account-limits-cache-eyx1jcxc.js";
+import"../../chunks/account-limits-cache-6x05n06z.js";
+import"../../chunks/account-limits-cache-ag5b8dja.js";
+import"../../chunks/account-limits-cache-ykbqsvv6.js";
+import"../../chunks/account-limits-cache-90c9c2eb.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-7z9s8j16.js";
+import"../../chunks/account-limits-cache-9wqk28n5.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+export {
+  openrouterProvider2 as openrouterProvider
+};

package/dist/src/providers/vercel-ai-gateway.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../models-types.ts";
+/** Vercel AI Gateway. Nyte-only: OIDC tokens authenticate only as a bearer, which API keys also accept, so every key is sent as `Authorization: Bearer`. */
+export declare function vercelAiGatewayProvider(): Provider<"anthropic-messages">;

package/dist/src/providers/vercel-ai-gateway.js

@@ -0,0 +1,19 @@
+import {
+  vercelAiGatewayProvider2
+} from "../../chunks/account-limits-cache-q63mc41j.js";
+import"../../chunks/account-limits-cache-ydq8p8qp.js";
+import"../../chunks/account-limits-cache-zqdb4yh4.js";
+import"../../chunks/account-limits-cache-6x05n06z.js";
+import"../../chunks/account-limits-cache-ag5b8dja.js";
+import"../../chunks/account-limits-cache-ykbqsvv6.js";
+import"../../chunks/account-limits-cache-90c9c2eb.js";
+import"../../chunks/account-limits-cache-fsktnetm.js";
+import"../../chunks/account-limits-cache-zcbkmrvy.js";
+import"../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+import"../../chunks/account-limits-cache-7z9s8j16.js";
+import"../../chunks/account-limits-cache-9wqk28n5.js";
+import"../../chunks/account-limits-cache-j2bt392s.js";
+export {
+  vercelAiGatewayProvider2 as vercelAiGatewayProvider
+};

package/dist/src/session-resources.d.ts

@@ -0,0 +1,9 @@
+export type SessionResourceCleanup = (sessionId?: string) => void;
+export declare function registerSessionResourceCleanup(cleanup: SessionResourceCleanup): () => void;
+export declare function cleanupSessionResources(sessionId?: string): void;
+/**
+ * Keep provider caches for a durable session alive while at least one harness
+ * owns them. Runtime/model replacement briefly overlaps harnesses, so cleanup
+ * belongs to the last release rather than to each harness independently.
+ */
+export declare function acquireSessionResources(sessionId: string): () => void;

package/dist/src/session-resources.js

@@ -0,0 +1,10 @@
+import {
+  registerSessionResourceCleanup2,
+  cleanupSessionResources2,
+  acquireSessionResources2
+} from "../chunks/account-limits-cache-gqsrbky9.js";
+export {
+  acquireSessionResources2 as acquireSessionResources,
+  cleanupSessionResources2 as cleanupSessionResources,
+  registerSessionResourceCleanup2 as registerSessionResourceCleanup
+};

package/dist/src/types.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Request option and adapter contract types for @nyte-ai/ai. The neutral message,
+ * model, and tool types live in @nyte-ai/schema and are re-exported here so
+ * callers can import everything from one place; this
+ * file adds only what a provider request needs on top of them: transport and
+ * auth options, and the stream function contract.
+ */
+import type { Api, CacheRetention, DeferredHandle, Model, ThinkingLevel, TranscriptContext } from "@nyte-ai/schema/model";
+import type { AssistantMessageEventStream } from "./utils/event-stream.ts";
+export type { AssistantMessageEventStream } from "./utils/event-stream.ts";
+export type { KnownProvider, OpenAICompletionsCompat, BedrockCompat, CacheRetention, ModelPromptCache, OpenRouterRouting, VercelGatewayRouting, ChatTemplateKwargValue, ThinkingTokenBudgetField, AnthropicAllowedFallbackModel, AnthropicMessagesCompat, Api, AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, ConstrainedSamplingConfig, Context, ProviderCheckpointMaterial, DeferredHandle, DiagnosticErrorInfo, GrammarFormat, GrammarVariants, ImageContent, JsonValue, KnownApi, Message, Model, ModelCost, ModelCostRates, ModelCostTier, ModelMode, ModelThinkingLevel, OpenAIResponsesCompat, ProviderId, SessionAffinityFormat, StopReason, SystemMessage, TextContent, TextSignatureV1, ThinkingContent, ThinkingLevel, ThinkingLevelMap, Tool, ToolCall, ToolReference, ToolResultMessage, TranscriptContext, Usage, UserMessage, } from "@nyte-ai/schema/model";
+export type ToolChoice = "auto" | "none";
+/** Token budgets for each thinking level (token-based providers only) */
+export interface ThinkingBudgets {
+    minimal?: number;
+    low?: number;
+    medium?: number;
+    high?: number;
+}
+export type CachedRetention = Exclude<CacheRetention, "none">;
+/** Provider-owned lower bounds for prompt-cache lifetime after a confirmed read or write. */
+export interface PromptCachePolicy {
+    readonly minimumRetentionMs: Readonly<Record<CachedRetention, number>>;
+}
+export type Transport = "sse" | "websocket" | "websocket-cached" | "auto";
+/** Provider-scoped environment overrides. Values take precedence over process.env. */
+export type ProviderEnv = Record<string, string>;
+export type ProviderHeaders = Record<string, string | null>;
+export type FetchFunction = typeof globalThis.fetch;
+export interface ProviderResponse {
+    status: number;
+    headers: Record<string, string>;
+}
+/** One provider subscription window, normalized as percent consumed. */
+export interface AccountLimitWindow {
+    /** Stable provider-owned bucket id, for example `five_hour` or `seven_day`. */
+    id: string;
+    /** Display name, for example `5-hour`, `Weekly`, or `Opus weekly`. */
+    label: string;
+    usedPercent: number;
+    /** Unix timestamp in milliseconds. */
+    resetsAt?: number;
+    windowMinutes?: number;
+}
+/** Ephemeral account-scoped subscription state. Never conversation usage. */
+export interface AccountLimits {
+    providerId: string;
+    plan?: string;
+    windows: readonly AccountLimitWindow[];
+    /** Unix timestamp in milliseconds when the provider supplied this state. */
+    observedAt: number;
+}
+/** Account windows from a cached refresh, retaining the last reading on failure. */
+export type AccountLimitsResult = {
+    readonly kind: "ready";
+    readonly limits: AccountLimits;
+    readonly stale: boolean;
+    readonly error: string | null;
+} | {
+    readonly kind: "unavailable";
+    readonly reason: "unsupported" | "unconfigured" | "failed";
+    readonly message: string;
+};
+/** Account endpoint metadata, independent of a provider's model catalog. */
+export type AccountLimitsTarget = Pick<Model<Api>, "provider" | "baseUrl" | "headers">;
+/** Auth and transport for a provider's non-generating account usage request. */
+export type AccountLimitsFetchOptions = Pick<ProviderRequestOptions, "apiKey" | "headers" | "fetch" | "signal" | "timeoutMs">;
+/** Authentication, HTTP transport, and lifecycle callbacks shared by provider requests. */
+export interface ProviderRequestOptions<TModel = Model<Api>> {
+    signal?: AbortSignal;
+    /** Request the model's advertised fast inference mode; each API maps it to its own field. */
+    fast?: boolean;
+    apiKey?: string;
+    /**
+     * Optional fetch implementation for provider HTTP requests.
+     * Defaults to `globalThis.fetch`. Provider adapters that cannot inject a custom implementation may reject it.
+     * This does not affect WebSocket transports.
+     */
+    fetch?: FetchFunction;
+    /**
+     * Provider-scoped environment values. These take precedence over process.env for
+     * provider configuration such as regional settings, endpoint placeholders, and
+     * proxy variables.
+     */
+    env?: ProviderEnv;
+    /** Inspects the provider request body just before it is sent. */
+    onPayload?: (payload: unknown, model: TModel) => void | Promise<void>;
+    /**
+     * Optional callback invoked after an HTTP response is received.
+     */
+    onResponse?: (response: ProviderResponse, model: TModel) => void | Promise<void>;
+    /** Account-limit telemetry observed during a provider request. */
+    onAccountLimits?: (limits: AccountLimits, model: TModel) => void | Promise<void>;
+    /**
+     * Optional custom HTTP headers to include in API requests.
+     * Merged with provider defaults; caller values override default headers.
+     * A null value suppresses a provider/API default header with the same name.
+     */
+    headers?: ProviderHeaders;
+    /**
+     * HTTP request timeout in milliseconds for providers/SDKs that support it.
+     * For example, OpenAI and Anthropic SDK clients default to 10 minutes.
+     */
+    timeoutMs?: number;
+    /**
+     * Maximum retry attempts for providers/SDKs that support client-side retries.
+     * For example, OpenAI and Anthropic SDK clients default to 2.
+     */
+    maxRetries?: number;
+    /**
+     * Maximum delay in milliseconds to wait for a retry when the server requests a long wait.
+     * If the server's requested delay exceeds this value, the request fails immediately
+     * with an error containing the requested delay, allowing higher-level retry logic
+     * to handle it with user visibility.
+     * Default: 60000 (60 seconds). Set to 0 to disable the cap.
+     */
+    maxRetryDelayMs?: number;
+}
+export interface StreamOptions extends ProviderRequestOptions<Model<Api>> {
+    /**
+     * Optional callback invoked after an HTTP response is received and before
+     * its body stream is consumed.
+     */
+    onResponse?: (response: ProviderResponse, model: Model<Api>) => void | Promise<void>;
+    temperature?: number;
+    /**
+     * Arbitrary sampling parameters merged into the request body as-is, after the named request
+     * fields, so keys here override them. Lets custom OpenAI-compatible servers receive parameters
+     * Nyte does not model, e.g. `top_p`, `top_k`, `min_p`, `repetition_penalty`. Merged over
+     * `Model.samplingParams` per key. Only applied by OpenAI-compatible adapters; other APIs ignore it.
+     */
+    samplingParams?: Record<string, unknown>;
+    maxTokens?: number;
+    /**
+     * Preferred transport for providers that support multiple transports.
+     * Providers that do not support this option ignore it.
+     */
+    transport?: Transport;
+    /**
+     * Prompt cache retention preference. Providers map this to their supported values.
+     * Default: "long".
+     */
+    cacheRetention?: CacheRetention;
+    /**
+     * Optional session identifier for providers that support session-based caching.
+     * Providers can use this to enable prompt caching, request routing, or other
+     * session-aware features. Ignored by providers that don't support it.
+     */
+    sessionId?: string;
+    /**
+     * WebSocket connect timeout in milliseconds for providers that support
+     * WebSocket transports. This covers the connection/open handshake only;
+     * stream idleness after connection uses timeoutMs.
+     */
+    websocketConnectTimeoutMs?: number;
+    /**
+     * Optional metadata to include in API requests.
+     * Providers extract the fields they understand and ignore the rest.
+     * For example, Anthropic uses `user_id` for abuse tracking and rate limiting.
+     */
+    metadata?: Record<string, unknown>;
+}
+export type ProviderStreamOptions = StreamOptions & Record<string, unknown>;
+export interface DeferredFetchOptions extends ProviderRequestOptions<Model<Api>> {
+    /**
+     * Maximum provider long-poll duration in milliseconds.
+     * Defaults to 0, which performs one status check.
+     */
+    wait?: number;
+}
+/** Request options for best-effort deferred-response cancellation. */
+export type DeferredCancelOptions = ProviderRequestOptions<Model<Api>>;
+/**
+ * The uniform stream contract of an API implementation module: every module
+ * under `src/api/` exports `stream` and `streamSimple`; capable modules may also
+ * export deferred-response methods. Lazy wrappers (`lazyApi()`) and provider
+ * factories pass these around as values. This is the untyped dispatch shape;
+ * per-API option typing lives on the implementation modules themselves and on
+ * `Provider.stream()` via `ApiStreamOptions`.
+ */
+export interface ProviderStreams {
+    stream(model: Model<Api>, context: TranscriptContext, options?: StreamOptions): AssistantMessageEventStream;
+    streamSimple(model: Model<Api>, context: TranscriptContext, options?: SimpleStreamOptions): AssistantMessageEventStream;
+    fetchDeferred?(model: Model<Api>, handle: DeferredHandle, options?: DeferredFetchOptions): AssistantMessageEventStream;
+    cancelDeferred?(model: Model<Api>, handle: DeferredHandle, options?: DeferredCancelOptions): Promise<void>;
+}
+export interface SimpleStreamOptions extends StreamOptions {
+    /** Provider-neutral tool selection for simple requests. Default: "auto". */
+    toolChoice?: ToolChoice;
+    reasoning?: ThinkingLevel;
+    /** Ask a capable provider to return a durable handle and continue the request asynchronously. */
+    deferred?: boolean | {
+        window?: "15m" | "1h" | "24h";
+    };
+    /** Custom token budgets for thinking levels (token-based providers only) */
+    thinkingBudgets?: ThinkingBudgets;
+}
+/**
+ * Generic StreamFunction with typed options.
+ *
+ * Contract:
+ * - Receives a normalized transcript: the system prompt and tools live in the
+ *   leading system message, never on the context itself.
+ * - Must return an AssistantMessageEventStream.
+ * - Once invoked, request/model/runtime failures should be encoded in the
+ *   returned stream, not thrown.
+ * - Error termination must produce an AssistantMessage with stopReason
+ *   "error" or "aborted" and errorMessage, emitted via the stream protocol.
+ */
+export type StreamFunction<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> = (model: Model<TApi>, context: TranscriptContext, options?: TOptions) => AssistantMessageEventStream;

package/dist/src/types.js

@@ -0,0 +1 @@
+import"../chunks/account-limits-cache-gr671dr2.js";

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

@@ -0,0 +1,12 @@
+/**
+ * Resolve after `ms`, or reject with `abortError()` once `signal` aborts.
+ * The abort listener is detached when the timer fires.
+ */
+export declare function sleep(ms: number, signal: AbortSignal | undefined, abortError: () => Error): Promise<void>;
+/** Create an operation-local signal for public APIs whose signal is optional. */
+export declare function operationSignal(signal?: AbortSignal): AbortSignal;
+/**
+ * Stop waiting for an operation when its signal aborts while continuing to
+ * observe the abandoned promise so a later rejection is always handled.
+ */
+export declare function raceWithAbortSignal<T>(operation: Promise<T>, signal: AbortSignal): Promise<T>;

package/dist/src/utils/abort.js

@@ -0,0 +1,10 @@
+import {
+  sleep2,
+  operationSignal2,
+  raceWithAbortSignal2
+} from "../../chunks/account-limits-cache-j2bt392s.js";
+export {
+  operationSignal2 as operationSignal,
+  raceWithAbortSignal2 as raceWithAbortSignal,
+  sleep2 as sleep
+};

package/dist/src/utils/deferred-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Splits the current tool list into the definitions sent up front and those the transcript loaded later (marked by `addedToolNames` on a tool result), for providers with native deferred tool loading.
+ */
+import type { Context, Tool } from "@nyte-ai/schema/model";
+type ToolNameNormalizer = (name: string) => string;
+/** Split current tools into prefix and transcript-loaded definitions. */
+export declare function splitDeferredTools(context: Context, enabled: boolean, normalizeName?: ToolNameNormalizer): {
+    immediate: Tool<import("typebox").TSchema>[];
+    deferred: Map<string, Tool<import("typebox").TSchema>>;
+};
+export {};

package/dist/src/utils/deferred-tools.js

@@ -0,0 +1,6 @@
+import {
+  splitDeferredTools2
+} from "../../chunks/account-limits-cache-8s8bz4dr.js";
+export {
+  splitDeferredTools2 as splitDeferredTools
+};

package/dist/src/utils/diagnostics.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Redacted diagnostics attached to an AssistantMessage for failures and recoveries (retries, transport errors).
+ */
+import type { AssistantMessageDiagnostic, DiagnosticErrorInfo } from "@nyte-ai/schema/model";
+export type { AssistantMessageDiagnostic, DiagnosticErrorInfo };
+export declare function formatThrownValue(cause: unknown): string;
+export declare function extractDiagnosticError(cause: unknown): DiagnosticErrorInfo;
+export declare function createAssistantMessageDiagnostic(type: string, cause: unknown, details?: AssistantMessageDiagnostic["details"]): AssistantMessageDiagnostic;
+export declare function appendAssistantMessageDiagnostic<T extends {
+    diagnostics?: AssistantMessageDiagnostic[];
+}>(message: T, diagnostic: AssistantMessageDiagnostic): void;

package/dist/src/utils/diagnostics.js

@@ -0,0 +1,12 @@
+import {
+  formatThrownValue2,
+  extractDiagnosticError2,
+  createAssistantMessageDiagnostic2,
+  appendAssistantMessageDiagnostic2
+} from "../../chunks/account-limits-cache-9wqk28n5.js";
+export {
+  appendAssistantMessageDiagnostic2 as appendAssistantMessageDiagnostic,
+  createAssistantMessageDiagnostic2 as createAssistantMessageDiagnostic,
+  extractDiagnosticError2 as extractDiagnosticError,
+  formatThrownValue2 as formatThrownValue
+};

package/dist/src/utils/error-body.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared normalization for provider HTTP error objects. Gateways and proxies can return non-2xx bodies the SDK cannot fold into `error.message`; this probes the known SDK field shapes so adapters can surface status and body instead of an opaque message.
+ */
+export declare const MAX_PROVIDER_ERROR_BODY_CHARS = 4000;
+interface NormalizedProviderError {
+    /** HTTP status code, when one could be extracted from the SDK error object. */
+    status?: number;
+    /** Raw HTTP body reason, already trimmed and truncated to the cap. */
+    body?: string;
+    /** `error.message`, or `safeJsonStringify(error)` for a non-`Error` throw. */
+    message: string;
+    /** True when `message` already contains the body (no separate body to add). */
+    messageCarriesBody: boolean;
+}
+export declare function normalizeProviderError(cause: unknown): NormalizedProviderError;
+/**
+ * Compose a display string from a normalized error. When the message already
+ * carries the body (Anthropic / `@google/genai` happy path) or no body/status
+ * was extracted, the message is returned unchanged. Otherwise the status and
+ * body are surfaced, with an optional provider prefix.
+ *
+ * - no prefix: `"<status>: <body>"`
+ * - prefix:    `"<prefix> (<status>): <body>"`
+ */
+export declare function formatProviderError(norm: NormalizedProviderError, prefix?: string): string;
+export {};

package/dist/src/utils/error-body.js

@@ -0,0 +1,10 @@
+import {
+  MAX_PROVIDER_ERROR_BODY_CHARS2,
+  normalizeProviderError2,
+  formatProviderError2
+} from "../../chunks/account-limits-cache-zcbkmrvy.js";
+export {
+  MAX_PROVIDER_ERROR_BODY_CHARS2 as MAX_PROVIDER_ERROR_BODY_CHARS,
+  formatProviderError2 as formatProviderError,
+  normalizeProviderError2 as normalizeProviderError
+};

package/dist/src/utils/estimate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Context size estimation. Uses the most recent applicable assistant usage block as the anchor and estimates only the messages after it, so the number tracks the provider's count instead of a chars-per-token guess over the whole history.
+ */
+import type { Context, ImageContent, Message, TextContent, TranscriptContext, Usage } from "@nyte-ai/schema/model";
+export interface ContextUsageEstimate {
+    /** Estimated total context tokens. */
+    tokens: number;
+    /** Tokens reported by the most recent applicable assistant usage block. */
+    usageTokens: number;
+    /** Estimated tokens after the most recent applicable assistant usage block. */
+    trailingTokens: number;
+    /** Index of the applicable message that provided usage, or null when none exists. */
+    lastUsageIndex: number | null;
+}
+export declare function calculateContextTokens(usage: Usage): number;
+export declare function estimateTextTokens(text: string): number;
+export declare function estimateTextAndImageContentTokens(content: string | Array<TextContent | ImageContent>): number;
+export declare function estimateMessageTokens(message: Message): number;
+/** Estimates a context's tokens. A transcript carries its prompt and tools in system messages, so only a legacy context adds them separately. */
+export declare function estimateContextTokens(context: Context | TranscriptContext | readonly Message[]): ContextUsageEstimate;

package/dist/src/utils/estimate.js

@@ -0,0 +1,14 @@
+import {
+  calculateContextTokens2,
+  estimateTextTokens2,
+  estimateTextAndImageContentTokens2,
+  estimateMessageTokens2,
+  estimateContextTokens2
+} from "../../chunks/account-limits-cache-dejeygdt.js";
+export {
+  calculateContextTokens2 as calculateContextTokens,
+  estimateContextTokens2 as estimateContextTokens,
+  estimateMessageTokens2 as estimateMessageTokens,
+  estimateTextAndImageContentTokens2 as estimateTextAndImageContentTokens,
+  estimateTextTokens2 as estimateTextTokens
+};

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

@@ -0,0 +1,22 @@
+/**
+ * Async event queue with a promise for the terminal result. AssistantMessageEventStream is the stream every adapter returns: events are pushed as they arrive, and `result()` resolves with the final AssistantMessage once `done` or `error` is pushed.
+ */
+import type { AssistantMessage, AssistantMessageEvent } from "@nyte-ai/schema/model";
+export declare class EventStream<T, R = T> implements AsyncIterable<T> {
+    private queue;
+    private waiting;
+    private done;
+    private finalResult;
+    private isComplete;
+    private extractResult;
+    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
+    push(event: T): void;
+    end(result?: R): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    result(): Promise<R>;
+}
+export declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+    constructor();
+}
+/** Factory function for AssistantMessageEventStream (for use in extensions) */
+export declare function createAssistantMessageEventStream(): AssistantMessageEventStream;

package/dist/src/utils/event-stream.js

@@ -0,0 +1,11 @@
+import {
+  EventStream2,
+  AssistantMessageEventStream2,
+  createAssistantMessageEventStream2
+} from "../../chunks/account-limits-cache-a6cgeagz.js";
+import"../../chunks/account-limits-cache-nn9jebsj.js";
+export {
+  AssistantMessageEventStream2 as AssistantMessageEventStream,
+  EventStream2 as EventStream,
+  createAssistantMessageEventStream2 as createAssistantMessageEventStream
+};

package/dist/src/utils/failure.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The one place that reads provider error text. An assistant message that
+ * stopped with `error` or `aborted` is classified here, once, into a closed
+ * `FailureClass`; everything downstream switches on the class.
+ *
+ * Context-window examples by provider:
+ *
+ * - Anthropic: "prompt is too long: 213462 tokens > 200000 maximum"
+ * - Anthropic: "413 {\"error\":{\"type\":\"request_too_large\",\"message\":\"Request exceeds the maximum size\"}}"
+ * - OpenAI: "Your input exceeds the context window of this model"
+ * - OpenAI/LiteLLM: "Requested token count exceeds the model's maximum context length of 131072 tokens"
+ * - OpenAI-compatible: "Input length (265330) exceeds model's maximum context length (262144)."
+ * - Google: "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)"
+ * - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
+ * - Groq: "Please reduce the length of the messages or completion"
+ * - OpenRouter: "This endpoint's maximum context length is X tokens. However, you requested about Y tokens"
+ * - OpenRouter/Poolside: "Input length X exceeds the maximum allowed input length of Y tokens."
+ * - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+ * - llama.cpp: "the request exceeds the available context size, try increasing it"
+ * - LM Studio: "tokens to keep from the initial prompt is greater than the context length"
+ * - GitHub Copilot: "prompt token count of X exceeds the limit of Y"
+ * - MiniMax: "invalid params, context window exceeds limit"
+ * - Kimi For Coding: "Your request exceeded model token limit: X (requested: Y)"
+ * - DS4: "Prompt has X tokens, but the configured context size is Y tokens"
+ * - Cerebras: "400/413 status code (no body)", only from the cerebras provider
+ * - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+ * - z.ai: "Prompt too long", "Prompt exceeds max length" (CN endpoint), or silent
+ *   overflow detected via usage.input > contextWindow
+ * - Xiaomi MiMo: truncates input to fill contextWindow, then returns finish_reason "length"
+ *   with output=0; detected via stopReason "length" + zero output + input filling the window.
+ * - DashScope/Qwen: "Range of input length should be [1, X]"
+ * - Ollama: "prompt too long; exceeded max context length by X tokens"
+ */
+import type { Failure, FailureClass } from "@nyte-ai/schema";
+import type { Api, AssistantMessage, Model } from "@nyte-ai/schema/model";
+/**
+ * Whether provider error text reports spent quota or credit, which waiting does not lift. It
+ * outranks a 429 status: providers answer exhausted credit with 429, e.g. Anthropic's
+ * `extra_usage_out_of_credits`.
+ */
+export declare function reportsQuotaExhaustion(text: string): boolean;
+/**
+ * Classify an assistant message's failure. `model` enables detecting the
+ * overflow a provider accepts without an error. A message that did not fail
+ * and did not overflow answers `provider` with an empty message.
+ */
+export declare function classifyAssistantFailure(message: AssistantMessage, model?: Pick<Model<Api>, "contextWindow">): Failure;
+/** Whether another attempt can change the answer: load, limits that lift, and transport. */
+export declare function retryCanHelp(failureClass: FailureClass): boolean;

package/dist/src/utils/failure.js

@@ -0,0 +1,10 @@
+import {
+  reportsQuotaExhaustion2,
+  classifyAssistantFailure2,
+  retryCanHelp2
+} from "../../chunks/account-limits-cache-xds88kxd.js";
+export {
+  classifyAssistantFailure2 as classifyAssistantFailure,
+  reportsQuotaExhaustion2 as reportsQuotaExhaustion,
+  retryCanHelp2 as retryCanHelp
+};

package/dist/src/utils/fifo-queue.d.ts

@@ -0,0 +1,11 @@
+/**
+ * First-in, first-out storage with amortized constant-time dequeue: values enter one stack and leave the other, which is refilled in reverse only when empty.
+ */
+export declare class FifoQueue<T> {
+    private incoming;
+    private outgoing;
+    get length(): number;
+    enqueue(value: T): void;
+    dequeue(): T | undefined;
+    clear(): void;
+}

package/dist/src/utils/fifo-queue.js

@@ -0,0 +1,6 @@
+import {
+  FifoQueue2
+} from "../../chunks/account-limits-cache-nn9jebsj.js";
+export {
+  FifoQueue2 as FifoQueue
+};

package/dist/src/utils/hash.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fast deterministic string hash used to shorten long identifiers.
+ */
+/** Fast deterministic hash to shorten long strings */
+export declare function shortHash(str: string): string;

package/dist/src/utils/hash.js

@@ -0,0 +1,6 @@
+import {
+  shortHash2
+} from "../../chunks/account-limits-cache-0af5gqeg.js";
+export {
+  shortHash2 as shortHash
+};

package/dist/src/utils/headers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Header helpers: flatten a fetch Headers object, and merge caller-supplied ProviderHeaders case-insensitively, where a later source replaces an earlier header. A null survives the merge for SDKs that use it to suppress their defaults; the string record drops it instead. Presence checks ignore null and blank values.
+ */
+import type { ProviderHeaders } from "../types.ts";
+export declare function headersToRecord(headers: Headers): {
+    [k: string]: string;
+};
+export declare function mergeProviderHeaders(...headerSources: (ProviderHeaders | undefined)[]): ProviderHeaders;
+export declare function providerHeadersToRecord(...headerSources: (ProviderHeaders | undefined)[]): Record<string, string> | undefined;
+export declare function hasHeader(headers: ProviderHeaders | undefined, name: string): boolean;
+/** The OpenAI SDK requires a key; a caller-supplied authorization header stands in for one. */
+export declare function getClientApiKey(provider: string, apiKey: string | undefined, headers: ProviderHeaders | undefined): string;