@kodax-ai/kodax 0.7.42 → 0.7.43

package/dist/types-chunks/manager.d-87belpiS.d.ts

@@ -0,0 +1,370 @@
+import { a as McpServerConfig, b as McpServersConfig, M as McpConnectMode } from './config.d-BfJUXxC0.js';
+import { a as CapabilityProvider, C as CapabilityKind, b as CapabilityResult } from './capability.d-3C62G8Eq.js';
+
+type McpCapabilityKind = 'tool' | 'resource' | 'prompt';
+type McpCapabilityRisk = 'read' | 'write' | 'network' | 'exec';
+interface McpCatalogItem {
+    id: string;
+    serverId: string;
+    kind: McpCapabilityKind;
+    name: string;
+    title?: string;
+    summary: string;
+    tags?: string[];
+    risk?: McpCapabilityRisk;
+    annotations?: Record<string, unknown>;
+    cachedAt: string;
+}
+interface McpCapabilityDescriptor extends McpCatalogItem {
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    promptArgsSchema?: unknown;
+    uri?: string;
+    mimeType?: string;
+}
+interface McpServerCatalogSnapshot {
+    serverId: string;
+    items: McpCatalogItem[];
+    descriptors: McpCapabilityDescriptor[];
+    updatedAt: string;
+}
+interface McpCatalogSearchOptions {
+    kind?: McpCapabilityKind;
+    limit?: number;
+}
+declare function defaultMcpCacheDir(): string;
+declare function createMcpCapabilityId(serverId: string, kind: McpCapabilityKind, name: string): string;
+declare function parseMcpCapabilityId(id: string): {
+    serverId: string;
+    kind: McpCapabilityKind;
+    name: string;
+};
+declare function searchMcpCatalog(items: readonly McpCatalogItem[], query: string, options?: McpCatalogSearchOptions): McpCatalogItem[];
+declare function getMcpCachePaths(cacheDir: string, serverId: string): {
+    catalogDir: string;
+    indexPath: string;
+    itemsPath: string;
+};
+
+interface McpServerRuntimeDiagnostics {
+    serverId: string;
+    connect: 'lazy' | 'prewarm' | 'disabled';
+    status: 'idle' | 'connecting' | 'ready' | 'error' | 'disabled';
+    dirty: boolean;
+    lastError?: string;
+    cachedAt?: string;
+    tools: number;
+    resources: number;
+    prompts: number;
+}
+declare class McpServerRuntime {
+    private readonly serverId;
+    private readonly config;
+    private readonly cacheDir;
+    private transport?;
+    private readonly pending;
+    private nextRequestId;
+    private initialized;
+    private connectPromise?;
+    private catalog?;
+    private diagnostics;
+    constructor(serverId: string, config: McpServerConfig, cacheDir: string);
+    getDiagnostics(): McpServerRuntimeDiagnostics;
+    prewarmIfNeeded(): Promise<void>;
+    /** Load catalog from memory or disk only — never triggers a lazy connection. */
+    getCachedCatalog(): Promise<McpServerCatalogSnapshot | undefined>;
+    getCatalog(forceRefresh?: boolean): Promise<McpServerCatalogSnapshot>;
+    describeCapability(capabilityId: string): Promise<McpCapabilityDescriptor | undefined>;
+    callTool(name: string, args: Record<string, unknown>): Promise<{
+        content?: string;
+        structuredContent?: unknown;
+        metadata?: Record<string, unknown>;
+    }>;
+    readResource(name: string, options: Record<string, unknown>): Promise<{
+        content?: string;
+        structuredContent?: unknown;
+        metadata?: Record<string, unknown>;
+    }>;
+    getPrompt(name: string, args: Record<string, unknown>): Promise<unknown>;
+    refreshCatalog(forceReconnect?: boolean): Promise<void>;
+    /** Public teardown — clears everything including the connect lock. */
+    dispose(): Promise<void>;
+    /** Internal transport teardown — does NOT clear connectPromise so the
+     *  retry loop inside doConnect() can safely call it between attempts. */
+    private resetTransport;
+    private connect;
+    private doConnect;
+    private listDescriptors;
+    private request;
+    private notify;
+    private handleMessage;
+    private failPending;
+    private applyCatalogSnapshot;
+}
+
+/**
+ * `McpCapabilityProvider` — implements the Layer A `CapabilityProvider`
+ * contract for an MCP server fleet.
+ *
+ * FEATURE_082 (v0.7.24): moved from
+ * `@kodax-ai/coding/src/capabilities/providers/mcp/provider.ts` to this package.
+ * The coding-specific `registerConfiguredMcpCapabilityProvider` adapter (which
+ * pulls in `KodaXExtensionRuntime`) lives in
+ * `@kodax-ai/coding/src/capabilities/providers/mcp-adapter.ts`.
+ */
+
+interface McpProviderOptions {
+    cacheDir?: string;
+}
+declare class McpCapabilityProvider implements CapabilityProvider {
+    readonly id = "mcp";
+    readonly kinds: CapabilityProvider['kinds'];
+    private readonly runtimes;
+    private readonly cacheDir;
+    /**
+     * Construct an MCP capability provider.
+     *
+     * **Cache-dir capture warning (v0.7.35.1 FEATURE_145)** — when
+     * `options.cacheDir` is omitted, this constructor resolves
+     * `defaultMcpCacheDir()` ONCE at instantiation time and threads the
+     * result into every `McpServerRuntime` it spawns. If a substrate
+     * consumer plans to redirect the agent config home via
+     * `setAgentConfigHome()` from `@kodax-ai/agent`, that call MUST happen
+     * BEFORE constructing this provider. Late calls have no effect on
+     * already-constructed runtimes.
+     *
+     * To bypass the agent-home resolver entirely, pass
+     * `options.cacheDir` explicitly — that path wins unconditionally.
+     */
+    constructor(servers: McpServersConfig | undefined, options?: McpProviderOptions);
+    hasActiveServers(): boolean;
+    /**
+     * v0.7.42 — read-only accessor for the enabled server id list.
+     * Used by {@link McpManager} to drive popout-shape `listServers /
+     * startServer / stopServer / logs / tools` operations without
+     * exposing the internal runtimes Map.
+     */
+    getServerIds(): readonly string[];
+    /**
+     * v0.7.42 — single-server runtime accessor. Returns `undefined`
+     * for unknown / disabled servers. Use {@link McpManager} for
+     * higher-level lifecycle control.
+     */
+    getRuntime(serverId: string): McpServerRuntime | undefined;
+    prewarm(): Promise<void>;
+    search(query: string, options?: {
+        kind?: CapabilityKind;
+        limit?: number;
+        server?: string;
+    }): Promise<unknown[]>;
+    describe(id: string): Promise<unknown>;
+    execute(id: string, input: Record<string, unknown>): Promise<CapabilityResult>;
+    read(id: string, options?: Record<string, unknown>): Promise<CapabilityResult>;
+    getPrompt(id: string, args?: Record<string, unknown>): Promise<unknown>;
+    getPromptContext(): Promise<string | undefined>;
+    getDiagnostics(): Record<string, unknown> | undefined;
+    refresh(): Promise<void>;
+    dispose(): Promise<void>;
+    private collectCatalogItems;
+    private listServerDiagnostics;
+    private requireRuntime;
+}
+
+interface McpTransportEvents {
+    /** Called with a complete JSON-RPC message (raw JSON string). */
+    onMessage(raw: string): void;
+    onError(error: Error): void;
+    onClose(reason: string): void;
+}
+interface McpTransport {
+    open(events: McpTransportEvents): Promise<void>;
+    /** Send a JSON string. The transport handles framing. */
+    send(json: string): Promise<void>;
+    close(): Promise<void>;
+    readonly connected: boolean;
+}
+type StdioFraming = 'content-length' | 'ndjson';
+interface McpTransportOptions {
+    stdioFraming?: StdioFraming;
+}
+declare function createMcpTransport(config: McpServerConfig, options?: McpTransportOptions): McpTransport;
+
+/**
+ * McpManager — v0.7.42 (extends FEATURE_186 MCP popout surface).
+ *
+ * `McpCapabilityProvider` (`./provider.ts`) is the capability-provider-
+ * shaped object KodaX uses internally to plug MCP into the agent runtime
+ * — its public methods are `search` / `describe` / `execute` / `read` /
+ * `getPrompt` / `getDiagnostics` / `refresh` / `dispose`, which is the
+ * shape the substrate consumes but NOT the shape a popout UI wants.
+ *
+ * KodaX Space reported that `@kodax-ai/kodax/mcp` only exposed "types +
+ * helpers, no manager-shape API" — concretely they wanted a thin
+ * `listServers / startServer / stopServer / getServerLogs / listTools`
+ * surface to drive a popout panel:
+ *
+ *   - One row per configured MCP server with live status
+ *   - "Start" / "Stop" buttons that map to refreshCatalog(true) / dispose
+ *   - Server logs (last error + status) so users can debug failures
+ *   - Per-server tool list (filtered descriptors) for the "what does
+ *     this MCP server expose" pane
+ *
+ * `McpManager` is the thin wrapper. It owns one `McpCapabilityProvider`
+ * instance internally, so all the existing lifecycle invariants
+ * (cache-dir capture, refresh, dispose, server-config validation) are
+ * preserved verbatim. The capability-provider-shaped methods stay
+ * available via `manager.provider()` as an escape hatch.
+ *
+ * Trust boundary: same as the rest of FEATURE_186 — KodaX is a
+ * single-user CLI, last-write-wins on the server-config-vs-active-
+ * runtime path; a Space popout that swaps configs hot would still need
+ * to construct a fresh `McpManager` (or call `dispose()` then
+ * `createMcpManager` again) to pick up the new wire.
+ */
+
+interface McpServerStatus {
+    readonly serverId: string;
+    readonly config: McpServerConfig;
+    readonly connect: McpConnectMode;
+    readonly status: McpServerRuntimeDiagnostics['status'];
+    readonly tools: number;
+    readonly resources: number;
+    readonly prompts: number;
+    readonly dirty: boolean;
+    readonly cachedAt?: string;
+    readonly lastError?: string;
+}
+interface McpServerLogs {
+    readonly serverId: string;
+    readonly status: McpServerRuntimeDiagnostics['status'];
+    readonly connect: McpConnectMode;
+    readonly lastError?: string;
+    readonly cachedAt?: string;
+}
+interface McpServerToolList {
+    readonly serverId: string;
+    readonly tools: readonly McpCapabilityDescriptor[];
+    readonly cachedAt?: string;
+}
+/**
+ * Full catalog snapshot for a server — tools + resources + prompts.
+ * Use {@link McpManager.getCatalog} when the popout needs to render
+ * all three capability kinds (not just tools).
+ *
+ * `cachedAt` matches the naming used by {@link McpServerStatus},
+ * {@link McpServerLogs}, and {@link McpServerToolList} for consistency
+ * across the manager surface (all are renames of the underlying
+ * `McpServerCatalogSnapshot.updatedAt` field).
+ */
+interface McpServerCatalog {
+    readonly serverId: string;
+    readonly items: readonly McpCatalogItem[];
+    readonly descriptors: readonly McpCapabilityDescriptor[];
+    readonly cachedAt: string;
+}
+/**
+ * Manager-shape facade over {@link McpCapabilityProvider}. Construct
+ * via the {@link createMcpManager} factory or `new McpManager(...)`
+ * directly.
+ */
+declare class McpManager {
+    private readonly capabilityProvider;
+    private readonly serversConfig;
+    constructor(servers: McpServersConfig | undefined, options?: McpProviderOptions);
+    /**
+     * Escape hatch — returns the underlying {@link McpCapabilityProvider}
+     * for callers that need the search / describe / execute / read /
+     * getPrompt API (e.g. embedding into a custom agent runtime).
+     */
+    provider(): McpCapabilityProvider;
+    /**
+     * One status row per configured server (lazy / prewarm / disabled
+     * all included). Returned objects are plain readonly snapshots —
+     * mutating them does NOT affect runtime state.
+     */
+    listServers(): McpServerStatus[];
+    /**
+     * Force a connection + catalog refresh for `serverId`. Returns the
+     * post-start status row. Throws if `serverId` is not configured.
+     *
+     * For lazy servers, this is the explicit "connect now" trigger —
+     * useful when a popout user clicks "Start" before any tool call has
+     * forced the lazy connection.
+     */
+    startServer(serverId: string): Promise<McpServerStatus>;
+    /**
+     * Disconnect `serverId` — closes the transport, drops the pending
+     * request queue, but keeps the server in the config so a subsequent
+     * `startServer` / `listTools` can reconnect. Returns the post-stop
+     * status (`status: 'idle'`).
+     */
+    stopServer(serverId: string): Promise<McpServerStatus>;
+    /**
+     * Return the most recent runtime diagnostic envelope for `serverId`
+     * — status, last error, last cached timestamp. Designed as the data
+     * source for a popout "Logs" pane.
+     *
+     * Logs API is intentionally conservative in v0.7.42: only the last
+     * error message + status are exposed. A future iteration may add a
+     * ring buffer of recent events; the field shape will extend (add
+     * fields), never break (rename / remove).
+     */
+    getServerLogs(serverId: string): McpServerLogs;
+    /**
+     * Return the tool descriptors for `serverId`. Triggers a lazy
+     * connect + catalog fetch if the catalog has not yet been built;
+     * pass `{ forceRefresh: true }` to force a fresh catalog regardless
+     * of cache state.
+     *
+     * Only `kind === 'tool'` descriptors are returned (filters out
+     * resources + prompts so popout consumers can render a clean
+     * "tools" table). Use the underlying `provider().describe(id)` for
+     * full descriptor introspection including resources + prompts.
+     */
+    listTools(serverId: string, options?: {
+        forceRefresh?: boolean;
+    }): Promise<McpServerToolList>;
+    /**
+     * Return the full catalog snapshot for `serverId` — every tool,
+     * resource, and prompt the server exposes — plus lightweight catalog
+     * items for menu rendering. `listTools` is the tools-only fast path;
+     * use this when the popout needs to render resources / prompts panes
+     * alongside tools.
+     *
+     * Triggers a lazy connect + catalog fetch if the catalog has not yet
+     * been built; pass `{ forceRefresh: true }` to force a fresh catalog
+     * regardless of cache state.
+     */
+    getCatalog(serverId: string, options?: {
+        forceRefresh?: boolean;
+    }): Promise<McpServerCatalog>;
+    /**
+     * Dispose all runtimes. After calling, the manager is no longer
+     * usable for `startServer` / `listTools` (they would reconnect, but
+     * the consumer should construct a fresh manager instead).
+     */
+    dispose(): Promise<void>;
+    /** v0.7.42 — escape hatch for advanced uses; usually consumers use the typed methods above. */
+    search(query: string, options?: {
+        kind?: CapabilityKind;
+        limit?: number;
+        server?: string;
+    }): Promise<readonly McpCatalogItem[]>;
+    /** v0.7.42 — escape hatch for advanced uses; usually consumers use {@link listTools}. */
+    describe(id: string): Promise<McpCapabilityDescriptor | undefined>;
+    /** v0.7.42 — invoke a tool by capability id (`mcp://<serverId>/<kind>/<name>`). */
+    execute(id: string, input: Record<string, unknown>): Promise<CapabilityResult>;
+    /** v0.7.42 — read a resource by capability id. */
+    read(id: string, options?: Record<string, unknown>): Promise<CapabilityResult>;
+    private requireRuntime;
+    private buildStatus;
+}
+/**
+ * Convenience factory matching the rest of the FEATURE_186 surface
+ * naming (`createSessionControl`, etc.). Equivalent to
+ * `new McpManager(servers, options)`.
+ */
+declare function createMcpManager(servers: McpServersConfig | undefined, options?: McpProviderOptions): McpManager;
+
+export { McpCapabilityProvider as b, McpManager as e, McpServerRuntime as j, createMcpCapabilityId as p, createMcpManager as q, createMcpTransport as r, defaultMcpCacheDir as s, getMcpCachePaths as t, parseMcpCapabilityId as u, searchMcpCatalog as v };
+export type { McpCapabilityDescriptor as M, McpCapabilityKind as a, McpCapabilityRisk as c, McpCatalogItem as d, McpProviderOptions as f, McpServerCatalog as g, McpServerCatalogSnapshot as h, McpServerLogs as i, McpServerRuntimeDiagnostics as k, McpServerStatus as l, McpServerToolList as m, McpTransport as n, McpTransportEvents as o };

package/dist/types-chunks/{resolver.d-DX9au4NJ.d.ts → resolver.d-CA68_NeH.d.ts}

@@ -1,6 +1,6 @@
-import { D as KodaXReasoningMode, U as KodaXThinkingBudgetMap, V as KodaXThinkingDepth, r as KodaXProviderConfig, C as KodaXReasoningCapability, F as KodaXReasoningRequest, Q as KodaXTaskType, E as KodaXReasoningOverride, X as KodaXToolDefinition, m as KodaXMessage, z as KodaXProviderStreamOptions, J as KodaXStreamResult, q as KodaXProviderCapabilityProfile, h as KodaXCustomProviderConfig } from './types.d-B1uGoVTE.js';
+import { D as KodaXReasoningMode, U as KodaXThinkingBudgetMap, V as KodaXThinkingDepth, r as KodaXProviderConfig, C as KodaXReasoningCapability, F as KodaXReasoningRequest, Q as KodaXTaskType, E as KodaXReasoningOverride, X as KodaXToolDefinition, m as KodaXMessage, z as KodaXProviderStreamOptions, J as KodaXStreamResult, n as KodaXModelDescriptor, q as KodaXProviderCapabilityProfile, h as KodaXCustomProviderConfig } from './types.d-B1uGoVTE.js';
 import Anthropic from '@anthropic-ai/sdk';
-import { K as KodaXBaseProvider } from './cost-tracker.d-B6vMoLLF.js';
+import { K as KodaXBaseProvider } from './base.d-FUJahC0i.js';
 import OpenAI from 'openai';
 
 /**
@@ -155,13 +155,41 @@ declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
  */
 
 type ProviderName = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'kimi-code' | 'qwen' | 'zhipu' | 'zhipu-coding' | 'minimax-coding' | 'mimo-coding' | 'ark-coding' | 'gemini-cli' | 'codex-cli';
+/**
+ * Per-provider static metadata. v0.7.43 — promoted from a partial
+ * descriptor (`models: string[]`) to the full capability surface so
+ * SDK consumers can read context windows / max output tokens /
+ * thinking-budget caps / per-model descriptors without instantiating
+ * a Provider class (which previously required a valid API key just
+ * to read static metadata — architectural mismatch).
+ *
+ * This map is now the single source of truth for capability data;
+ * Provider classes derive their runtime `config` from it via
+ * `buildProviderConfig`.
+ */
 type ProviderSnapshot = {
     model: string;
-    models?: readonly string[];
+    /**
+     * Alternative model descriptors beyond the default `model`. Carries
+     * per-model capability overrides (`contextWindow` / `maxOutputTokens` /
+     * `thinkingBudgetCap` / `reasoningCapability` / `replayReasoningContent` /
+     * `strictThinkingSignature`). Provider-level defaults below fill any
+     * gaps a descriptor leaves unset. The default model has no descriptor
+     * entry — it inherits provider-level defaults directly.
+     */
+    models?: readonly KodaXModelDescriptor[];
     apiKeyEnv: string;
     reasoningCapability: KodaXReasoningCapability;
     modelReasoningCapabilities?: Partial<Record<string, KodaXReasoningCapability>>;
     capabilityProfile: KodaXProviderCapabilityProfile;
+    /** Maximum input context window (tokens). Provider-level default. */
+    contextWindow?: number;
+    /** Per-turn output token cap KodaX requests. Provider-level default. */
+    maxOutputTokens?: number;
+    /** Upper bound on `thinking_budget` for native-budget reasoning providers. */
+    thinkingBudgetCap?: number;
+    /** Whether the provider supports `thinking_budget` / native reasoning. */
+    supportsThinking?: boolean;
 };
 declare const KODAX_PROVIDER_SNAPSHOTS: Record<ProviderName, ProviderSnapshot>;
 declare const KODAX_PROVIDERS: Record<string, () => KodaXBaseProvider>;
@@ -181,6 +209,82 @@ declare function getProviderList(): Array<{
 }>;
 declare function getProviderModels(name: string): string[];
 declare function isProviderName(name: string): name is ProviderName;
+/**
+ * Effective per-model capability surface. v0.7.43 SDK exposure.
+ *
+ * Values are resolved with the cascade:
+ *   1. Per-model descriptor override (`KodaXModelDescriptor` field)
+ *   2. Provider-level default (`KODAX_PROVIDER_SNAPSHOTS[name].*`)
+ *   3. `undefined` (the field is genuinely not advertised for this model)
+ *
+ * `displayName` falls back to `id` when not set; never undefined.
+ *
+ * **All fields below are KodaX-maintained values** — they reflect what
+ * KodaX itself uses at runtime (the per-turn `max_tokens` we request,
+ * the thinking budget we cap at, etc.), benchmarked against the upstream
+ * model so they are honest representations of the agent's behavior. They
+ * are deliberately NOT sourced from upstream `/models` API responses,
+ * which a 2026-05 cross-provider probe confirmed are sparse and often
+ * empty (see docs/SDK_EMBEDDER_GUIDE.md §9). Embedders showing these
+ * values in a popout UI can trust them.
+ */
+interface KodaXModelCapabilities {
+    /** Provider name (`anthropic`, `kimi`, `ark-coding`, or any custom name). */
+    provider: string;
+    /** Model id (the value `runKodaX(... { model } ...)` accepts). */
+    model: string;
+    /** Human-readable label — falls back to `model` when no descriptor entry. */
+    displayName: string;
+    /** Whether the provider supports `thinking_budget` / native reasoning. */
+    supportsThinking: boolean;
+    /** Effective reasoning capability for THIS model (per-model override aware). */
+    reasoningCapability: KodaXReasoningCapability;
+    /** Maximum input context window (tokens). `undefined` for CLI-bridge providers. */
+    contextWindow?: number;
+    /**
+     * Per-turn `max_tokens` KodaX requests. KodaX-side decision —
+     * benchmarked against each provider (kill-windows, decode rate, cost
+     * predictability). NOT the upstream "theoretical maximum" — providers
+     * often advertise inflated ceilings; this value reflects what KodaX
+     * actually asks for. If you display "expected output size" in your UI,
+     * use this. Long generations escalate through the L5 continuation
+     * meta path, not by raising this number per-turn.
+     */
+    maxOutputTokens?: number;
+    /** Upper bound on `thinking_budget` (native-budget providers only). */
+    thinkingBudgetCap?: number;
+    /** True when the model is the provider's default (the `model` field on the snapshot). */
+    isDefault: boolean;
+}
+/**
+ * List all model descriptors for a built-in provider — default model first,
+ * then alternatives. No API key required (reads from KODAX_PROVIDER_SNAPSHOTS).
+ *
+ * Returns an empty array for unknown provider names so SDK consumers can
+ * iterate `[...KODAX_PROVIDER_LIST, ...customNames]` without a guard per name.
+ */
+declare function getProviderModelDescriptors(name: string): KodaXModelDescriptor[];
+/**
+ * Effective per-model capability surface for a built-in provider. Returns
+ * `undefined` for unknown provider name or unknown model under a known
+ * provider — caller should fall back to `DEFAULT_CONTEXT_WINDOW` from
+ * `@kodax-ai/kodax/agent` when nothing is advertised.
+ *
+ * No API key required.
+ */
+declare function getModelCapabilities(providerName: string, modelId: string): KodaXModelCapabilities | undefined;
+/**
+ * Full capability listing for every built-in provider/model pair. Default
+ * model comes first per provider, in the order providers appear in
+ * `KODAX_PROVIDERS`. Use this for popout UIs that enumerate all models
+ * without filtering by `configured` (the consumer can filter post-hoc by
+ * checking `process.env[snapshot.apiKeyEnv]` themselves, or just present
+ * everything for selection).
+ *
+ * Custom-provider models are exposed via the equivalent helper in
+ * `custom-registry.ts` (`getCustomProviderModelCapabilities`).
+ */
+declare function listBuiltinModelCapabilities(): KodaXModelCapabilities[];
 
 /**
  * Custom Provider Factory
@@ -230,6 +334,25 @@ declare function getCustomProviderList(): Array<{
  * Returns undefined if not a custom provider.
  */
 declare function getCustomProviderModels(name: string): string[] | undefined;
+/**
+ * List all model descriptors for a custom provider. Default model first,
+ * then alternatives. Returns undefined when the name doesn't match any
+ * registered custom provider — caller can fall through to the built-in
+ * `getProviderModelDescriptors`.
+ */
+declare function getCustomProviderModelDescriptors(name: string): KodaXModelDescriptor[] | undefined;
+/**
+ * Effective per-model capability surface for a custom provider. Returns
+ * undefined when the provider name is not a registered custom provider,
+ * OR when the model id doesn't appear under that provider. The same
+ * descriptor-then-provider cascade as the built-in counterpart.
+ */
+declare function getCustomModelCapabilities(providerName: string, modelId: string): KodaXModelCapabilities | undefined;
+/**
+ * Full capability listing for every registered custom provider / model.
+ * Mirrors `listBuiltinModelCapabilities`. Default model first per provider.
+ */
+declare function listCustomProviderModelCapabilities(): KodaXModelCapabilities[];
 
 type ModelProviderFactory = () => KodaXBaseProvider;
 declare function registerModelProvider(name: string, factory: ModelProviderFactory): () => void;
@@ -258,6 +381,27 @@ declare function isKnownProvider(name: string): boolean;
  * Get all available provider names (built-in + custom).
  */
 declare function getAvailableProviderNames(): string[];
+/**
+ * Model descriptors for any registered provider (built-in or custom).
+ * Default model first, then alternatives. Empty array if name unknown.
+ */
+declare function resolveProviderModelDescriptors(name: string): KodaXModelDescriptor[];
+/**
+ * Effective capabilities for a single provider/model pair. Built-in
+ * lookup first, then custom. Returns undefined when neither has it.
+ */
+declare function resolveModelCapabilities(providerName: string, modelId: string): KodaXModelCapabilities | undefined;
+/**
+ * Every model capability KodaX knows about — built-in + custom — in
+ * a single flat list. Built-in providers come first (in `KODAX_PROVIDERS`
+ * declaration order), then custom providers (in registration order).
+ * Within each provider, default model first.
+ *
+ * Use for popout UIs that need a single source for a model picker.
+ * No filtering by `configured` — consumers can subset themselves by
+ * checking `process.env[snapshot.apiKeyEnv]` if they care.
+ */
+declare function listAllModelCapabilities(): KodaXModelCapabilities[];
 
-export { getProviderList as A, getProviderModel as B, getProviderModels as C, getReasoningCapability as D, getRuntimeModelProvider as E, getRuntimeModelProviderNames as F, isCustomProviderName as G, isKnownProvider as H, isProviderConfigured as I, isProviderName as J, KODAX_DEFAULT_PROVIDER as K, isReasoningEnabled as L, isRuntimeModelProviderName as M, loadReasoningOverride as N, mapDepthToOpenAIReasoningEffort as O, normalizeReasoningRequest as Q, reasoningCapabilityToOverride as R, reasoningOverrideToCapability as S, registerCustomProviders as T, registerModelProvider as U, resolveProvider as V, resolveThinkingBudget as W, saveReasoningOverride as X, validateCustomProviderConfig as Y, KODAX_DEFAULT_THINKING_BUDGETS as a, KODAX_PROVIDERS as b, KODAX_PROVIDER_SNAPSHOTS as c, KODAX_REASONING_MODE_SEQUENCE as d, KODAX_REASONING_SAFETY_RESERVE as e, KodaXAnthropicCompatProvider as f, KodaXError as g, KodaXNetworkError as h, KodaXOpenAICompatProvider as i, KodaXProviderError as j, KodaXRateLimitError as k, KodaXToolCallIdError as l, buildReasoningOverrideKey as m, clampThinkingBudget as n, clearReasoningOverride as o, clearRuntimeModelProviders as p, createCustomProvider as q, getAvailableProviderNames as r, getCustomProvider as s, getCustomProviderList as t, getCustomProviderModels as u, getCustomProviderNames as v, getDefaultThinkingDepthForMode as w, getProvider as x, getProviderConfiguredCapabilityProfile as y, getProviderConfiguredReasoningCapability as z };
-export type { ProviderName as P };
+export { registerCustomProviders as $, getModelCapabilities as A, getProvider as B, getProviderConfiguredCapabilityProfile as C, getProviderConfiguredReasoningCapability as D, getProviderList as E, getProviderModel as F, getProviderModelDescriptors as G, getProviderModels as H, getReasoningCapability as I, getRuntimeModelProvider as J, KODAX_DEFAULT_PROVIDER as K, getRuntimeModelProviderNames as L, isCustomProviderName as M, isKnownProvider as N, isProviderConfigured as O, isProviderName as Q, isReasoningEnabled as R, isRuntimeModelProviderName as S, listAllModelCapabilities as T, listBuiltinModelCapabilities as U, listCustomProviderModelCapabilities as V, loadReasoningOverride as W, mapDepthToOpenAIReasoningEffort as X, normalizeReasoningRequest as Y, reasoningCapabilityToOverride as Z, reasoningOverrideToCapability as _, KODAX_DEFAULT_THINKING_BUDGETS as a, registerModelProvider as a0, resolveModelCapabilities as a1, resolveProvider as a2, resolveProviderModelDescriptors as a3, resolveThinkingBudget as a4, saveReasoningOverride as a5, validateCustomProviderConfig as a6, KODAX_PROVIDERS as b, KODAX_PROVIDER_SNAPSHOTS as c, KODAX_REASONING_MODE_SEQUENCE as d, KODAX_REASONING_SAFETY_RESERVE as e, KodaXAnthropicCompatProvider as f, KodaXError as g, KodaXNetworkError as i, KodaXOpenAICompatProvider as j, KodaXProviderError as k, KodaXRateLimitError as l, KodaXToolCallIdError as m, buildReasoningOverrideKey as n, clampThinkingBudget as o, clearReasoningOverride as p, clearRuntimeModelProviders as q, createCustomProvider as r, getAvailableProviderNames as s, getCustomModelCapabilities as t, getCustomProvider as u, getCustomProviderList as v, getCustomProviderModelDescriptors as w, getCustomProviderModels as x, getCustomProviderNames as y, getDefaultThinkingDepthForMode as z };
+export type { ProviderName as P, KodaXModelCapabilities as h };

package/dist/types-chunks/{session-storage.d-Cci897iM.d.ts → storage.d-DPAEX7zS.d.ts}

@@ -1,4 +1,4 @@
-import { k as KodaXSessionData, o as KodaXSessionLineage, r as KodaXSessionNavigationOptions, s as KodaXSessionRuntimeInfo } from './types.d-mM8vqvhT.js';
+import { k as KodaXSessionData, o as KodaXSessionLineage, r as KodaXSessionNavigationOptions, s as KodaXSessionRuntimeInfo, u as KodaXSessionStorage } from './types.d-mM8vqvhT.js';
 
 /**
  * Session Storage - Session storage abstraction layer
@@ -64,5 +64,52 @@ declare class MemorySessionStorage implements SessionStorage {
 }
 declare function createMemorySessionStorage(): SessionStorage;
 
-export { MemorySessionStorage as M, createMemorySessionStorage as c };
+/**
+ * KodaX session storage - filesystem implementation.
+ */
+
+declare class FileSessionStorage implements KodaXSessionStorage {
+    private readonly sessionsDir;
+    constructor(opts?: {
+        sessionsDir?: string;
+    });
+    private writeQueues;
+    private serializedWrite;
+    private appendState;
+    /** Update watermarks. Only overwrites fields the caller actually provided. */
+    private syncAppendState;
+    private getSessionFilePath;
+    private getArchiveFilePath;
+    private readSession;
+    private writeSessionInternal;
+    private mergeAndWriteInternal;
+    appendSessionDelta(id: string, data: SessionData): Promise<void>;
+    private shouldRunMaintenance;
+    private runMaintenance;
+    save(id: string, data: SessionData): Promise<void>;
+    load(id: string): Promise<SessionData | null>;
+    getLineage(id: string): Promise<KodaXSessionLineage | null>;
+    setActiveEntry(id: string, selector: string, options?: {
+        summarizeCurrentBranch?: boolean;
+    }): Promise<SessionData | null>;
+    rewind(id: string, selector?: string): Promise<SessionData | null>;
+    setLabel(id: string, selector: string, label?: string): Promise<SessionData | null>;
+    fork(id: string, selector?: string, options?: {
+        sessionId?: string;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+        data: SessionData;
+    } | null>;
+    list(gitRoot?: string): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+        runtimeInfo?: KodaXSessionRuntimeInfo;
+    }>>;
+    delete(id: string): Promise<void>;
+    deleteAll(gitRoot?: string): Promise<void>;
+}
+
+export { FileSessionStorage as F, MemorySessionStorage as M, createMemorySessionStorage as c };
 export type { SessionData as S, SessionStorage as a };