@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/plugins/providers/codex.d.ts

@@ -0,0 +1,60 @@
+import OpenAI from 'openai';
+import { z } from 'zod';
+import type { ModelOption } from '../../llm/index.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` of 272,000 with its `effective_context_window_percent` of 95 applied, 258,400
+ * (`~/.codex/models_cache.json`, checked 2026-10-03). 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;

package/dist/plugins/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/plugins/providers/deepseek.d.ts

@@ -0,0 +1,55 @@
+import type OpenAI from 'openai';
+import { z } from 'zod';
+import type { ModelOption, ModelRequest } from '../../llm/index.js';
+import { OpenAIResponsesLLMClient } from './openaiResponses.js';
+import { type ProviderErrorFields } 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;
+}
+export {};

package/dist/plugins/providers/door.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `@leuduan/lagent/providers`: the shipped providers, their configuration types and the Codex login
+ * helpers a host resolves a credential with. The package's own entry point to this folder is
+ * `index.ts`, which adds what the package keeps private.
+ */
+import type { LLMProvider } from '../../llm/index.js';
+import { type CodexConfig } from './codex.js';
+import { type OpenAIChatConfig } from './openaiChat.js';
+import { type OpenAIResponsesConfig } from './openaiResponses.js';
+import { type DeepSeekResponsesConfig } from './deepseek.js';
+import { type OpenCodeGoConfig } from './opencodeGo.js';
+/**
+ * A provider's configuration with its credential named: the host resolves it, from wherever it keeps
+ * it, and says so even when it has none. A provider without one can still be described, its defaults
+ * and models read; building a client for it then fails, naming what is missing.
+ */
+type WithCredential<Config> = Config & {
+    readonly apiKey: string | undefined;
+};
+/**
+ * The OpenAI Responses provider, at OpenAI's endpoint unless `baseURL` names another. Building one
+ * registers nothing, so a host can read its defaults and models first (see `defaultRoute`);
+ * `registerProvider(ctx, openaiResponsesProvider(config), { retry })` registers it.
+ */
+export declare const openaiResponsesProvider: (config: WithCredential<OpenAIResponsesConfig>) => LLMProvider;
+/** DeepSeek's Responses API provider, at DeepSeek's endpoint unless `baseURL` names another. */
+export declare const deepseekProvider: (config: WithCredential<DeepSeekResponsesConfig>) => LLMProvider;
+/**
+ * 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;
+/**
+ * The OpenAI Chat Completions provider, and with a `baseURL` any gateway that speaks it. It declares
+ * no models and no windows of its own: a gateway serves whatever ids its operator configured, so the
+ * windows it declares are the ones `contextWindows` configures. It replays reasoning text but no
+ * opaque reasoning state, and provider-executed tools are refused.
+ */
+export declare const openaiChatProvider: (config: WithCredential<OpenAIChatConfig>) => LLMProvider;
+/**
+ * The OpenCode Go gateway (`https://opencode.ai/zen/go/v1`): one subscription key in front of many
+ * vendors' models, each answering on one protocol: OpenAI Responses, Chat Completions or Anthropic
+ * Messages, each served by its own client. The host names itself with a
+ * `User-Agent` in `defaultHeaders`; each request carries its thread as Go's session header.
+ */
+export declare const opencodeGoProvider: (config: WithCredential<OpenCodeGoConfig>) => LLMProvider;
+export { CODEX_PROVIDER_NAME } from './codex.js';
+export type { CodexConfig } from './codex.js';
+export type { OpenAIChatConfig } from './openaiChat.js';
+export { codexAuthPath, CodexCredentialError } from './codexAuth.js';
+export type { OpenAIResponsesConfig } from './openaiResponses.js';
+export { DEEPSEEK_RESPONSES_PROVIDER_NAME } from './deepseek.js';
+export { OPENCODE_GO_PROVIDER_NAME } from './opencodeGo.js';
+export type { OpenCodeGoConfig } from './opencodeGo.js';
+export type { DeepSeekResponsesConfig } from './deepseek.js';
+export { OPENCODE_COPILOT_PROVIDER_NAME, opencodeCopilotProvider } from './opencodeCopilot.js';
+export type { OpenCodeCopilotConfig } from './opencodeCopilot.js';

package/dist/plugins/providers/door.js

@@ -0,0 +1 @@
+import{a,b,d as c,e as d,f as e,g as f,h as g,i as h,j as i,k as j,l as k,m as l}from"../../chunks/WUUKTSRT.js";import"../../chunks/NDIM7MEW.js";import"../../chunks/34KW6VNQ.js";import"../../chunks/PUSUPTAT.js";import"../../chunks/DDANMY45.js";import"../../chunks/D7E6EWIE.js";export{c as CODEX_PROVIDER_NAME,a as CodexCredentialError,d as DEEPSEEK_RESPONSES_PROVIDER_NAME,f as OPENCODE_COPILOT_PROVIDER_NAME,e as OPENCODE_GO_PROVIDER_NAME,b as codexAuthPath,j as codexProvider,i as deepseekProvider,k as openaiChatProvider,h as openaiResponsesProvider,g as opencodeCopilotProvider,l as opencodeGoProvider};

package/dist/plugins/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/index.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/plugins/providers/gateway.d.ts

@@ -0,0 +1,23 @@
+import type { LLMClient, ModelRequest, StreamingLLMResponse } from '../../llm/index.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/plugins/providers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The package's own entry point to the providers: the public door, and `codexBackend`, which the web
+ * search tool uses and the package does not offer.
+ */
+export * from './door.js';
+export { codexBackend } from './codexAuth.js';

package/dist/plugins/providers/openaiChat.d.ts

@@ -0,0 +1,62 @@
+import OpenAI from 'openai';
+import type { ChatCompletionChunk } from 'openai/resources/chat/completions';
+import { z } from 'zod';
+import type { ConversationMessage, LLMClient, ModelRequest, StreamingLLMResponse } from '../../llm/index.js';
+import type { DeepReadonly } from '../../util/json.js';
+import { type CallHeaders } from './stream.js';
+export declare const OPENAI_CHAT_DEFAULT_MODEL = "gpt-5.4";
+export declare const OpenAIChatConfigSchema: 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>;
+    systemRole: z.ZodDefault<z.ZodEnum<{
+        system: "system";
+        developer: "developer";
+    }>>;
+    contextWindows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export type OpenAIChatConfig = z.input<typeof OpenAIChatConfigSchema>;
+type RequestPayload = Record<string, unknown>;
+/**
+ * LLM client for the OpenAI Chat Completions API, and for the many gateways that speak it.
+ *
+ * What it cannot do is the reason it is not the direction: Chat Completions has no field for a
+ * model's opaque reasoning state. Reasoning text goes back as the `reasoning_content` vendor
+ * extension, which models that read it accept, but this client writes no `provider_state`.
+ * Provider-executed tools are refused outright rather than silently dropped.
+ */
+export declare class OpenAIChatLLMClient implements LLMClient {
+    readonly providerName: string;
+    protected readonly client: OpenAI;
+    private readonly callHeaders;
+    /** Absent sends no effort, leaving it to the model; a named one, `none` included, is sent. */
+    private readonly thinkingEffort;
+    private readonly extraBody;
+    private readonly systemRole;
+    private readonly streamIdleTimeoutMs;
+    /**
+     * `name` is the provider the client speaks for (a gateway's); `headers` adds headers to each call.
+     * Both are the client's owner's: nothing subclasses the client to say them.
+     */
+    constructor(config: OpenAIChatConfig & {
+        client?: OpenAI;
+        name?: string;
+        headers?: CallHeaders;
+    });
+    buildRequest(call: ModelRequest): RequestPayload;
+    /** The one SDK call of this protocol; `headers` are the call's own, over the client's defaults. */
+    protected openStream(request: RequestPayload, headers: Record<string, string>, signal: AbortSignal): Promise<AsyncIterable<ChatCompletionChunk>>;
+    chat(call: ModelRequest): Promise<StreamingLLMResponse>;
+}
+export declare function toChatMessage(message: DeepReadonly<ConversationMessage>, provider?: string): unknown;
+export {};

package/dist/plugins/providers/openaiResponses.d.ts

@@ -0,0 +1,100 @@
+import OpenAI from 'openai';
+import type { Response, ResponseInputItem, ResponseStreamEvent } from 'openai/resources/responses/responses';
+import { z } from 'zod';
+import type { ConversationMessage, LLMClient, ModelOption, ModelRequest, StreamingLLMResponse } from '../../llm/index.js';
+import type { DeepReadonly } from '../../util/json.js';
+import { type ProviderErrorFields } from './shared.js';
+import { type CallHeaders } from './stream.js';
+export declare class UnsupportedResponseOutputError extends Error {
+    constructor(types: readonly string[]);
+}
+export declare const OPENAI_RESPONSES_DEFAULT_MODEL = "gpt-5.4";
+/**
+ * The models agents are told about, with the efforts lagent can send. From the list the Codex
+ * backend serves, which marks them available in the API (checked 2026-09-26).
+ */
+export declare const OPENAI_RESPONSES_MODELS: readonly ModelOption[];
+/**
+ * The usable context window of each model this provider declares one for, in tokens.
+ *
+ * The `gpt-6-*` figures come from the Codex CLI's model cache for the same models on the Codex
+ * backend: a `context_window` of 272,000 with its `effective_context_window_percent` of 95 applied,
+ * 258,400 (`~/.codex/models_cache.json`, checked 2026-10-03). `gpt-5.4`, the default, is not in
+ * that cache; it is given the same 258,400 as the conservative figure for the family. The raw figure
+ * is itself conservative: the Codex backend accepted 285,889 input tokens on a model it lists at
+ * 272,000 (measured 2026-10-03). A model not listed here has no window.
+ */
+export declare const OPENAI_RESPONSES_CONTEXT_WINDOWS: Readonly<Record<string, number>>;
+export declare const OpenAIResponsesConfigSchema: 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 OpenAIResponsesConfig = z.input<typeof OpenAIResponsesConfigSchema>;
+type RequestPayload = Record<string, unknown>;
+/**
+ * LLM client for the OpenAI Responses API. History is application-managed (`store: false`) and
+ * provider-owned output items round-trip through `ConversationMessage.provider_state`, so
+ * encrypted reasoning survives across turns.
+ */
+export declare class OpenAIResponsesLLMClient implements LLMClient {
+    readonly providerName: string;
+    protected readonly client: OpenAI;
+    private readonly callHeaders;
+    private readonly replayByModel;
+    private readonly thinkingEffort;
+    private readonly extraBody;
+    private readonly streamIdleTimeoutMs;
+    /**
+     * `name` is the provider the client speaks for (Codex's, a gateway's); `headers` adds headers to
+     * each call; `replayByModel` narrows replayable state to the model that wrote it, for a gateway
+     * serving several vendors under one name. All are the client's owner's: nothing subclasses the
+     * client to say them.
+     */
+    constructor(config: OpenAIResponsesConfig & {
+        client?: OpenAI;
+        name?: string;
+        headers?: CallHeaders;
+        replayByModel?: boolean;
+    });
+    buildRequest(call: ModelRequest): RequestPayload;
+    /**
+     * Whose output a request may splice back verbatim, and the tag its own output is written under:
+     * the client's name, so another backend's state is rebuilt from the normalized fields; with
+     * `replayByModel`, the name and the model.
+     */
+    private replayTag;
+    /** The one SDK call of this protocol; `headers` are the call's own, over the client's defaults. */
+    protected openStream(request: RequestPayload, headers: Record<string, string>, signal: AbortSignal): Promise<AsyncIterable<ResponseStreamEvent>>;
+    chat(call: ModelRequest): Promise<StreamingLLMResponse>;
+    /**
+     * Whether a provider error says the request exceeded the model's context window: the structured
+     * code `context_length_exceeded`, on a rejected request and inside the stream alike (where the
+     * Codex backend reported it, with type `invalid_request_error`, param `input` and no count;
+     * measured 2026-10-03). A variant whose backend has no code for it overrides this.
+     */
+    protected isContextOverflow(fields: ProviderErrorFields): boolean;
+}
+/**
+ * Maps the conversation to Responses input items. An assistant message carrying **this client's**
+ * own state is spliced back verbatim; anything else is synthesized from the normalized fields.
+ *
+ * The tag is the client's replay tag (its name unless it narrows it) rather than this module's,
+ * because a credential variant talks to a different backend: Codex's encrypted reasoning is not
+ * something `api.openai.com` can read, so whichever client did not write it rebuilds the message from
+ * the normalized fields instead.
+ */
+export declare function toResponsesInput(messages: readonly DeepReadonly<ConversationMessage>[], replayTag?: string): ResponseInputItem[];
+/** Normalizes a completed response into a `ConversationMessage`, tagged for the client that got it. */
+export declare function responseToMessage(response: Response, replayTag?: string): ConversationMessage;
+export {};

package/dist/plugins/providers/opencodeCopilot.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { LLMProvider } from '../../llm/index.js';
+export declare const OPENCODE_COPILOT_PROVIDER_NAME = "opencode-copilot";
+declare const ConfigSchema: z.ZodObject<{
+    authPath: z.ZodString;
+    streamIdleTimeoutMs: z.ZodNullable<z.ZodNumber>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    thinkingEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        none: "none";
+        medium: "medium";
+        max: "max";
+    }>>;
+}, z.core.$strict>;
+export type OpenCodeCopilotConfig = z.input<typeof ConfigSchema>;
+/**
+ * Initialize before registration. Reads the OpenCode login at `authPath`, then discovers models;
+ * any startup failure rejects, so no provider is offered without a live catalog. No login or refresh.
+ * Protocols and headers follow anomalyco/opencode's github-copilot plugin (checked 2026-10-14).
+ */
+export declare function opencodeCopilotProvider(config: OpenCodeCopilotConfig): Promise<LLMProvider>;
+export {};

package/dist/plugins/providers/opencodeGo.d.ts

@@ -0,0 +1,98 @@
+import type OpenAI from 'openai';
+import { z } from 'zod';
+import type { ModelOption, ThinkingEffort } from '../../llm/index.js';
+import { GatewayLLMClient, type GatewayProtocol } from './gateway.js';
+export declare const OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
+export declare const OPENCODE_GO_PROVIDER_NAME = "opencode-go";
+export declare const OPENCODE_GO_DEFAULT_MODEL = "deepseek-v4.1-flash";
+/**
+ * A model Go serves: the protocol it answers on, its context window when one is known, the efforts
+ * it accepts when it was found to refuse some, for a Messages model, which needs one on every
+ * request, its output cap, and for a Chat model that refuses the `developer` role, the role its
+ * notices go as instead.
+ */
+type GoModel = {
+    readonly protocol: GatewayProtocol;
+    readonly contextWindow?: number;
+    readonly thinkingEfforts?: readonly ThinkingEffort[];
+    readonly maxOutputTokens?: number;
+    readonly developerRole?: DeveloperRole;
+};
+/** The role a Chat model is sent lagent's notices as: `developer` as they are, or `system`, in place. */
+type DeveloperRole = 'developer' | 'system';
+type GoModelTable = Readonly<Record<string, GoModel>>;
+/**
+ * Every model Go serves, with the one protocol it answers on (any other endpoint returns
+ * `ModelProtocolUnsupported`) and its context window in tokens. Protocols from Go's model table
+ * (https://opencode.ai/v2/docs/console/go); windows from the `opencode-go` entry of
+ * https://models.dev/api.json, its `input` limit where it gives one, else `context`, undiscounted
+ * (both checked 2026-10-11); a Messages model's output cap is that entry's `output` limit (checked
+ * 2026-10-12). `GET /models` lists ids but no protocol, so nothing here is discovered.
+ */
+export declare const OPENCODE_GO_MODEL_TABLE: GoModelTable;
+export declare const OpenCodeGoConfigSchema: 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>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        protocol: z.ZodEnum<{
+            messages: "messages";
+            responses: "responses";
+            chat: "chat";
+        }>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        thinkingEfforts: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            none: "none";
+            medium: "medium";
+            max: "max";
+        }>>>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        developerRole: z.ZodOptional<z.ZodEnum<{
+            system: "system";
+            developer: "developer";
+        }>>;
+    }, z.core.$strict>>>;
+}, z.core.$strip>;
+export type OpenCodeGoConfig = z.input<typeof OpenCodeGoConfigSchema>;
+type ParsedConfig = z.output<typeof OpenCodeGoConfigSchema>;
+/**
+ * Go's configuration, parsed, with its default model checked to be one lagent can speak to: a model
+ * whose protocol nobody named, or a Messages model with no output cap, fails here rather than on the
+ * first turn.
+ */
+export declare function parseOpenCodeGoConfig(config: OpenCodeGoConfig): {
+    readonly config: ParsedConfig;
+    readonly table: GoModelTable;
+};
+/** The models agents are told about: every model shipped and configured. */
+export declare const openCodeGoModels: (table: GoModelTable) => readonly ModelOption[];
+/** The declared window of `model`, `null` where neither the table nor the configuration gives one. */
+export declare const openCodeGoWindow: (table: GoModelTable, model: string) => number | null;
+/**
+ * The OpenCode Go gateway: one credential and one endpoint in front of models that each answer on
+ * one protocol. Each call goes to the adapter for its model's protocol, Responses, Chat Completions
+ * or Anthropic Messages, never tried on another endpoint. Responses and Chat share one SDK client;
+ * Messages goes over `fetch`, with the key as `x-api-key`. Every request carries its thread as Go's
+ * session header. Go serves several vendors' models under one name, and one vendor's encrypted
+ * reasoning or signed thinking is nothing another can read: output replays only to the model that
+ * wrote it, and a thread changing model is rebuilt from the normalized fields.
+ */
+export declare class OpenCodeGoLLMClient extends GatewayLLMClient {
+    constructor(config: OpenCodeGoConfig & {
+        client?: OpenAI;
+        fetch?: typeof globalThis.fetch;
+    });
+}
+export {};