indusagi 0.12.32 → 0.12.34

package/dist/types/llmgateway/conversion/mappers.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Conversation → provider wire-body mappers.
+ *
+ * Pure functions that translate the provider-neutral {@link Conversation} into
+ * each provider's native request shape. Output is always plain, JSON-able data
+ * typed as `Record<string, unknown>` (or arrays thereof) so it can be handed
+ * straight to `JSON.stringify` inside a connector. No network, no mutation.
+ *
+ * Wire shapes are re-derived from the providers' public HTTP documentation:
+ *   - OpenAI Chat Completions  (`/v1/chat/completions`)
+ *   - OpenAI Responses          (`/v1/responses`)
+ *   - Anthropic Messages        (`/v1/messages`)
+ *   - Google Generative AI      (`generateContent` `contents`)
+ */
+import type { Conversation, ModelCard, StreamOptions, ToolChoice, ToolDescriptor } from "../contract";
+/** A single JSON-able wire object. */
+type WireObject = Record<string, unknown>;
+/**
+ * Translate a conversation into the OpenAI Chat Completions `messages` array.
+ *
+ * Rules:
+ *   - A `system` preamble becomes a leading `{ role: "system" }` message.
+ *   - User turns merge text + images into either a bare string (text-only) or
+ *     the multimodal `content` parts array.
+ *   - Assistant turns carry text in `content` and tool calls in `tool_calls`.
+ *   - Tool turns expand into one `{ role: "tool", tool_call_id }` per result.
+ */
+export declare function toOpenAIChatMessages(c: Conversation): WireObject[];
+/** Translate tool descriptors into OpenAI's `tools` array. */
+export declare function toOpenAITools(tools: readonly ToolDescriptor[] | undefined): WireObject[] | undefined;
+/** Translate the neutral tool-choice into OpenAI's `tool_choice` value. */
+export declare function toOpenAIToolChoice(choice: ToolChoice | undefined): string | undefined;
+/**
+ * Build the full Anthropic `/v1/messages` request body for `model`.
+ *
+ * The system preamble is hoisted to the top-level `system` field. Thinking,
+ * temperature, top-p, tool choice, and the output ceiling are applied from
+ * {@link StreamOptions}.
+ */
+export declare function toAnthropicRequest(c: Conversation, model: ModelCard, opts: StreamOptions): WireObject;
+/**
+ * Translate a conversation into Google's `contents` array.
+ *
+ * Google uses `role: "user" | "model"`, carries tool calls as `functionCall`
+ * parts and tool results as `functionResponse` parts, and represents the
+ * system preamble separately (caller passes it via `systemInstruction`; it is
+ * not part of `contents`).
+ */
+export declare function toGoogleContents(c: Conversation): WireObject[];
+/** Optional `systemInstruction` object for Google requests. */
+export declare function toGoogleSystemInstruction(c: Conversation): WireObject | undefined;
+/** Translate tool descriptors into Google's `tools` declaration. */
+export declare function toGoogleTools(tools: readonly ToolDescriptor[] | undefined): WireObject[] | undefined;
+/**
+ * Translate a conversation into the OpenAI Responses `input` array.
+ *
+ * The Responses API uses a flat list of typed items: `message` items carry
+ * `input_text` / `output_text` / `input_image` content parts, while tool calls
+ * and their outputs are top-level `function_call` / `function_call_output`
+ * items rather than nested message fields.
+ */
+export declare function toResponsesInput(c: Conversation): WireObject[];
+/** Translate tool descriptors into the OpenAI Responses `tools` array. */
+export declare function toResponsesTools(tools: readonly ToolDescriptor[] | undefined): WireObject[] | undefined;
+export {};

package/dist/types/llmgateway/conversion/openai-compatible.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared OpenAI-compatible chat streamer.
+ *
+ * Every provider that speaks the OpenAI Chat Completions dialect (OpenAI
+ * itself, NVIDIA, Kimi, Azure, and a long tail of compatible gateways) reuses
+ * this single streamer. A connector supplies the endpoint URL, auth headers,
+ * and any body overrides; this module handles request assembly, SSE decoding,
+ * and translation of the OpenAI streaming chunk format into neutral
+ * {@link Emission}s.
+ *
+ * The OpenAI streaming chunk shape (re-derived from public docs) is:
+ *
+ *   data: {"choices":[{"delta":{"content":"..."},"finish_reason":null}], ...}
+ *   data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_x",
+ *           "function":{"name":"f","arguments":"{\"a"}}]}}]}
+ *   data: {"choices":[{"finish_reason":"stop"}],"usage":{...}}
+ *   data: [DONE]
+ */
+import type { Channel, ModelCard, Reply, StreamOptions, Conversation } from "../contract";
+/** Connector-supplied endpoint configuration. */
+export interface OpenAICompatibleConfig {
+    /** Absolute chat-completions URL to POST to. */
+    readonly url: string;
+    /** Request headers (auth, content-type is added if absent). */
+    readonly headers: Record<string, string>;
+    /** Extra top-level body fields merged after the standard ones. */
+    readonly bodyExtra?: Record<string, unknown>;
+}
+/**
+ * Open a streaming OpenAI-compatible chat invocation as a {@link Channel}.
+ *
+ * The channel POSTs on first iteration, decodes the SSE body, yields neutral
+ * emissions (text/thinking/tool-call/usage/stop), and finishes with a single
+ * terminal `done` carrying the folded {@link Reply}. Any failure surfaces as a
+ * terminal `error` emission rather than a thrown exception, so consumers can
+ * branch on it inline.
+ */
+export declare function streamOpenAICompatibleChat(cfg: OpenAICompatibleConfig, model: ModelCard, c: Conversation, opts: StreamOptions): Channel;
+/**
+ * Run an OpenAI-compatible chat invocation to completion (non-streaming view).
+ *
+ * Built directly on {@link streamOpenAICompatibleChat} + {@link collectReply},
+ * so streaming and one-shot share one code path. Throws the underlying
+ * {@link GatewayError} on failure.
+ */
+export declare function completeOpenAICompatibleChat(cfg: OpenAICompatibleConfig, model: ModelCard, c: Conversation, opts: StreamOptions): Promise<Reply>;

package/dist/types/llmgateway/conversion/reduce.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Emission folding.
+ *
+ * `foldReply` is a pure functional reducer (no class, no mutation of inputs)
+ * that collapses a sequence of streaming {@link Emission}s into the terminal
+ * {@link Reply}. It accumulates text and thinking prose, reassembles tool-call
+ * argument fragments back into structured input, tracks the latest usage and
+ * stop reason, and assembles the ordered block list.
+ *
+ * Ordering rule: thinking, then text, then tool calls — the canonical order an
+ * assistant turn takes. Tool calls preserve their first-seen order.
+ */
+import type { Emission, Reply } from "../contract";
+/**
+ * Fold a sequence of emissions into a {@link Reply} for `model`.
+ *
+ * Pure with respect to its inputs: it allocates its own scratch state, never
+ * mutates the supplied emissions, and returns a fresh immutable-shaped reply.
+ */
+export declare function foldReply(model: string, emissions: Iterable<Emission>): Reply;

package/dist/types/llmgateway/credentials/oauth.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Minimal OAuth 2.0 helper for authorization-code (with PKCE) and refresh flows.
+ *
+ * This is a transport-level skeleton: it builds the authorization URL, exchanges
+ * an authorization code for tokens, and refreshes an access token. It deals only
+ * in the wire shapes of RFC 6749 (the OAuth 2.0 framework) plus RFC 7636 (PKCE);
+ * the surrounding browser/device redirect choreography lives in the caller.
+ *
+ * Network access is via the global `fetch` (Node 20+); failures are normalized
+ * into the gateway's {@link GatewayError} so callers can branch on `.kind`.
+ */
+import type { ProviderId } from "../contract";
+import type { PkcePair } from "./pkce";
+/**
+ * Tokens returned by a token endpoint, normalized to the gateway's vocabulary.
+ * `expiresAt` is an absolute epoch-millisecond deadline (derived from the
+ * server's relative `expires_in`), which is far easier to act on than a TTL.
+ */
+export interface OAuthTokens {
+    readonly accessToken: string;
+    readonly refreshToken?: string;
+    readonly expiresAt?: number;
+}
+/**
+ * Static endpoint + client configuration for a provider's OAuth flow. Held in
+ * the {@link OAUTH_PROVIDERS} table and threaded through every helper.
+ */
+export interface OAuthConfig {
+    /** Which provider this configuration authorizes against. */
+    readonly provider: ProviderId;
+    /** Authorization endpoint the user-agent is sent to (RFC 6749 §3.1). */
+    readonly authorizeUrl: string;
+    /** Token endpoint for code exchange and refresh (RFC 6749 §3.2). */
+    readonly tokenUrl: string;
+    /** Public client identifier registered with the provider. */
+    readonly clientId: string;
+    /** Where the provider redirects back with the authorization code. */
+    readonly redirectUri: string;
+    /** Space-joined scopes requested for the grant. */
+    readonly scopes: readonly string[];
+}
+/** Inputs needed to assemble an authorization URL. */
+export interface AuthUrlInputs {
+    /** Opaque CSRF-binding value echoed back on the redirect (RFC 6749 §10.12). */
+    readonly state: string;
+    /** PKCE pair whose `challenge` is attached to the request (RFC 7636 §4.3). */
+    readonly pkce: PkcePair;
+}
+/**
+ * Provider-specific OAuth configuration table. Endpoints/client IDs are
+ * placeholders to be supplied per deployment; the shape is what matters for the
+ * flow. Only providers that actually expose an OAuth login appear here.
+ */
+export declare const OAUTH_PROVIDERS: Partial<Record<ProviderId, OAuthConfig>>;
+/** Look up a provider's OAuth config, or `undefined` if it has no OAuth flow. */
+export declare function oauthConfigFor(provider: ProviderId): OAuthConfig | undefined;
+/**
+ * Build the authorization-request URL (RFC 6749 §4.1.1) with PKCE parameters
+ * (RFC 7636 §4.3). The returned URL is what the user-agent should be sent to.
+ */
+export declare function buildAuthUrl(cfg: OAuthConfig, inputs: AuthUrlInputs): string;
+/**
+ * Exchange an authorization `code` for tokens (RFC 6749 §4.1.3), supplying the
+ * PKCE `verifier` so the server can re-derive and match the challenge
+ * (RFC 7636 §4.5).
+ */
+export declare function exchangeCode(cfg: OAuthConfig, code: string, verifier: string): Promise<OAuthTokens>;
+/**
+ * Trade a `refresh` token for a fresh access token (RFC 6749 §6). Providers may
+ * or may not rotate the refresh token; the normalized result reflects whatever
+ * the server returned.
+ */
+export declare function refreshToken(cfg: OAuthConfig, refresh: string): Promise<OAuthTokens>;

package/dist/types/llmgateway/credentials/pkce.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Proof Key for Code Exchange (PKCE) — RFC 7636.
+ *
+ * PKCE hardens the OAuth 2.0 authorization-code flow for public clients that
+ * cannot keep a secret. The client mints a high-entropy random `code_verifier`,
+ * derives a `code_challenge` from it, and sends only the challenge on the
+ * authorization request. At the token endpoint it presents the verifier; the
+ * server re-derives the challenge and checks it matches, proving the same client
+ * that started the flow is finishing it.
+ *
+ * This module implements the S256 transformation defined in RFC 7636 §4:
+ *
+ *   code_verifier  = high-entropy string, 43–128 chars from the unreserved set
+ *                    [A-Z] / [a-z] / [0-9] / "-" / "." / "_" / "~"   (§4.1)
+ *   code_challenge = BASE64URL-ENCODE( SHA256( ASCII(code_verifier) ) )   (§4.2)
+ *
+ * Everything runs on the Web Crypto API (`crypto.getRandomValues`,
+ * `crypto.subtle.digest`), available as a global in Node 20+.
+ */
+/** The S256 challenge method. RFC 7636 §4.3 — the only method we emit. */
+export type PkceMethod = "S256";
+/**
+ * A PKCE pair ready to drive an authorization-code flow.
+ *
+ * `verifier` is kept by the client and sent only at token exchange; `challenge`
+ * and `method` travel on the initial authorization request.
+ */
+export interface PkcePair {
+    readonly verifier: string;
+    readonly challenge: string;
+    readonly method: PkceMethod;
+}
+/**
+ * Generate a `code_verifier`: `length` characters drawn uniformly from the
+ * unreserved set using CSPRNG bytes. Rejection sampling keeps the distribution
+ * unbiased across the 66-character alphabet.
+ *
+ * @param length characters to emit; clamped into the RFC's [43, 128] range.
+ */
+export declare function createCodeVerifier(length?: number): string;
+/**
+ * Derive the S256 `code_challenge` for a verifier:
+ * `BASE64URL( SHA-256( ASCII(verifier) ) )` (RFC 7636 §4.2).
+ */
+export declare function deriveCodeChallenge(verifier: string): Promise<string>;
+/**
+ * Create a complete PKCE pair: a fresh verifier plus its S256 challenge.
+ *
+ * @param verifierLength optional verifier length; defaults to 64, clamped to
+ *                       the RFC's 43–128 range.
+ */
+export declare function createPkcePair(verifierLength?: number): Promise<PkcePair>;

package/dist/types/llmgateway/credentials/secrets.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Declarative credential resolution for every {@link ProviderId}.
+ *
+ * Each provider declares, in order of preference, the environment variables it
+ * reads to find an API key (or, for cloud-IAM providers, the variables that
+ * indicate ambient credentials are present). The {@link resolveSecret} function
+ * walks that table — honoring a caller override first — and yields the first
+ * non-empty value. This is the runtime backing for the gateway's
+ * {@link CredentialResolver} contract.
+ *
+ * Env var names are derived from each provider's public documentation:
+ *   - Anthropic ........ ANTHROPIC_API_KEY
+ *   - OpenAI ........... OPENAI_API_KEY
+ *   - Google (Gemini) .. GEMINI_API_KEY, then GOOGLE_API_KEY
+ *   - Google Vertex .... GOOGLE_APPLICATION_CREDENTIALS, GOOGLE_VERTEX_PROJECT…
+ *   - Amazon Bedrock ... AWS_BEARER_TOKEN_BEDROCK, then AWS_ACCESS_KEY_ID…
+ *   - Azure OpenAI ..... AZURE_OPENAI_API_KEY, then AZURE_API_KEY
+ *   - NVIDIA ........... NVIDIA_API_KEY
+ *   - Kimi (Moonshot) .. MOONSHOT_API_KEY, then KIMI_API_KEY
+ *   - Ollama / mock .... (no secret required)
+ */
+import type { CredentialResolver, ProviderId } from "../contract";
+/**
+ * How a provider's secret is sourced from the process environment.
+ *
+ * - `"api-key"`   — a single bearer key; the first present `envVars` entry wins.
+ * - `"cloud-iam"` — credentials are managed by a cloud SDK/role chain; the
+ *                   `envVars` here are *signals* that ambient creds exist, and
+ *                   any present one resolves to that variable's value.
+ * - `"none"`      — the provider needs no secret (local or mock transports).
+ */
+export type SecretScheme = "api-key" | "cloud-iam" | "none";
+/** One row of the credential table: how to locate a provider's secret. */
+export interface SecretDescriptor {
+    /** Which provider this descriptor governs. */
+    readonly provider: ProviderId;
+    /** The sourcing strategy for this provider's secret. */
+    readonly scheme: SecretScheme;
+    /**
+     * Environment variable names to probe, highest preference first. Empty for
+     * providers whose `scheme` is `"none"`.
+     */
+    readonly envVars: readonly string[];
+    /** Human-readable note about what the secret unlocks / where it comes from. */
+    readonly hint: string;
+}
+/**
+ * The canonical, ordered credential table. One descriptor per `ProviderId`.
+ * Probe order within `envVars` reflects the most specific / most recommended
+ * variable first.
+ */
+export declare const SECRET_TABLE: Readonly<Record<ProviderId, SecretDescriptor>>;
+/**
+ * Look up the descriptor for a provider. Always defined because the table is a
+ * total `Record<ProviderId, …>`.
+ */
+export declare function describeSecret(provider: ProviderId): SecretDescriptor;
+/**
+ * Resolve a provider's secret.
+ *
+ * Precedence:
+ *   1. an explicit `override` (e.g. a per-request `apiKey`), trimmed;
+ *   2. the first present, non-empty variable in the provider's `envVars`;
+ *   3. `undefined` — including the `"none"` scheme, which never carries a key.
+ *
+ * Implements {@link CredentialResolver.resolve}; async to keep the door open
+ * for future cloud token-exchange without a signature change.
+ */
+export declare function resolveSecret(provider: ProviderId, override?: string): Promise<string | undefined>;
+/**
+ * A ready-made {@link CredentialResolver} bound to {@link resolveSecret}. Hand
+ * this to connectors that need to source credentials from the environment.
+ */
+export declare const environmentCredentialResolver: CredentialResolver;

package/dist/types/llmgateway/gateway.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Top-level gateway dispatch.
+ *
+ * The single entry point callers use to talk to any model. Given a model id, it
+ * resolves the {@link ModelCard} from the catalog, selects the {@link Connector}
+ * that speaks the card's wire dialect, and delegates the streaming or one-shot
+ * invocation to it. Unknown model ids fail fast with an `unsupported`
+ * {@link GatewayError}.
+ */
+import type { Channel, Conversation, ModelCard, Reply, StreamOptions } from "./contract";
+/**
+ * Open a streaming invocation against a model.
+ *
+ * Resolves the card by id, routes to the matching connector, and returns its
+ * {@link Channel}. Throws an `unsupported` {@link GatewayError} when the id is
+ * not in the catalog.
+ */
+export declare function stream(modelId: string, conversation: Conversation, options?: StreamOptions): Channel;
+/**
+ * Open a streaming invocation against a pre-resolved {@link ModelCard}.
+ *
+ * Bypasses catalog lookup — useful when the caller already holds a card (e.g.
+ * from a fluent {@link models} query) and wants to route it directly.
+ */
+export declare function streamWithCard(card: ModelCard, conversation: Conversation, options?: StreamOptions): Channel;
+/**
+ * Run a one-shot invocation against a model and resolve the assembled
+ * {@link Reply}. Throws an `unsupported` {@link GatewayError} for unknown ids.
+ */
+export declare function complete(modelId: string, conversation: Conversation, options?: StreamOptions): Promise<Reply>;
+/**
+ * Run a one-shot invocation against a pre-resolved {@link ModelCard}.
+ */
+export declare function completeWithCard(card: ModelCard, conversation: Conversation, options?: StreamOptions): Promise<Reply>;

package/dist/types/llmgateway/gateway.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gateway smoke test.
+ *
+ * Exercises the full dispatch path through the deterministic `mock` connector:
+ *   - `stream("mock-1", …)` emits text deltas, a tool call, then a terminal
+ *     `done` carrying the folded reply;
+ *   - `complete("mock-1", …)` resolves a `tool_calls` reply with non-empty
+ *     blocks;
+ *   - `estimateCost` returns a finite number for a card + usage pair.
+ *
+ * No network, no credentials — the mock card/connector make the routing wholly
+ * deterministic.
+ */
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * LLM gateway — public surface.
+ *
+ * Re-exports the frozen type contract, the top-level dispatch
+ * (`stream`/`complete`), the catalog query + cost layer, and the connector
+ * registry. Downstream code should import everything it needs from here.
+ */
+export * from "./contract";
+export { stream, complete, streamWithCard, completeWithCard, } from "./gateway";
+export { MODEL_CARDS, CardSelection, models, getCard, estimateCost, } from "./catalog";
+export { CONNECTOR_REGISTRY, connectorForApi } from "./connectors";

package/dist/types/llmgateway/streaming/channel.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Channel construction and collapse helpers.
+ *
+ * A {@link Channel} is just an `AsyncIterable<Emission>`. These helpers let a
+ * connector wrap a generator function as a (re-iterable) channel, and let a
+ * caller fold a whole channel down to its terminal {@link Reply}.
+ */
+import type { Channel, Emission, Reply } from "../contract";
+/**
+ * Wrap a generator factory as a {@link Channel}.
+ *
+ * Unlike handing a single `AsyncGenerator` around (which is exhausted after one
+ * pass), this returns an object whose `[Symbol.asyncIterator]` calls the
+ * factory afresh each time, so the channel can be consumed more than once.
+ */
+export declare function channelOf(gen: () => AsyncGenerator<Emission>): Channel;
+/**
+ * Drain a channel and produce its final {@link Reply}.
+ *
+ * If the channel emits a terminal `done`, that reply is returned verbatim. If
+ * it emits a terminal `error`, the underlying {@link GatewayError} is thrown.
+ * Otherwise the buffered deltas are folded into a reply via {@link foldReply}.
+ */
+export declare function collectReply(channel: Channel): Promise<Reply>;

package/dist/types/llmgateway/streaming/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Transport layer barrel.
+ *
+ * Re-exports the channel construction helpers and the two wire-framing
+ * decoders (SSE for OpenAI/Anthropic/Google dialects, NDJSON for Ollama).
+ */
+export { channelOf, collectReply } from "./channel";
+export { sseEvents } from "./sse";
+export type { ServerEvent } from "./sse";
+export { ndjsonLines } from "./ndjson";

package/dist/types/llmgateway/streaming/ndjson.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Newline-delimited JSON framing.
+ *
+ * Ollama streams one JSON object per line (`\n`-separated), not SSE. This
+ * decodes such a body into a stream of parsed values: split on LF, trim a
+ * trailing CR (tolerating CRLF), skip blank lines, and `JSON.parse` each line.
+ */
+/**
+ * Decode an NDJSON response body into a stream of parsed JSON values.
+ *
+ * Each yielded value is typed `unknown`; callers narrow it against the
+ * provider's documented per-line shape.
+ *
+ * @param body   The response's byte stream.
+ * @param signal Optional abort signal; aborting stops iteration promptly.
+ */
+export declare function ndjsonLines(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<unknown>;

package/dist/types/llmgateway/streaming/sse.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Server-Sent Events framing.
+ *
+ * A clean re-derivation of the WHATWG HTML "event stream" interpretation rules
+ * (https://html.spec.whatwg.org/multipage/server-sent-events.html), restricted
+ * to the subset that LLM providers actually transmit:
+ *
+ *   - The byte stream is decoded as UTF-8.
+ *   - It is split into lines on LF, CR, or CRLF.
+ *   - Lines are grouped into events; a blank line dispatches the buffered event.
+ *   - Each non-blank line is `field`, `field: value`, or `field:value`; a single
+ *     leading space after the colon is stripped from the value.
+ *   - `event` sets the event type (default "message"); `data` lines accumulate,
+ *     joined by `\n`; a line that begins with `:` is a comment and is ignored.
+ *   - Fields we do not consume (`id`, `retry`) are parsed and discarded.
+ *
+ * Only events that carried at least one `data` field are yielded.
+ */
+/** One dispatched server-sent event: its type and its accumulated data payload. */
+export interface ServerEvent {
+    readonly event: string;
+    readonly data: string;
+}
+/**
+ * Decode an SSE response body into a stream of {@link ServerEvent}s.
+ *
+ * @param body   The response's byte stream.
+ * @param signal Optional abort signal; when aborted, iteration stops promptly
+ *               with an `aborted` {@link GatewayError}.
+ */
+export declare function sseEvents(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<ServerEvent>;

package/dist/types/react-host/index.d.ts

@@ -0,0 +1,9 @@
+import type * as ReactTypes from "react";
+declare const React: typeof ReactTypes;
+export type { Dispatch, PropsWithChildren, ReactNode, SetStateAction } from "react";
+export declare const Fragment: typeof ReactTypes.Fragment;
+export declare const createElement: typeof ReactTypes.createElement;
+export declare const useEffect: typeof ReactTypes.useEffect;
+export declare const useMemo: typeof ReactTypes.useMemo;
+export declare const useState: typeof ReactTypes.useState;
+export default React;

package/dist/types/react-host/ink.d.ts

@@ -0,0 +1,5 @@
+import type * as InkTypes from "ink";
+export declare const Box: typeof InkTypes.Box;
+export declare const Text: typeof InkTypes.Text;
+export declare const render: typeof InkTypes.render;
+export declare const useInput: typeof InkTypes.useInput;

package/dist/types/react-host/jsx-runtime.d.ts

@@ -0,0 +1,4 @@
+import type * as ReactJsxRuntimeTypes from "react/jsx-runtime";
+export declare const Fragment: typeof ReactJsxRuntimeTypes.Fragment;
+export declare const jsx: typeof ReactJsxRuntimeTypes.jsx;
+export declare const jsxs: typeof ReactJsxRuntimeTypes.jsxs;

package/dist/types/react-host/loader.d.ts

@@ -0,0 +1,3 @@
+export declare function loadHostReact(): Promise<typeof import("react")>;
+export declare function loadHostJsxRuntime(): Promise<typeof import("react/jsx-runtime")>;
+export declare function loadHostInk(): Promise<typeof import("ink")>;

package/dist/types/react-ink/components/ChangelogBlock.d.ts

@@ -0,0 +1,8 @@
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface ChangelogBlockProps {
+    title: string;
+    markdown: string;
+    theme: InkThemeAdapter;
+}
+export declare function ChangelogBlock({ markdown, theme, title }: ChangelogBlockProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/DisplayBlockView.d.ts

@@ -0,0 +1,8 @@
+import type { UiDisplayBlock } from "../types.js";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface DisplayBlockViewProps {
+    block: UiDisplayBlock;
+    theme: InkThemeAdapter;
+}
+export declare function DisplayBlockView({ block, theme }: DisplayBlockViewProps): JSX.Element | null;
+export {};

package/dist/types/react-ink/components/Footer.d.ts

@@ -0,0 +1,11 @@
+import type { SessionSnapshot } from "../types.js";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface FooterProps {
+    theme: InkThemeAdapter;
+    branch: string | null;
+    snapshot: SessionSnapshot;
+    availableProviderCount: number;
+    extensionStatuses?: ReadonlyMap<string, string>;
+}
+export declare function Footer({ availableProviderCount, branch, extensionStatuses, snapshot, theme }: FooterProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/MessageList.d.ts

@@ -0,0 +1,14 @@
+import type { AgentMessage } from "indusagi/agent";
+import type { UiDisplayBlock } from "../types.js";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface MessageListProps {
+    messages: AgentMessage[];
+    theme: InkThemeAdapter;
+    showThinking: boolean;
+    showImages: boolean;
+    expandToolOutputs?: boolean;
+    maxItems: number;
+    displayBlocks?: UiDisplayBlock[];
+}
+export declare function MessageList({ displayBlocks, expandToolOutputs, maxItems, messages, showImages, showThinking, theme, }: MessageListProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/MessageRow.d.ts

@@ -0,0 +1,13 @@
+import type { AgentMessage } from "indusagi/agent";
+import type { ToolResultMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface MessageRowProps {
+    message: AgentMessage;
+    theme: InkThemeAdapter;
+    showThinking: boolean;
+    showImages: boolean;
+    expandToolOutputs?: boolean;
+    toolResults?: ToolResultMessage[];
+}
+export declare function MessageRow({ message, expandToolOutputs, showImages, showThinking, theme, toolResults, }: MessageRowProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/StatusLine.d.ts

@@ -0,0 +1,9 @@
+import type { SessionSnapshot, StatusMessage } from "../types.js";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface StatusLineProps {
+    theme: InkThemeAdapter;
+    status?: StatusMessage;
+    snapshot: SessionSnapshot;
+}
+export declare function StatusLine({ snapshot, status, theme }: StatusLineProps): JSX.Element | null;
+export {};

package/dist/types/react-ink/components/TaskPanel.d.ts

@@ -0,0 +1,11 @@
+import type { PendingMessageItem, SessionSnapshot, ToolExecutionState } from "../types.js";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface TaskPanelProps {
+    theme: InkThemeAdapter;
+    snapshot: SessionSnapshot;
+    toolExecutions: Record<string, ToolExecutionState>;
+    expandToolOutputs?: boolean;
+    pendingMessages?: PendingMessageItem[];
+}
+export declare function TaskPanel({ expandToolOutputs, pendingMessages, snapshot, theme, toolExecutions }: TaskPanelProps): JSX.Element | null;
+export {};

package/dist/types/react-ink/components/ToolEventBlock.d.ts

@@ -0,0 +1,24 @@
+import type { InkThemeAdapter } from "../theme-adapter.js";
+type ToolEventStatus = "running" | "success" | "error";
+interface ToolEventBlockProps {
+    title: string;
+    summary?: string;
+    detail?: string;
+    emptyText?: string;
+    status: ToolEventStatus;
+    theme: InkThemeAdapter;
+    indent?: number;
+    marginBottom?: number;
+    showTitle?: boolean;
+    showSummaryInline?: boolean;
+    maxContentLines?: number;
+    /**
+     * When true the detail body already carries syntax-highlight ANSI; render it
+     * verbatim instead of stripping the escapes. stripAnsi is still used for the
+     * visible-width / line-count measurements so wrapping and clamping stay
+     * correct against the escape-free text.
+     */
+    preformatted?: boolean;
+}
+export declare function ToolEventBlock({ detail, emptyText, indent, marginBottom, maxContentLines, preformatted, showSummaryInline, showTitle, status, summary, theme: _theme, title, }: ToolEventBlockProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/DialogFrame.d.ts

@@ -0,0 +1,8 @@
+import type { PropsWithChildren, ReactNode } from "indusagi/react-host";
+interface DialogFrameProps extends PropsWithChildren {
+    title: string;
+    subtitle?: string;
+    footer?: ReactNode;
+}
+export declare function DialogFrame({ children, footer, subtitle, title }: DialogFrameProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/LoginDialog.d.ts

@@ -0,0 +1,14 @@
+import type { LoginProviderOption, SavedAccountOption } from "../../types.js";
+type LoginDialogProps = {
+    mode: "login";
+    providers: LoginProviderOption[];
+    onClose: () => void;
+    onSelect: (provider: LoginProviderOption) => void | Promise<void>;
+} | {
+    mode: "logout";
+    accounts: SavedAccountOption[];
+    onClose: () => void;
+    onSelect: (account: SavedAccountOption) => void | Promise<void>;
+};
+export declare function LoginDialog(props: LoginDialogProps): JSX.Element;
+export {};