@leuduan/lagent 0.0.0-stage → 44.0.0

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,178 @@
+import type { ContentPart } from '../llm/content.js';
+import type { ConversationMessage, JsonObject, LLMStreamChunk, ModelResponse, ResponseFinish, ThinkingEffort, ToolSpec } from '../llm/primitives.js';
+import type { FailureClassification } from '../llm/failure.js';
+import type { ToolChoice } from '../llm/request.js';
+import type { DeepReadonly } from '../util/json.js';
+/** One Messages content block, as JSON. */
+export type AnthropicBlock = Record<string, unknown>;
+/** One Messages turn. Consecutive messages of one role are one turn. */
+export type AnthropicMessage = {
+    role: 'user' | 'assistant';
+    content: AnthropicBlock[];
+};
+/**
+ * A call id as Messages accepts it: an id already in its alphabet as it is, any other (another
+ * provider's, such as Responses' `call_…|fc_…`) as a digest of itself. Deterministic, so a call and
+ * its result agree; never reversed, since only ids Messages wrote come back.
+ */
+export declare const anthropicToolUseId: (id: string) => string;
+/**
+ * The state an assistant message keeps for replay: its message id, and its thinking blocks with
+ * their signatures, which the API verifies and which only the model that wrote them can read.
+ */
+export type AnthropicReplayState = {
+    id: string;
+    thinking: AnthropicBlock[];
+};
+/**
+ * A request's conversation as Messages turns.
+ *
+ * - A `tool` message is a `tool_result` block in the next user turn, and results lead their turn,
+ *   as the API requires.
+ * - A `developer` or `system` message is user text inside `<system-reminder>`: Messages has no role
+ *   for a notice in the conversation.
+ * - An assistant message replays its thinking first, from state `replayTag` wrote; another model's
+ *   is dropped. A malformed tool call goes back with empty input, since Messages takes an object.
+ * - Empty text is dropped (the API refuses it), and a message left with nothing is dropped too.
+ */
+export declare function toAnthropicMessages(messages: readonly DeepReadonly<ConversationMessage>[], options: {
+    readonly provider: string;
+    readonly replayTag: string;
+}): AnthropicMessage[];
+/**
+ * Content parts as Messages blocks: images by URL or base64, files as documents (a PDF by URL or
+ * base64, plain text inline). A file the provider holds by id is refused: that is another API's
+ * upload, which Messages cannot name.
+ */
+export declare function contentBlocks(content: readonly DeepReadonly<ContentPart>[], provider: string): AnthropicBlock[];
+/** Tool specs as Messages tools; the schema goes as it stands. */
+export declare const toAnthropicTools: (tools: readonly DeepReadonly<ToolSpec>[]) => AnthropicBlock[];
+/** A request's tool choice, with parallel calls off when the request says so. */
+export declare function toAnthropicToolChoice(choice: DeepReadonly<ToolChoice>, parallel: boolean): AnthropicBlock;
+/**
+ * The thinking fields for an effort: none sent for none named, so the model's own default stands;
+ * `none` disables thinking; any other is adaptive thinking at that effort, with its text summarized,
+ * since some models omit thinking text unless asked.
+ */
+export declare function anthropicThinking(effort: ThinkingEffort | undefined): JsonObject;
+/** One raw Messages stream event, as the API streams it. Only the fields read here are typed. */
+export type AnthropicStreamEvent = {
+    type: 'message_start';
+    message: {
+        id: string;
+        model: string;
+        usage?: RawUsage;
+    };
+} | {
+    type: 'content_block_start';
+    index: number;
+    content_block: AnthropicBlock;
+} | {
+    type: 'content_block_delta';
+    index: number;
+    delta: AnthropicBlock;
+} | {
+    type: 'content_block_stop';
+    index: number;
+} | {
+    type: 'message_delta';
+    delta: {
+        stop_reason?: string | null;
+        stop_sequence?: string | null;
+    };
+    usage?: RawUsage;
+} | {
+    type: 'message_stop';
+} | {
+    type: 'ping';
+} | {
+    type: 'error';
+    error: {
+        type?: string;
+        message?: string;
+    };
+};
+type RawUsage = {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+    output_tokens_details?: {
+        thinking_tokens?: number | null;
+    } | null;
+};
+/** A failure the API reported, from a rejected request (with its status) or an `error` stream event. */
+export declare class AnthropicAPIError extends Error {
+    readonly errorType: string | undefined;
+    readonly status?: number;
+    readonly headers?: Headers;
+    constructor(
+    /** The API's error type, such as `overloaded_error`. */
+    errorType: string | undefined, message: string, 
+    /** The HTTP status of a rejected request; absent for a failure inside the stream. */
+    status?: number, headers?: Headers);
+}
+/**
+ * Whether a failure says the request exceeded the model's context window. The API names no code of
+ * its own for it, only `invalid_request_error`, so its wording decides, as `docs/guides/providers.md` allows
+ * where a provider has no code: "prompt is too long", which a gateway may wrap in its own prose.
+ */
+export declare const isAnthropicOverflow: (error: AnthropicAPIError) => boolean;
+/**
+ * The kind of a failure from a Messages client, by structured evidence only: the API's error type
+ * where it names a kind (a `billing_error` is `quota` whatever status carries it), else the HTTP
+ * status as every protocol reads one (`statusKind`, 529 being Anthropic's overloaded). A failure
+ * inside the stream has no status, so its type is all there is; else socket codes.
+ * `retryAfterMs` comes from the `retry-after-ms` or `retry-after` header.
+ */
+export declare function classifyAnthropicFailure(error: unknown, now?: number): FailureClassification;
+/** `end_turn`, `tool_use` and `stop_sequence` finish a message; the output cap and window are `length`. */
+export declare const anthropicFinish: (stopReason: string) => ResponseFinish;
+export interface MessagesAssemblyOptions {
+    /** The tag the message's state is written under, which replays it. */
+    readonly replayTag: string;
+    /** The name a tool call reaches lagent under, from the name the model used. */
+    readonly toolName?: (name: string) => string;
+}
+/**
+ * One streamed Messages message, folded event by event. It owns the rule that a message is complete
+ * only once its stop reason arrived and `message_stop` followed, and hands back what arrived for a
+ * cut-off one: text and reasoning, never a tool call or state.
+ */
+export declare class MessagesAssembly {
+    private id;
+    private model;
+    private readonly blocks;
+    private stopReason;
+    private stopSequence;
+    private stopped;
+    private usage;
+    private readonly options;
+    constructor(options: MessagesAssemblyOptions);
+    /** Folds one event and returns the chunk it adds, if any. An `error` event throws. */
+    apply(event: AnthropicStreamEvent): LLMStreamChunk | null;
+    /** Whether the message is complete: its stop reason arrived, and `message_stop` after it. */
+    get complete(): boolean;
+    /** The message's stop reason, once one arrived. */
+    get stop(): string | null;
+    private applyDelta;
+    private addUsage;
+    /**
+     * Usage as lagent counts it: Anthropic's `input_tokens` excludes the cached ones, so input is the
+     * sum of uncached, cache-read and cache-written tokens, with the cached ones also kept apart.
+     */
+    private normalizedUsage;
+    private ordered;
+    private text;
+    private reasoning;
+    /** What the message says about itself: observed, never sent back. */
+    metadata(): JsonObject;
+    /** The settled message, once complete; `undefined` before. */
+    settle(): ModelResponse | undefined;
+    /** What arrived so far: text and reasoning, never a tool call nobody finished asking for. */
+    partial(): {
+        message: ConversationMessage;
+        providerMetadata: JsonObject;
+    };
+}
+export {};

package/dist/providers/anthropicMessages.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import type { LLMClient, StreamingLLMResponse } from '../llm/client.js';
+import type { ModelRequest } from '../llm/request.js';
+import { type AnthropicStreamEvent } from './anthropic.js';
+import { type CallHeaders } from './stream.js';
+declare const AnthropicMessagesConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseURL: z.ZodString;
+    streamIdleTimeoutMs: z.ZodNullable<z.ZodNumber>;
+    authorization: z.ZodDefault<z.ZodEnum<{
+        "x-api-key": "x-api-key";
+        bearer: "bearer";
+    }>>;
+    defaultHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    thinkingEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        none: "none";
+        medium: "medium";
+        max: "max";
+    }>>;
+    maxOutputTokens: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+type AnthropicMessagesConfig = z.input<typeof AnthropicMessagesConfigSchema>;
+type ParsedConfig = z.output<typeof AnthropicMessagesConfigSchema>;
+type RequestPayload = Record<string, unknown>;
+/**
+ * The Anthropic Messages adapter for a provider whose models answer on Messages (Go or Copilot),
+ * which names itself as `name`. It speaks over `fetch` with no SDK: the request goes as
+ * JSON and the server-sent events are read as they arrive, so nothing reads the process environment.
+ * `headers` adds headers to each call, over the client's own; it is the client's owner's, and
+ * nothing subclasses the client to say it.
+ *
+ * The prompt goes as `system` blocks, notices as user text, and thinking replays from
+ * `provider_state` to the model that wrote it. Provider-executed tools and non-text response
+ * formats are refused.
+ */
+export declare class AnthropicMessagesLLMClient implements LLMClient {
+    readonly providerName: string;
+    protected readonly config: ParsedConfig;
+    private readonly fetchImpl;
+    private readonly callHeaders;
+    constructor(config: AnthropicMessagesConfig & {
+        name: string;
+        headers?: CallHeaders;
+        fetch?: typeof globalThis.fetch;
+    });
+    /** The tag replayable state is written and read under: one model's signed thinking is no other's. */
+    private replayTag;
+    /** The output cap of a request: its own, else the one configured for its model. */
+    private maxOutputTokens;
+    /** The headers of one call: the client's own, then the owner's for this call and its mapped request. */
+    private headers;
+    buildRequest(call: ModelRequest): RequestPayload;
+    chat(call: ModelRequest): Promise<StreamingLLMResponse>;
+    private open;
+    /** `error` as the overflow it is, when its fields say so, else unchanged. */
+    classified(error: unknown): unknown;
+}
+/**
+ * The events of a server-sent event stream, each `data` payload parsed as JSON. Lines end in CR, LF
+ * or CRLF, as the format allows; a CR at the end of a chunk waits for the next, which may bring its
+ * LF. The payload's own `type` names the event, so `event:` lines, ids and comments are not read.
+ */
+export declare function serverSentEvents(body: AsyncIterable<Uint8Array>): AsyncGenerator<AnthropicStreamEvent>;
+export {};

package/dist/providers/codex.d.ts

@@ -0,0 +1,71 @@
+import OpenAI from 'openai';
+import { z } from 'zod';
+import type { ModelOption } from '../llm/client.js';
+import type { LLMProvider } from '../llm/provider.js';
+import { type CodexCredentialManager } from './codexAuth.js';
+import { OpenAIResponsesLLMClient } from './openaiResponses.js';
+export declare const CODEX_PROVIDER_NAME = "codex";
+export declare const CODEX_DEFAULT_MODEL = "gpt-5.6-luna";
+/**
+ * The models agents are told about: every model the Codex backend lists for clients, with the
+ * efforts lagent can send (the backend also takes `xhigh` and, on some, `ultra`, which
+ * `ThinkingEffort` has no value for), from `codex app-server`'s `model/list` (checked 2026-10-11).
+ * The models it hides can be named, just not told.
+ */
+export declare const CODEX_MODELS: readonly ModelOption[];
+/**
+ * The usable context window of every model the Codex CLI's model cache lists, in tokens: its
+ * `context_window` with its `effective_context_window_percent` of 95 applied. `gpt-6.1-sol` lists
+ * 500,000, so 475,000; every other model lists 272,000, so 258,400
+ * (`~/.codex/models_cache.json`, checked 2026-10-23). The raw figure is itself conservative: the
+ * backend accepted 285,889 input tokens on `gpt-5.6-luna`, listed at 272,000 (measured 2026-10-03).
+ * A model not listed here has no window.
+ */
+export declare const CODEX_CONTEXT_WINDOWS: Readonly<Record<string, number>>;
+export declare const CodexConfigSchema: z.ZodObject<{
+    authPath: z.ZodOptional<z.ZodString>;
+    refreshTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    streamIdleTimeoutMs: z.ZodNullable<z.ZodNumber>;
+    baseURL: z.ZodDefault<z.ZodString>;
+    defaultModel: z.ZodDefault<z.ZodString>;
+    thinkingEffort: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        none: "none";
+        medium: "medium";
+        max: "max";
+    }>>;
+    extraBody: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type CodexConfig = z.input<typeof CodexConfigSchema>;
+/**
+ * The Responses client over the Codex CLI's ChatGPT login. Requests go to the ChatGPT backend through
+ * {@link codexOpenAI}, with a token read from the login file per call, so there is no API key and a
+ * token rotated by another process (or by this client) takes effect on the next request.
+ */
+export declare class CodexLLMClient extends OpenAIResponsesLLMClient {
+    readonly credentials: CodexCredentialManager;
+    constructor(config: CodexConfig & {
+        client?: OpenAI;
+        credentials?: CodexCredentialManager;
+        /** The transport under the authorization, for tests. */
+        fetch?: typeof globalThis.fetch;
+    });
+    /** The request goes out over the login, read first (see {@link overLogin}). */
+    protected openStream(request: Record<string, unknown>, headers: Record<string, string>, signal: AbortSignal): Promise<AsyncIterable<OpenAI.Responses.ResponseStreamEvent>>;
+}
+/**
+ * Compresses the JSON body of each request under the authorization: the model calls replay the whole
+ * conversation, so their bodies are the large ones. The SDK sends JSON as a string; any other body
+ * goes as it is.
+ */
+export declare const compressingFetch: (baseFetch?: typeof globalThis.fetch) => typeof globalThis.fetch;
+/**
+ * The Codex provider: the same Responses API, reached with the ChatGPT login that `codex login`
+ * leaves in the file `authPath` names instead of an API key, reread per request and refreshed in
+ * place when it nears expiry.
+ */
+export declare const codexProvider: (config: CodexConfig & {
+    readonly authPath: string;
+    readonly refreshTimeoutMs: number;
+}) => LLMProvider;

package/dist/providers/codexAuth.d.ts

@@ -0,0 +1,116 @@
+import OpenAI from 'openai';
+import { TransportCredentialError } from './shared.js';
+/** The Codex backend every client of a Codex login calls: the model adapter and web search. */
+export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+export declare const CODEX_REFRESH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+export declare const CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+/** Everything a request needs; never logged, and never interpolated into an error message. */
+export type CodexCredentials = {
+    accessToken: string;
+    refreshToken: string;
+    accountId: string;
+};
+export declare class CodexCredentialError extends TransportCredentialError {
+    constructor(message: string);
+}
+export type CodexCredentialManagerOptions = {
+    /** The login file, which the host names; see {@link codexAuthPath} for where `codex login` writes it. */
+    authPath: string;
+    /**
+     * How long one refresh request may take, body included, before it fails and the next caller may
+     * try. The manager's own deadline, so one stalled refresh cannot hold every later read of the
+     * login: no caller's signal sets it, and none can cut a refresh short for the others.
+     */
+    refreshTimeoutMs: number;
+    refreshUrl?: string;
+    oauthClientId?: string;
+    /** Test seam for the refresh call. */
+    fetch?: typeof globalThis.fetch;
+};
+/**
+ * Where `codex login` writes its login, for a host to resolve from its own environment and home
+ * directory: `$CODEX_HOME/auth.json`, else `<home>/.codex/auth.json`. No library code calls it.
+ */
+export declare const codexAuthPath: (environment: Readonly<Record<string, string | undefined>>, home: string) => string;
+/**
+ * Reads the ChatGPT login `codex login` leaves on disk, refreshes the access token shortly before
+ * it expires, and writes the rotated tokens back to the same file. Nothing is cached: every call
+ * re-reads the file, so a token another process rotated is picked up immediately.
+ */
+export declare class CodexCredentialManager {
+    readonly authPath: string;
+    readonly refreshTimeoutMs: number;
+    private readonly refreshUrl;
+    private readonly oauthClientId;
+    private readonly fetchImpl;
+    /** Serializes read-refresh-write, the way the Python manager holds an asyncio lock. */
+    private queue;
+    constructor(options: CodexCredentialManagerOptions);
+    /** The current credentials, refreshed first when the access token is about to expire. */
+    credentials(): Promise<CodexCredentials>;
+    /**
+     * Called after a request was rejected as unauthorized: returns the token another process already
+     * rotated onto disk, or forces a refresh when the failed one is still the current one.
+     */
+    recoverUnauthorized(failed: CodexCredentials): Promise<CodexCredentials>;
+    private serialize;
+    private read;
+    private needsRefresh;
+    private refresh;
+    private requestRefresh;
+    /** Writes through a sibling temp file so a crash can never leave a truncated login behind. */
+    private write;
+}
+/**
+ * The one credential manager for an auth file in this process. A manager serializes only its own
+ * read-refresh-write, so two managers of one file could both spend the same refresh token and make
+ * one refresh fail; every client of one login shares this manager instead. The first caller's
+ * `refreshTimeoutMs` configures it, and a later one that asks for another is refused rather than
+ * silently given the first's.
+ */
+export declare function codexCredentials(authPath: string, options: {
+    readonly refreshTimeoutMs: number;
+}): CodexCredentialManager;
+/**
+ * Authorizes every request with the current Codex login, and gives a rejected one a second chance
+ * with recovered credentials: credential recovery, not a retry policy, so its two HTTP requests are
+ * one attempt. The SDK sends JSON bodies as strings, so the second request can resend it.
+ */
+export declare const authorizingFetch: (credentials: Pick<CodexCredentialManager, "credentials" | "recoverUnauthorized">, baseFetch?: typeof globalThis.fetch) => typeof globalThis.fetch;
+/**
+ * Runs one request over a Codex login, the one place a Codex request waits for its credentials, for
+ * the model adapter and web search alike. The login is read first, outside the SDK: the idle deadline
+ * is held (the login's own refresh deadline bounds the wait instead), the SDK's request timeout has
+ * not started, and what the read throws, a {@link CodexCredentialError} or a failure to persist a
+ * refreshed login, reaches the caller as it is rather than as a failed connection. The credentials
+ * read are the ones `request`'s own authorization uses (see {@link authorizingFetch}), whichever SDK
+ * client it is given. `signal` bounds only this caller's wait, never the refresh.
+ */
+export declare function overLogin<T>(credentials: Pick<CodexCredentialManager, 'credentials'>, signal: AbortSignal | undefined, request: () => Promise<T>): Promise<T>;
+/**
+ * The one SDK client over a Codex login, for the provider and anything else that calls the Codex
+ * backend: every request authorized from the login, a rejected one retried once with recovered
+ * credentials.
+ */
+export declare function codexOpenAI(options: {
+    readonly credentials: CodexCredentialManager;
+    readonly baseURL: string;
+    /** The transport under the authorization; the global `fetch` without it. */
+    readonly fetch?: typeof globalThis.fetch;
+}): OpenAI;
+/**
+ * A Codex login's backend for JSON requests besides the model adapter's, web search's: every request
+ * authorized from the login's one manager in this process through {@link codexOpenAI}, and a login
+ * problem thrown as its {@link CodexCredentialError}: the login is awaited first ({@link overLogin}), and
+ * one raised in the transport is handed back by {@link classifyProviderError}. `post` answers
+ * with the status and the parsed body; a non-2xx status throws the SDK's error, and nothing retries.
+ */
+export declare function codexBackend(login: {
+    readonly authPath: string;
+    readonly refreshTimeoutMs: number;
+}): {
+    post(path: string, body: Record<string, unknown>, signal: AbortSignal): Promise<{
+        status: number;
+        data: unknown;
+    }>;
+};

package/dist/providers/deepseek.d.ts

@@ -0,0 +1,59 @@
+import type OpenAI from 'openai';
+import { z } from 'zod';
+import type { ModelOption } from '../llm/client.js';
+import type { ModelRequest } from '../llm/request.js';
+import type { LLMProvider } from '../llm/provider.js';
+import { OpenAIResponsesLLMClient } from './openaiResponses.js';
+import { type ProviderErrorFields, type WithCredential } from './shared.js';
+/** The stateless Responses endpoint DeepSeek documents as OpenAI-compatible. */
+export declare const DEEPSEEK_RESPONSES_BASE_URL = "https://api.deepseek.com";
+export declare const DEEPSEEK_RESPONSES_PROVIDER_NAME = "deepseek-responses";
+/** DeepSeek's current API name for the DeepSeek-V4.1-Flash model. */
+export declare const DEEPSEEK_RESPONSES_DEFAULT_MODEL = "deepseek-flash";
+/** The models agents are told about, from the Codex CLI's DeepSeek model list (checked 2026-09-26). */
+export declare const DEEPSEEK_RESPONSES_MODELS: readonly ModelOption[];
+/**
+ * The usable context window of each DeepSeek model, in tokens, from the Codex CLI's DeepSeek model
+ * list: a `context_window` of 1,048,576 with its `effective_context_window_percent` of 95 applied,
+ * 996,147, rounded down from 996,147.2 (`~/.codex/ds.models.json`, checked 2026-10-03). The raw
+ * figure agreed with DeepSeek's own overflow message for `deepseek-flash`, so the usable one sits
+ * below the limit DeepSeek enforces. A model not listed here has no window.
+ */
+export declare const DEEPSEEK_RESPONSES_CONTEXT_WINDOWS: Readonly<Record<string, number>>;
+export declare const DeepSeekResponsesConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    streamIdleTimeoutMs: z.ZodNullable<z.ZodNumber>;
+    defaultHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    extraBody: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    thinkingEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        none: "none";
+        medium: "medium";
+        max: "max";
+    }>>;
+    baseURL: z.ZodDefault<z.ZodString>;
+    defaultModel: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type DeepSeekResponsesConfig = z.input<typeof DeepSeekResponsesConfigSchema>;
+type DeepSeekResponsesClientConfig = DeepSeekResponsesConfig & {
+    client?: OpenAI;
+};
+/**
+ * DeepSeek's OpenAI-compatible Responses API.
+ *
+ * The normalized Responses mapping is shared with OpenAI, while the provider name keeps one
+ * backend's replay state out of another. DeepSeek is stateless too, so completed output is replayed
+ * through `provider_state` on the next turn.
+ */
+export declare class DeepSeekResponsesLLMClient extends OpenAIResponsesLLMClient {
+    constructor(config: DeepSeekResponsesClientConfig);
+    buildRequest(call: ModelRequest): {
+        [x: string]: unknown;
+    };
+    /** The structured code where DeepSeek sends one, else the wording of its message. */
+    protected isContextOverflow(fields: ProviderErrorFields): boolean;
+}
+/** DeepSeek's Responses API provider, at DeepSeek's endpoint unless `baseURL` names another. */
+export declare const deepseekProvider: (config: WithCredential<DeepSeekResponsesConfig>) => LLMProvider;
+export {};

package/dist/providers/failure.d.ts

@@ -0,0 +1,23 @@
+/**
+ * What every adapter shares of a failure, whatever its transport or SDK: the kind an HTTP status says,
+ * the kind of a socket error code, and the wait a response's headers ask for. Structured evidence
+ * only; each protocol's own codes and types are classified beside its adapter.
+ */
+import type { FailureClassification, FailureKind } from '../llm/failure.js';
+/**
+ * The kind an HTTP status says on its own, the one fallback every protocol shares: `undefined` for a
+ * status it does not name. With the SDKs' own retries off, every status they used to retry (408, 409,
+ * 429 and every 5xx) has a retried kind, and a 5xx not named here, such as a CDN's 520-524 in front of
+ * a backend, is `transport`. A 402 is a spent balance, which waiting does not lift. A protocol's
+ * own structured evidence (a quota code, an error type) is read before this, where it has one.
+ */
+export declare function statusKind(status: number): FailureKind | undefined;
+/** `kind`, with the wait the headers ask for, except where a wait means nothing: `auth` and `other`. */
+export declare function withRetryAfter(kind: FailureKind, headers: Headers | undefined, now: number): FailureClassification;
+/** The failure kind of a socket error code (Node, undici) somewhere in a failure's causes; else `other`. */
+export declare function socketCodeKind(error: unknown): FailureKind;
+/**
+ * The wait a response's headers ask for, in milliseconds: `retry-after-ms`, else `retry-after` as
+ * delta-seconds or an HTTP date read against `now`. A malformed or negative value is no wait at all.
+ */
+export declare function retryAfterOf(headers: Headers | undefined, now: number): number | undefined;

package/dist/providers/gateway.d.ts

@@ -0,0 +1,24 @@
+import type { LLMClient, StreamingLLMResponse } from '../llm/client.js';
+import type { ModelRequest } from '../llm/request.js';
+/** The protocols a gateway's models answer on: OpenAI Responses, Chat Completions, Anthropic Messages. */
+export type GatewayProtocol = 'responses' | 'chat' | 'messages';
+/** A gateway's check of a call: the protocol it goes on and the call to send. */
+export type PrepareCall = (call: ModelRequest) => {
+    readonly protocol: GatewayProtocol;
+    readonly call: ModelRequest;
+};
+/**
+ * One gateway: a credential and an endpoint in front of models that each answer on one protocol.
+ * It owns the rule that a call goes to the adapter for its model's protocol, never tried on
+ * another. `prepare` is the gateway's own check of a call: it names the protocol, throws what the
+ * gateway refuses, and returns the call to send, normalized for the model where the gateway must.
+ * The adapters are the protocol clients the gateway built, which share its name and its per-call
+ * headers (see `CallHeaders`).
+ */
+export declare class GatewayLLMClient implements LLMClient {
+    readonly providerName: string;
+    private readonly prepare;
+    private readonly adapters;
+    constructor(providerName: string, prepare: PrepareCall, adapters: Readonly<Record<GatewayProtocol, LLMClient>>);
+    chat(call: ModelRequest): Promise<StreamingLLMResponse>;
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@leuduan/lagent/providers`: the shipped providers, their configuration types and the Codex login
+ * helpers a host resolves a credential with. Names only: each provider is built in its own module,
+ * and what the package keeps private (`codexBackend`) is imported from the module that defines it.
+ */
+export { codexAuthPath, CodexCredentialError } from './codexAuth.js';
+export { CODEX_PROVIDER_NAME, codexProvider } from './codex.js';
+export type { CodexConfig } from './codex.js';
+export { DEEPSEEK_RESPONSES_PROVIDER_NAME, deepseekProvider } from './deepseek.js';
+export type { DeepSeekResponsesConfig } from './deepseek.js';
+export { openaiChatProvider } from './openaiChat.js';
+export type { OpenAIChatConfig } from './openaiChat.js';
+export { openaiResponsesProvider } from './openaiResponses.js';
+export type { OpenAIResponsesConfig } from './openaiResponses.js';
+export { OPENCODE_COPILOT_PROVIDER_NAME, opencodeCopilotProvider } from './opencodeCopilot.js';
+export type { OpenCodeCopilotConfig } from './opencodeCopilot.js';
+export { OPENCODE_GO_PROVIDER_NAME, opencodeGoProvider } from './opencodeGo.js';
+export type { OpenCodeGoConfig } from './opencodeGo.js';