@lmctl-ai/lmctl 0.1.342 → 0.2.3

package/dist/providers/index.d.ts

@@ -0,0 +1,421 @@
+/**
+ * Public API surface for the lmctl provider library.
+ *
+ * Phase A0.4 introduces this facade so A1's engine switch (gated by
+ * `LMCTL_USE_LIBRARY_PROVIDER=1`) can `import { chat, seed,
+ * listSessions, countTokens } from "../providers/index.js"` and rely on
+ * a stable surface even as the internal file layout under
+ * `src/providers/` evolves.
+ *
+ * The four exported functions are thin wrappers around the existing
+ * adapter / registry plumbing copied in by A0.1. They do not introduce
+ * new behavior; if `chat()` rejects, the rejection comes from the
+ * underlying transport (claude / codex / gemini), not from this layer.
+ *
+ * @module providers
+ */
+import type { ProgressEvent, TurnOptions } from "./adapter.js";
+import type { ProviderName, SessionSummary, SessionTokenUsage } from "./types.js";
+import { ProviderRegistry } from "./registry.js";
+import type { BundleSession, BundleSessionOpenOptions } from "./bundle.js";
+/**
+ * Test-only escape hatch: drop the cached default registry. Calls to
+ * `chat()` / `seed()` / `listSessions()` / `countTokens()` made without
+ * an explicit `registry:` field will rebuild on next use.
+ */
+export declare function _resetDefaultRegistryForTests(): void;
+/**
+ * Options for a single chat turn against an existing native provider session.
+ */
+export interface ChatOptions {
+    /** Which provider drives the turn. */
+    provider: ProviderName;
+    /** Native session id to resume. */
+    sessionId: string;
+    /** Working directory the provider CLI runs in for this turn. */
+    cwd: string;
+    /** The user prompt sent on this turn. */
+    prompt: string;
+    /** Optional model override; format is provider-specific (e.g. `claude-sonnet-4-6`). */
+    model?: string;
+    /** Optional effort / variant override; used by OpenCode ACP. Kimi has no genuine per-turn effort override, so this is unsupported (and warned on) for kimi members. */
+    effort?: string;
+    /**
+     * Idle timeout in ms. Default: 8 hours. `0` disables the timer; when
+     * the timer fires the turn resolves with `status: "stalled"` rather
+     * than killing the child — see the underlying `TurnResult` doc.
+     */
+    timeoutMs?: number;
+    /** Abort signal for cancellation (caller rejects immediately on abort). */
+    signal?: AbortSignal;
+    /** Streaming delta callback — every text chunk the provider emits. */
+    onDelta?: (text: string) => void;
+    /** Classified progress events (tool_use / tool_result / thinking / …). */
+    onProgress?: (event: ProgressEvent) => void;
+    /** Environment overrides for the spawned provider process. */
+    env?: NodeJS.ProcessEnv;
+    /** Override the spawned provider binary path (troubleshooting dev builds). */
+    progPath?: string;
+    /**
+     * Teamfile alias of the member being spawned.
+     */
+    alias?: string;
+    /** Role-based Lead signal from teamfile resolution. */
+    isLead?: boolean;
+    /**
+     * Defer end-of-turn shutdown while the session still has outstanding
+     * dispatched work of its own. See `TurnOptions.holdOpen`.
+     */
+    holdOpen?: TurnOptions["holdOpen"];
+    /**
+     * Permission mode for the turn — `"yolo"` (default) or `"plan"`.
+     * Plumbed straight through to the adapter's TurnOptions so the
+     * transport rewrites argv / JSON-RPC params per the table in
+     * `src/providers/yolo-contract.ts`. Default `"yolo"` preserves
+     * the historical contract.
+     */
+    permissionMode?: import("./yolo-contract.js").PermissionMode;
+    /**
+     * Fail closed on resume: when `true`, a provider that cannot load the
+     * requested `sessionId` MUST error instead of silently creating a NEW
+     * session. Currently only meaningful for ACP-transport providers
+     * (opencode/kimi/gemini/copilot) — that's the only transport that reads it
+     * (see `acp.ts` `session/load` handling); every other provider silently
+     * IGNORES it (it is a request for stricter behavior a provider MAY not
+     * support, never an error). Omitted/`false` preserves the historical
+     * fallback-with-warning behavior. Batch opts in so successive prompts keep
+     * their conversation; ordinary chat preserves its existing behavior.
+     * Other callers (e.g. a Hermes ACP adapter) may also opt in explicitly.
+     *
+     * Caveat: a member configured with a custom one-shot `agent=` command routes
+     * through `runOneShotAgent`, which bypasses the ACP transport entirely — the
+     * flag has no effect there (consistent with "a provider MAY not support it").
+     */
+    requireResume?: boolean;
+    /**
+     * Caller-held bundle session (batch bundle mode): when set, this
+     * turn goes through the already-open provider process instead of
+     * spawning a new one. Spawn-time options (model, effort, env, holdOpen)
+     * were fixed at open. See src/providers/bundle.ts for the contract.
+     */
+    bundleSession?: import("./bundle.js").BundleSession;
+    /**
+     * Provider-adapter registry. If omitted, a default built from
+     * `createAllAdapters()` is reused across calls. Pass an explicit
+     * registry when you need custom provider home directories
+     * (testing) or a non-default adapter set.
+     */
+    registry?: ProviderRegistry;
+}
+/**
+ * Result of a single chat turn.
+ *
+ * `text` is the final assistant response (with multi-turn aggregation
+ * applied for stream-json — see `joinResultTurns`). `status` is `"ok"`
+ * on normal completion, or `"stalled"` when the idle timer fired (the
+ * child remains alive; caller decides what to do).
+ *
+ * Per-turn token usage is NOT returned here — providers persist it to
+ * their on-disk session files. Read it with `countTokens()` after.
+ */
+export interface ChatResult {
+    text: string;
+    sessionId: string;
+    durationMs: number;
+    stopReason?: string;
+    numTurns?: number;
+    status?: "ok" | "stalled";
+    stalledAfterMs?: number;
+    /** Human-readable strings when this turn's provider silently dropped a
+     * declared model=/effort= (task #232). Omitted when nothing was dropped. */
+    warnings?: string[];
+}
+/**
+ * Run one chat turn against an existing native session.
+ *
+ * Delegates to `ProviderAdapter.sendTurn` for the named provider.
+ *
+ * @param opts - chat call options; see {@link ChatOptions}
+ * @param opts.provider - which provider adapter drives the turn
+ *   (for example `"claude"`, `"codex"`, `"gemini"`, or `"agy"`)
+ * @param opts.sessionId - native session id to resume
+ * @param opts.cwd - working directory the provider CLI runs in
+ * @param opts.prompt - user message sent on this turn
+ * @param opts.model - optional provider-specific model override
+ * @param opts.timeoutMs - idle timeout in ms (default 8h; 0 disables)
+ * @param opts.signal - abort signal; on abort the caller rejects with
+ *   `Error("Aborted")` while the child gets a graceful-shutdown ladder
+ * @param opts.onDelta - streaming text-chunk callback
+ * @param opts.onProgress - classified ProgressEvent callback
+ * @param opts.env - environment overrides for the spawned child
+ * @param opts.progPath - override the spawned binary path (dev builds)
+ * @param opts.alias - teamfile alias of the spawning member
+ *   (Lead-only flows gate on case-insensitive `"lead"`)
+ * @param opts.registry - DI for the ProviderRegistry; omit to use the
+ *   lazily-built default
+ * @returns A {@link ChatResult} with the assembled assistant text plus
+ *   session bookkeeping (durationMs, stopReason, numTurns, status).
+ * @throws `Error` (plain) when `opts.provider` is not registered in
+ *   the supplied (or default) registry — message matches
+ *   `/not registered/`. {@link TransportConnectionError} if the
+ *   provider binary cannot be spawned (ENOENT).
+ *   {@link TransportProcessError} if it exits non-zero before a final
+ *   result event. {@link TransportJsonError} on malformed wire frames.
+ *   {@link TransportRpcError} on JSON-RPC errors from codex / gemini
+ *   app-server. `Error("Aborted")` (plain) on `opts.signal` abort.
+ * @example
+ * ```ts
+ * import { chat } from "../providers/index.js";
+ *
+ * const result = await chat({
+ *   provider: "claude",
+ *   sessionId: "ses-abc",
+ *   cwd: "/repo",
+ *   prompt: "summarize the diff",
+ *   model: "claude-sonnet-4-6",
+ *   onDelta: (chunk) => process.stdout.write(chunk),
+ * });
+ * console.log(result.text);
+ * ```
+ */
+export declare function chat(opts: ChatOptions): Promise<ChatResult>;
+/**
+ * Options for opening a bundle session — one provider process serving many
+ * prompts (batch bundle mode). The lifecycle contract is in
+ * `src/providers/bundle.ts`.
+ */
+export interface OpenBundleSessionOptions extends BundleSessionOpenOptions {
+    /** Which provider drives the bundle. */
+    provider: ProviderName;
+    /** Adapter registry override. See {@link ChatOptions.registry}. */
+    registry?: ProviderRegistry;
+}
+/**
+ * Providers whose adapter implements `openSession` — the bundle-SUPPORTED
+ * set for this version (Landing C1: the ACP providers). Distinct from
+ * `BUNDLE_CAPABLE_PROVIDERS` in bundle.ts, which is the by-design matrix
+ * including the transports a follow-up landing will implement.
+ */
+export declare function bundleSupportedProviders(registry?: ProviderRegistry): string[];
+/**
+ * Open a bundle session for `opts.provider`. Throws when the provider's
+ * adapter has no `openSession` (not bundle-supported in this version).
+ */
+export declare function openBundleSession(opts: OpenBundleSessionOptions): Promise<BundleSession>;
+/**
+ * Options for bootstrapping a new provider session.
+ */
+export interface SeedOptions {
+    /** Provider whose CLI will be spawned to create the session. */
+    provider: ProviderName;
+    /** Working directory where the session-bound subprocess will run. */
+    cwd: string;
+    /** Optional initial-turn model override. */
+    model?: string;
+    /** Optional initial-turn effort / variant override. */
+    effort?: string;
+    /** Optional initial seed prompt; defaults to the standard seed ACK prompt. */
+    prompt?: string;
+    /** Adapter registry override. See {@link ChatOptions.registry}. */
+    registry?: ProviderRegistry;
+}
+/**
+ * Result of `seed()`. On success, the on-disk session has been written
+ * and is discoverable via `listSessions()`. On failure, `error` carries
+ * the human-readable cause; the caller typically falls back to the
+ * adapter's `manualSeedHint()`.
+ *
+ * A0.5 extension (added during A2.1): `sessionId` carries the native
+ * session id of the freshly-created session when discovery can match
+ * a single new entry against the pre-seed snapshot. Callers that need
+ * the id (the engine's `seedMember` does) read it directly; older
+ * callers that only checked `success` keep working unchanged.
+ *
+ * `sessionId` may be omitted (undefined) when:
+ *   - `success: false`
+ *   - discovery couldn't isolate a single new session (parallel seed
+ *     races; corrupt session file; provider that doesn't persist
+ *     immediately). Callers must defensively fall back to
+ *     `listSessions()` + their own diff logic in that case.
+ */
+export interface SeedResult {
+    success: boolean;
+    error?: string;
+    /** Non-fatal provider diagnostics that callers should surface to the operator. */
+    warnings?: string[];
+    /** Native session id of the freshly-created session. See doc above. */
+    sessionId?: string;
+}
+/**
+ * Bootstrap a new native session for the given provider in `cwd`.
+ *
+ * Delegates to `ProviderAdapter.seed`. The provider spawns its own
+ * one-shot seed turn (via the SEED_INITIAL_PROMPT shared across
+ * adapters) and the session file lands in the provider's home
+ * directory. `listSessions()` will then find it.
+ *
+ * @param opts - seed call options; see {@link SeedOptions}
+ * @param opts.provider - provider whose CLI is spawned
+ *   (for example `"claude"`, `"codex"`, `"gemini"`, or `"agy"`)
+ * @param opts.cwd - working directory the session is bound to
+ * @param opts.model - optional initial-turn model override
+ * @param opts.registry - DI for the ProviderRegistry; omit to use the
+ *   lazily-built default
+ * @returns {@link SeedResult} — `{success: true, sessionId?}` on
+ *   success (with the new session id when discovery can isolate one),
+ *   `{success: false, error}` on failure (error is human-readable
+ *   and surfaces the adapter / transport reason).
+ * @throws `Error` (plain) when `opts.provider` is not registered in
+ *   the supplied (or default) registry — message matches
+ *   `/not registered/`. Otherwise the adapter swallows underlying
+ *   transport / spawn errors into `SeedResult.error` rather than
+ *   rejecting; an unexpected throw indicates a bug at this layer.
+ * @example
+ * ```ts
+ * import { seed } from "../providers/index.js";
+ *
+ * const { success, error, sessionId } = await seed({
+ *   provider: "claude",
+ *   cwd: "/repo/teams/backend",
+ * });
+ * if (!success) throw new Error(`seed failed: ${error}`);
+ * await persist(sessionId);  // engine writes the new id to teamfile
+ * ```
+ */
+export declare function seed(opts: SeedOptions): Promise<SeedResult>;
+/**
+ * Options for enumerating on-disk provider sessions.
+ */
+export interface ListSessionsOptions {
+    /** Restrict to one provider. Omit to list across all registered providers. */
+    provider?: ProviderName;
+    /** Filter by canonical workspace path (matches `SessionSummary.cwd`). */
+    workspace?: string;
+    /** Cap the result count after sorting by `modifiedAt` descending. */
+    limit?: number;
+    /** Only sessions modified at-or-after this date. */
+    from?: Date;
+    /** Only sessions modified at-or-before this date. */
+    to?: Date;
+    /** Adapter registry override. See {@link ChatOptions.registry}. */
+    registry?: ProviderRegistry;
+}
+/**
+ * Enumerate native provider sessions on disk.
+ *
+ * Walks the registered providers' session directories
+ * (`~/.claude/projects/`, `~/.codex/sessions/`, `~/.gemini/tmp/.../chats/`, ...)
+ * via the existing `ProviderRegistry.listAll` plumbing.
+ *
+ * @param opts - listing options; see {@link ListSessionsOptions}.
+ *   All fields are optional; omit `opts` entirely to list across every
+ *   registered provider with no filtering.
+ * @param opts.provider - restrict to one provider; omit for all
+ * @param opts.workspace - filter by canonical workspace path (matched
+ *   against `SessionSummary.cwd` via `canonicalPath`)
+ * @param opts.limit - cap the result count after newest-first sort
+ * @param opts.from - lower bound on `modifiedAt` (inclusive)
+ * @param opts.to - upper bound on `modifiedAt` (inclusive)
+ * @param opts.registry - DI for the ProviderRegistry; omit to use the
+ *   lazily-built default
+ * @returns Array of {@link SessionSummary} entries, sorted newest-first.
+ * @throws Adapter `discover()` calls catch and log most filesystem
+ *   errors internally (a corrupt session JSONL doesn't fail the whole
+ *   listing). Unexpected throws bubble up.
+ * @example
+ * ```ts
+ * import { listSessions } from "../providers/index.js";
+ *
+ * const recent = await listSessions({
+ *   provider: "claude",
+ *   workspace: "/repo",
+ *   limit: 5,
+ * });
+ * for (const s of recent) console.log(s.sessionId, s.modifiedAt);
+ * ```
+ */
+export declare function listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]>;
+/**
+ * Options for `countTokens()`.
+ */
+export interface CountTokensOptions {
+    /** Session id to look up. */
+    sessionId: string;
+    /**
+     * Restrict the lookup to one provider. If omitted, the registry
+     * probes every provider in registration order and returns the first
+     * match (same semantics as `lmctl info <sessionid>`).
+     */
+    provider?: ProviderName;
+    /** Adapter registry override. See {@link ChatOptions.registry}. */
+    registry?: ProviderRegistry;
+}
+/**
+ * Aggregate token usage for a single session.
+ *
+ * `input`, `output`, etc. mirror `SessionSummary.total*Tokens` —
+ * cumulative counts across every turn the session has produced. `total`
+ * is the sum the provider reports (when available); when only the
+ * per-bucket fields are populated, callers can compute `input +
+ * cachedInput + cacheWriteInput + output + reasoningOutput`.
+ */
+export interface TokenCount {
+    /** Provider that owns the session. */
+    provider: ProviderName;
+    /** Echoed sessionId for round-trip identification. */
+    sessionId: string;
+    /** Cumulative uncached input tokens. */
+    input: number;
+    /** Cumulative cache-hit input tokens. */
+    cachedInput: number;
+    /** Cumulative cache-write input tokens (claude only today). */
+    cacheWriteInput: number;
+    /** Cumulative output tokens. */
+    output: number;
+    /** Cumulative reasoning (a.k.a. "thoughts") output tokens. */
+    reasoningOutput: number;
+    /**
+     * Cumulative grand total = sum of the five per-bucket fields above.
+     * This is NOT the last-turn total — see `lastTurn.totalTokens`.
+     */
+    total: number;
+    /** Raw last-turn usage snapshot when the session file recorded it. */
+    lastTurn?: SessionTokenUsage;
+}
+/**
+ * Aggregate token usage for a single session.
+ *
+ * Loads the session via the registered adapter, then extracts the
+ * `total*Tokens` fields the discovery / load pass already computed.
+ * Returns zeros for any field the provider did not report — callers
+ * MUST treat 0 as "not measured" rather than "free." `total` is the
+ * SUM of the five per-bucket fields; for a last-turn snapshot read
+ * `lastTurn.totalTokens` instead.
+ *
+ * @param opts - lookup options; see {@link CountTokensOptions}
+ * @param opts.sessionId - native session id (UUID-like)
+ * @param opts.provider - restrict to one provider; omit to probe every
+ *   registered provider in registration order
+ * @param opts.registry - DI for the ProviderRegistry; omit to use the
+ *   lazily-built default
+ * @returns {@link TokenCount} populated from the session's persisted
+ *   token buckets.
+ * @throws `Error("session <sessionId> not found")` when no registered
+ *   provider can resolve the id (message matches `/not found/`).
+ * @example
+ * ```ts
+ * import { countTokens } from "../providers/index.js";
+ *
+ * const usage = await countTokens({ sessionId: "ses-abc" });
+ * console.log(`${usage.input} in / ${usage.output} out`);
+ * ```
+ */
+export declare function countTokens(opts: CountTokensOptions): Promise<TokenCount>;
+export type { ProviderAdapter } from "./adapter.js";
+export type { ProgressEvent, TurnOptions, TurnResult, } from "./adapter.js";
+export type { ProviderName, SessionSummary, SessionDetail, SessionTokenUsage, ConversationMessage, MessageRole, } from "./types.js";
+export { ProviderRegistry, createAdapterRegistry } from "./registry.js";
+export { createAllAdapters } from "./adapters/index.js";
+export type { BundleSession, BundleSessionOpenOptions, BundleTurnOptions, BundleTurnResult, } from "./bundle.js";
+export { BUNDLE_CAPABLE_PROVIDERS, BUNDLE_NEVER_CAPABLE_PROVIDERS, } from "./bundle.js";
+export { TransportError, TransportConnectionError, TransportProcessError, TransportJsonError, TransportRpcError, } from "./transport-errors.js";

package/dist/providers/kimi.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Kimi Code session provider.
+ *
+ * Kimi persists an append-only session index plus one self-contained directory
+ * per session:
+ *   $KIMI_CODE_HOME/session_index.jsonl
+ *   $KIMI_CODE_HOME/sessions/<workspace>/<session>/state.json
+ *   $KIMI_CODE_HOME/sessions/<workspace>/<session>/agents/main/wire.jsonl
+ */
+import type { SessionDetail, SessionProvider, SessionSummary } from "./types.js";
+interface KimiProviderOptions {
+    kimiHome?: string;
+}
+export declare class KimiProvider implements SessionProvider {
+    name: "kimi";
+    private readonly homeDir;
+    private readonly sessionsDir;
+    constructor(opts?: KimiProviderOptions);
+    discoverSessions(): Promise<SessionSummary[]>;
+    loadSession(sessionId: string): Promise<SessionDetail | null>;
+    resolveSessionPath(sessionId: string): Promise<string | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    getWatchPaths(): {
+        directory: string;
+        filePattern: RegExp;
+    }[];
+    private indexPath;
+    private sessionFiles;
+    private readIndex;
+    private filesFor;
+    private validSessionDir;
+    private findSession;
+    private readState;
+    private summary;
+    private parseWire;
+}
+export {};

package/dist/providers/model-catalog.d.ts

@@ -0,0 +1,141 @@
+/**
+ * lmprice <-> lmctl integration (approved design v2, section 1) -- the pure
+ * model-catalog layer: provider adapters + catalog resolution over an
+ * ALREADY-LOADED dataset snapshot (loading/refresh stays in pricing.ts).
+ *
+ * Identity vs billing route (design review correction #2): the same
+ * normalized model id can have divergent priced offers across sources
+ * (DeepSeek direct vs gateway rows differ ~2x; `:batch` variants share slugs
+ * but price differently). Rows are therefore grouped by adapter-normalized
+ * identity into ONE CatalogModel whose `offers` keep every source-qualified
+ * row; route preference (first-party > litellm > openrouter > manual) picks
+ * the winning row, never a reconciled average.
+ *
+ * Resolution order in resolveModel() (design section 1, exact):
+ *   1. aliases.json exact hit (also probing `<provider>/<declared>`, since
+ *      the table keys are harness-qualified) -- evidence states honored:
+ *      established/asserted follow standard_slug -> standards[] ->
+ *      catalog_record_id pin; `unresolved` or a null standard_slug is
+ *      TERMINAL (`kimi-code/k3` must never fall through to guessing).
+ *   2. Adapter path: normalize(declared) -> candidate ids -> match rows via
+ *      candidate fields (source_model_id, every path suffix of it -- which
+ *      covers LiteLLM route prefixes and the last `/`-segment -- and
+ *      gateway_id where present; lowercased).
+ *   3. Miss -> `unknown`.
+ */
+import type { PriceRecord } from "./pricing.js";
+export type ResolutionState = {
+    kind: "priced";
+    model: CatalogModel;
+} | {
+    kind: "known-unpriced";
+    id: string;
+} | {
+    kind: "estimated";
+    model: CatalogModel;
+} | {
+    kind: "unresolved";
+    alias: string;
+} | {
+    kind: "unknown";
+    declared: string;
+} | {
+    kind: "no-catalog";
+};
+export interface CatalogModel {
+    id: string;
+    normalizedId: string;
+    offers: PriceOffer[];
+    contextWindow?: number;
+}
+export interface PriceOffer {
+    route: string;
+    source: string;
+    sourceModelId: string;
+    provider: string | null;
+    pricing: PriceRecord["pricing"];
+    estimated: boolean;
+}
+/**
+ * The dataset record shape the catalog layer reads. Structurally compatible
+ * with pricing.ts's PriceRecord (the extra fields are optional so a slimmed
+ * record still satisfies this), but grounded in lmprice's real published
+ * schema (record_id / provider / mode / gateway_id / context_window).
+ */
+export interface CatalogRecord {
+    record_id?: string | null;
+    source: string;
+    source_model_id: string;
+    provider?: string | null;
+    mode?: string | null;
+    gateway_id?: string | null;
+    pricing: PriceRecord["pricing"];
+    context_window?: {
+        input_tokens?: number | null;
+    } | null;
+}
+export interface CatalogDataLike {
+    records: CatalogRecord[];
+}
+export type AliasEvidence = "established" | "asserted" | "unresolved";
+export interface AliasStandard {
+    standard_slug: string;
+    display_name?: string | null;
+    vendor?: string | null;
+    catalog_record_id: string | null;
+    note?: string | null;
+}
+export interface AliasEntry {
+    alias: string;
+    standard_slug: string | null;
+    evidence: AliasEvidence;
+    source_url?: string | null;
+    note?: string | null;
+}
+export interface AliasTable {
+    schema_version: number;
+    standards: AliasStandard[];
+    aliases: AliasEntry[];
+}
+/**
+ * Design section 1 sketches `matchRow(record)`; the implemented signature
+ * takes the normalized candidate ids as a second argument because matching
+ * is candidates-vs-row-candidate-fields, not a bare regex on the raw id
+ * (review correction #3).
+ */
+export interface ProviderAdapter {
+    matchRow(record: CatalogRecord, candidates: readonly string[]): boolean;
+    normalize(declared: string): string[];
+    isChatModel(record: CatalogRecord): boolean;
+    /** Family + capability membership WITHOUT a candidate check (catalog stats). */
+    coversRecord(record: CatalogRecord): boolean;
+}
+/**
+ * Providers WITHOUT adapters are skipped (`no-catalog`): copilot, opencode,
+ * pi, dsh, lmplayer. dsh/opencode models can still resolve via the aliases
+ * table, which is consulted BEFORE the adapter check.
+ */
+export declare const PROVIDER_ADAPTERS: Record<string, ProviderAdapter>;
+/**
+ * Resolve one declared model string for one provider against a loaded
+ * catalog snapshot + alias table. Pure; never throws; no I/O.
+ */
+export declare function resolveModel(provider: string, declared: string, data: CatalogDataLike | null, aliases: AliasTable | null): ResolutionState;
+export interface OfferResolution {
+    state: ResolutionState;
+    /** The offer to price at when the state is priced/estimated, else null. */
+    offer: PriceOffer | null;
+    /**
+     * How the offer was selected: the alias table's catalog_record_id pin
+     * when resolution came through aliases, route preference
+     * (first-party > litellm > openrouter > manual, first with rates) otherwise.
+     */
+    provenance: "alias-pin" | "route-preference" | null;
+}
+export declare function resolveOfferForCost(provider: string, declared: string, data: CatalogDataLike | null, aliases: AliasTable | null): OfferResolution;
+/**
+ * Count of distinct model identities a provider's adapter covers in this
+ * catalog -- the "(N known)" in lint/seed's unknown-model warning. `null`
+ * when the provider has no adapter.
+ */
+export declare function catalogKnownModelCount(data: CatalogDataLike, provider: string): number | null;

package/dist/providers/one-shot-timeout.d.ts

@@ -0,0 +1 @@
+export declare function getOneShotTimeoutMs(env?: NodeJS.ProcessEnv): number;

package/dist/providers/opencode-config.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Opencode `.opencode/opencode.json` permission writer.
+ *
+ * **YOLO contract via config** (`permission: "allow"`).
+ *
+ * Opencode's ACP mode does NOT accept the `--dangerously-skip-permissions`
+ * argv flag (it's `run`-subcommand-only — empirically verified, see commit
+ * log around the opencode06 incident). The only way to satisfy lmctl's
+ * YOLO contract for opencode is via the `permission` key in
+ * opencode.json. Per the opencode schema:
+ *   - shorthand `"allow"` → `{ "*": "allow" }` (all tools)
+ *   - object form        → per-tool decisions
+ * We use the shorthand.
+ *
+ * lmctl does NOT inject a provider/model catalog here — models resolve
+ * from opencode's own default catalog (models.dev + provider auth) and
+ * the user's `~/.config/opencode/opencode.json`. We write only
+ * `permission: "allow"`.
+ */
+import type { MemberConfig } from "./config/team-config.js";
+import type { McpExecutableWarningOptions } from "../mcp/path-warning.js";
+export declare const OPENCODE_LMCTL_MCP_TIMEOUT_MS = 86400000;
+export declare function buildOpencodeMcpEntry(): Record<string, unknown>;
+/**
+ * Predicate: is this `permission` value "effectively allow everything"?
+ *
+ * Two equivalent shapes per opencode's schema satisfy lmctl's YOLO
+ * contract:
+ *   - the shorthand string `"allow"`
+ *   - the object form `{ "*": "allow" }` (single wildcard-allow entry)
+ *
+ * Anything else (`"ask"`, `"deny"`, multi-entry objects with mixed
+ * rules, etc.) is a USER OVERRIDE we respect but warn about — turns
+ * may hang waiting on permission prompts opencode would otherwise
+ * auto-approve.
+ */
+export declare function isEffectivelyAllowAll(permission: unknown): boolean;
+export interface OpencodeYoloOverrideFsOps {
+    existsSync(path: string): boolean;
+    readFileSync(path: string, encoding: BufferEncoding): string;
+}
+export declare function opencodeYoloOverrideWarnings(members: MemberConfig[], baseDir: string, fsOps?: OpencodeYoloOverrideFsOps): string[];
+/**
+ * Install or upgrade `<targetDir>/.opencode/opencode.json`.
+ *
+ * What we write:
+ *   - `permission: "allow"` — the YOLO contract for opencode.
+ *
+ * Merge semantics:
+ *   - If the file is missing, write a fresh one with
+ *     `{ permission: "allow" }`.
+ *   - If the file exists, only fill in `permission` when absent;
+ *     a user-supplied permission value is PRESERVED (user override
+ *     wins). Existing user MCP entries are preserved untouched. When
+ *     the user-set value is not effectively allow-all, emit a structured
+ *     `opencode_yolo_override` warning via errorLog so the operator
+ *     knows YOLO isn't in effect.
+ *
+ * Returns true iff the file was written, false if already up-to-date
+ * or skipped due to malformed JSON.
+ */
+export declare function installOpencodeConfig(targetDir: string, _options?: McpExecutableWarningOptions): boolean;