@kodax-ai/kodax 0.7.62 → 0.7.66

package/dist/types-chunks/commands.d-C3B1TdGM.d.ts

@@ -0,0 +1,213 @@
+import { h as SessionStorage$1, f as PermissionMode } from './public-api.d-jtREVfEq.js';
+import { X as KodaXOptions, a5 as KodaXResult } from './bash-prefix-extractor.d-BjkITAva.js';
+import { m as RuntimeSurfaceStatus, b as CommandDefinition, e as CommandSource, c as CommandInfo, C as Command$1, I as InteractiveContext, a as CommandCallbacks, g as CurrentConfig, d as CommandInvocationRequest, f as CommandWorkflowInvocationRequest } from './utils.d-C1rpoeDh.js';
+import { am as KodaXSessionStorage, aa as KodaXSessionData } from './process.d-CY2g03Mb.js';
+
+/**
+ * InkREPL - Ink-based REPL Adapter
+ *
+ * Bridges Ink UI components with existing KodaX command processing logic.
+ * Replaces the Node.js readline-based input with Ink's React components.
+ *
+ * Architecture based on Gemini CLI:
+ * - Uses UIStateContext for global state
+ * - Uses KeypressContext for priority-based keyboard handling
+ * - Uses StreamingContext for streaming response management
+ */
+
+interface InkRuntimeRunnerInput {
+    readonly options: KodaXOptions;
+    readonly prompt: string;
+    readonly sessionId: string;
+    readonly permissionMode: PermissionMode;
+}
+type InkRuntimeRunner = (input: InkRuntimeRunnerInput) => Promise<KodaXResult>;
+type InkRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
+interface InkREPLOptions extends KodaXOptions {
+    storage?: SessionStorage$1;
+    hardExitOnClose?: boolean;
+    runtimeRunner?: InkRuntimeRunner;
+    getRuntimeStatus?: InkRuntimeStatusProvider;
+}
+/**
+ * Run Ink-based interactive mode
+ */
+declare function runInkInteractiveMode(options: InkREPLOptions): Promise<void>;
+
+interface SessionStorage extends KodaXSessionStorage {
+    list(gitRoot?: string): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+        tag?: string;
+        runtimeInfo?: KodaXSessionData['runtimeInfo'];
+    }>>;
+}
+interface ReplRuntimeRunnerInput {
+    readonly options: KodaXOptions;
+    readonly prompt: string;
+    readonly sessionId: string;
+    readonly permissionMode: PermissionMode;
+}
+type ReplRuntimeRunner = (input: ReplRuntimeRunnerInput) => Promise<KodaXResult>;
+type ReplRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
+interface RepLOptions extends KodaXOptions {
+    storage?: SessionStorage;
+    runtimeRunner?: ReplRuntimeRunner;
+    getRuntimeStatus?: ReplRuntimeStatusProvider;
+}
+declare function runInteractiveMode(options: RepLOptions): Promise<void>;
+declare function processSpecialSyntax(input: string): Promise<string>;
+
+/**
+ * Command Registry - Dynamic command registration system
+ * 命令注册表 - 动态命令注册系统
+ *
+ * Provides centralized command management with source tracking,
+ * supporting dynamic registration, lookup, and listing of commands.
+ */
+
+/**
+ * CommandRegistry - Centralized command management
+ * 命令注册表 - 集中式命令管理
+ *
+ * @example
+ * ```typescript
+ * const registry = new CommandRegistry();
+ *
+ * // Register a command
+ * registry.register({
+ *   name: 'copy',
+ *   description: 'Copy last message to clipboard',
+ *   source: 'builtin',
+ *   handler: async (args, context, callbacks, config) => {
+ *     // Implementation
+ *   }
+ * });
+ *
+ * // Get a command
+ * const cmd = registry.get('copy');
+ *
+ * // List all commands
+ * const allCommands = registry.getAll();
+ *
+ * // List builtin commands only
+ * const builtinCommands = registry.getBySource('builtin');
+ * ```
+ */
+declare class CommandRegistry {
+    /**
+     * Internal command storage
+     * 内部命令存储
+     */
+    private commands;
+    /**
+     * Alias to command name mapping
+     * 别名到命令名称的映射
+     */
+    private aliases;
+    /**
+     * Register a command
+     * 注册命令
+     *
+     * @param def - Command definition
+     * @throws Error if command with same name already exists
+     */
+    register(def: CommandDefinition): void;
+    /**
+     * Unregister a command
+     * 注销命令
+     *
+     * @param name - Command name or alias
+     * @returns true if command was unregistered, false if not found
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a command by name or alias
+     * 通过名称或别名获取命令
+     *
+     * @param name - Command name or alias
+     * @returns Command definition or undefined if not found
+     */
+    get(name: string): CommandDefinition | undefined;
+    /**
+     * Check if a command exists
+     * 检查命令是否存在
+     *
+     * @param name - Command name or alias
+     * @returns true if command exists, false otherwise
+     */
+    has(name: string): boolean;
+    /**
+     * Get all commands with optional source filter
+     * 获取所有命令，可选按来源过滤
+     *
+     * @param source - Optional source filter
+     * @returns Array of command information
+     */
+    getAll(source?: CommandSource): CommandInfo[];
+    /**
+     * Get commands by source
+     * 按来源获取命令
+     *
+     * @param source - Command source
+     * @returns Array of command information
+     */
+    getBySource(source: CommandSource): CommandInfo[];
+    /**
+     * Get all command names
+     * 获取所有命令名称
+     *
+     * @returns Array of command names
+     */
+    getNames(): string[];
+    /**
+     * Clear all commands
+     * 清空所有命令
+     */
+    clear(): void;
+    /**
+     * Get command count
+     * 获取命令数量
+     *
+     * @returns Number of registered commands
+     */
+    get size(): number;
+    /**
+     * Get alias count
+     * 获取别名数量
+     *
+     * @returns Number of registered aliases
+     */
+    get aliasCount(): number;
+}
+
+/**
+ * KodaX Interactive Command System
+ */
+
+type Command = Command$1;
+declare const BUILTIN_COMMANDS: Command[];
+declare function getCommandRegistry(projectRoot?: string): CommandRegistry;
+declare function parseCommand(input: string): {
+    command: string;
+    args: string[];
+    skillInvocation?: {
+        name: string;
+    };
+} | null;
+type CommandResult = boolean | {
+    skillContent?: string;
+    invocation?: CommandInvocationRequest;
+    workflow?: CommandWorkflowInvocationRequest;
+};
+declare function executeCommand(parsed: {
+    command: string;
+    args: string[];
+    skillInvocation?: {
+        name: string;
+    };
+}, context: InteractiveContext, callbacks: CommandCallbacks, currentConfig: CurrentConfig): Promise<CommandResult>;
+
+export { BUILTIN_COMMANDS as B, executeCommand as g, getCommandRegistry as h, processSpecialSyntax as i, runInteractiveMode as j, parseCommand as p, runInkInteractiveMode as r };
+export type { Command as C, InkREPLOptions as I, RepLOptions as R, InkRuntimeRunner as a, InkRuntimeRunnerInput as b, InkRuntimeStatusProvider as c, ReplRuntimeRunner as d, ReplRuntimeRunnerInput as e, ReplRuntimeStatusProvider as f };

package/dist/types-chunks/{types.d-DFf4Sfys.d.ts → guardrail.d-C_Siraua.d.ts}

@@ -1,5 +1,4 @@
-import { J as Guardrail, bp as RunnerToolCall, f as Agent, h as AgentMessage, bs as RunnerToolResult, bB as Span, a2 as KodaXInputArtifact } from './process.d-DXkRD7hj.js';
-import { R as KodaXTaskResultMetadata } from './types.d-Bp4Lm1jv.js';
+import { J as Guardrail, bq as RunnerToolCall, f as Agent, h as AgentMessage, bt as RunnerToolResult, bC as Span } from './process.d-CY2g03Mb.js';
 
 /**
  * Guardrail Runtime — FEATURE_085 (v0.7.26).
@@ -152,129 +151,5 @@ declare function runToolBeforeGuardrails(call: RunnerToolCall, guardrails: reado
  */
 declare function runToolAfterGuardrails(call: RunnerToolCall, result: RunnerToolResult, guardrails: readonly ToolGuardrail[], ctx: GuardrailContext, agentSpan: Span | null): Promise<RunnerToolResult>;
 
-/**
- * @kodax-ai/agent/messaging — Message queue types
- *
- * FEATURE_115 (v0.7.36): agentId-scoped 2-tier priority queue infrastructure.
- *
- * Per ADR-021: messaging is a generic agent-platform primitive (not coding-
- * specific). Downstream consumers:
- *   - @kodax-ai/coding runner-driven mid-turn drain
- *   - @kodax-ai/repl InkREPL ESC soft-pause + text injection (FEATURE_111 absorbed)
- *   - subagent task-notification routing (FEATURE_155 idle-yield wakeup)
- *
- * Phase 0.6 study (`c:/tmp/claude-code-actual-usage.md`): Claude Code's
- * `'now'` priority has zero production usage; KodaX simplifies to 2 tiers.
- */
-
-type MessagePriority = 'user' | 'background';
-type MessageMode = 'prompt' | 'task-notification' | 'system-reminder';
-type QueuedInputArtifact = KodaXInputArtifact;
-interface QueuedMessage {
-    /** Stable id for tracing / dedup. Format: `msg-<sequence>`. */
-    readonly id: string;
-    readonly priority: MessagePriority;
-    /**
-     * Routing key:
-     *   undefined = main thread / coordinator agent
-     *   'agent-id-XYZ' = subagent / specific consumer
-     *
-     * Drain consumers MUST filter by agentId match — undefined matches only
-     * undefined-agentId messages, not "any agent".
-     */
-    readonly agentId?: string;
-    readonly mode: MessageMode;
-    readonly content: string;
-    readonly inputArtifacts?: readonly QueuedInputArtifact[];
-    readonly taskResult?: KodaXTaskResultMetadata;
-    /** Wall-clock timestamp (`Date.now()`) for tracing only — not used for ordering. */
-    readonly enqueuedAt: number;
-}
-interface DequeueFilter {
-    /**
-     * Only return messages with this agentId.
-     * undefined matches messages with no agentId (main-thread messages only).
-     */
-    readonly agentId?: string;
-    /**
-     * Highest priority level included in the drain.
-     *   'user'       → only user priority drained, background stays queued
-     *   'background' → both user + background drained (Sleep-gated case)
-     */
-    readonly maxPriority: MessagePriority;
-    /**
-     * Optional cap on number of messages drained in this call.
-     * Defaults to unlimited (drains all matching).
-     */
-    readonly limit?: number;
-    /**
-     * FEATURE_159 (v0.7.40) — optional mode filter. Lets REPL split the
-     * single queue into mode-typed views (e.g. `mode:'prompt'` for user
-     * input vs `mode:'task-notification'` for child completion banners)
-     * without separate queues. When omitted, all modes match.
-     */
-    readonly mode?: MessageMode;
-    /**
-     * FEATURE_159 (v0.7.40) — optional precise-id filter. Single-message
-     * targeted removal — drives Esc-pop-this-uuid in REPL. When set, all
-     * other filters still apply (agentId / priority / mode mismatches still
-     * skip the message), so callers can't accidentally remove a message
-     * outside their scope.
-     */
-    readonly id?: string;
-    /**
-     * FEATURE_159 (v0.7.40) — optional escape-hatch predicate, AND-ed with
-     * the structured filters. Lets SDK consumers express conditions the
-     * typed fields don't cover (e.g. timestamp ranges, content-match) without
-     * forcing every new use case to extend `DequeueFilter`. KodaX-internal
-     * code should prefer the typed fields for readability; this is the
-     * "data-driven main path + predicate escape" pattern.
-     *
-     * Evaluated AFTER the typed filters succeed — so a `predicate` that
-     * inspects `message.content` never runs on messages outside the
-     * caller's `agentId` / `mode` / `id` scope.
-     */
-    readonly predicate?: (message: QueuedMessage) => boolean;
-}
-/**
- * FEATURE_159 (v0.7.40) — structured queue event emitted to subscribers.
- *
- * Replaces the prior `() => void` bare-notify signal. Carries the kind +
- * affected messages so SDK observability consumers (logging, tracing,
- * metrics) can react per-event without re-diffing snapshots.
- *
- * Event granularity rules:
- *   - `enqueued` fires ONCE per `enqueue()` call (always 1 message).
- *   - `dequeued` fires ONCE per `dequeue()` call that removed ≥1 message,
- *     carrying ALL drained messages in priority+FIFO order. No-op drains
- *     (filter matched nothing) fire no event — quiet by design so the
- *     `waitForWakeEvent` 100ms poll doesn't spam idle subscribers.
- *   - `cleared` fires ONCE per `clear()` call that removed ≥1 message,
- *     carrying the pre-clear messages. Empty-queue clear fires nothing.
- *
- * The `useSyncExternalStore` React hook ignores the event payload (it
- * only needs the change signal); SDK / tracer consumers read the event.
- */
-type QueueEvent = {
-    readonly kind: 'enqueued';
-    readonly message: QueuedMessage;
-} | {
-    readonly kind: 'dequeued';
-    readonly messages: readonly QueuedMessage[];
-} | {
-    readonly kind: 'cleared';
-    readonly messages: readonly QueuedMessage[];
-};
-/** FEATURE_159 — `MessageQueue.subscribe` listener signature. */
-type QueueEventListener = (event: QueueEvent) => void;
-interface EnqueueInput {
-    readonly priority: MessagePriority;
-    readonly mode: MessageMode;
-    readonly content: string;
-    readonly agentId?: string;
-    readonly inputArtifacts?: readonly QueuedInputArtifact[];
-    readonly taskResult?: KodaXTaskResultMetadata;
-}
-
-export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as h, runOutputGuardrails as i, runToolAfterGuardrails as j, runToolBeforeGuardrails as k, runInputGuardrails as r };
-export type { DequeueFilter as D, EnqueueInput as E, InputGuardrail as I, MessageMode as M, OutputGuardrail as O, QueueEventListener as Q, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, MessagePriority as d, QueuedInputArtifact as e, QueuedMessage as f, ToolGuardrail as g };
+export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as e, runOutputGuardrails as f, runToolAfterGuardrails as g, runToolBeforeGuardrails as h, runInputGuardrails as r };
+export type { InputGuardrail as I, OutputGuardrail as O, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, ToolGuardrail as d };

package/dist/types-chunks/{guardrail.d-DRp0Lqvx.d.ts → guardrail.d-wk-s0psS.d.ts}

@@ -1,8 +1,8 @@
-import { M as McpConnectMode, a as McpServerConfig, b as McpServersConfig, c as McpTransportKind } from './config.d-CJy1WENT.js';
+import { b as McpServersConfig, M as McpConnectMode, a as McpServerConfig, c as McpTransportKind } from './config.d-CJy1WENT.js';
 import { K as KodaXBaseProvider } from './base.d-DalIRhbb.js';
 import { a as CostTracker } from './cost-tracker.d-CBLk1fiD.js';
-import { bp as RunnerToolCall } from './process.d-DXkRD7hj.js';
-import { g as ToolGuardrail } from './types.d-DFf4Sfys.js';
+import { bq as RunnerToolCall } from './process.d-CY2g03Mb.js';
+import { d as ToolGuardrail } from './guardrail.d-C_Siraua.js';
 
 /**
  * FEATURE_200 Phase F (v0.7.45) — MCP domain types extracted from types.ts.

package/dist/types-chunks/{manager.d-DBD7SOTT.d.ts → manager.d-Zum9cGHU.d.ts}

@@ -1,5 +1,5 @@
-import { a as McpServerConfig, b as McpServersConfig, M as McpConnectMode } from './config.d-CJy1WENT.js';
 import { a as CapabilityProvider, C as CapabilityKind, b as CapabilityResult } from './capability.d-3C62G8Eq.js';
+import { a as McpServerConfig, b as McpServersConfig, M as McpConnectMode } from './config.d-CJy1WENT.js';
 
 type McpCapabilityKind = 'tool' | 'resource' | 'prompt';
 type McpCapabilityRisk = 'read' | 'write' | 'network' | 'exec';
@@ -348,176 +348,6 @@ declare class McpCapabilityProvider implements CapabilityProvider {
     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>;
-    setProtocolVersion?(version: string | undefined): void;
-    close(): Promise<void>;
-    readonly connected: boolean;
-    /** Effective transport after auto-detection (diagnostics only). */
-    readonly resolvedTransport?: string;
-}
-declare class McpExpiredSessionError extends Error {
-    constructor();
-}
-/**
- * FEATURE_222 — the server demanded OAuth (401) or a stronger scope (403). It
- * carries the `WWW-Authenticate` header so the connect flow can discover the
- * authorization server (RFC 9728 pointer) or read the step-up scope.
- */
-declare class McpAuthRequiredError extends Error {
-    readonly status: number;
-    readonly wwwAuthenticate?: string | undefined;
-    constructor(status: number, wwwAuthenticate?: string | undefined);
-}
-type StdioFraming = 'content-length' | 'ndjson';
-interface McpTransportOptions {
-    stdioFraming?: StdioFraming;
-    httpResolvedTransport?: 'streamable-http' | 'sse';
-}
-declare function createMcpTransport(config: McpServerConfig, options?: McpTransportOptions): McpTransport;
-
-/**
- * FEATURE_222 — MCP OAuth discovery (server→authorization-server resolution).
- *
- * The modern MCP auth flow does NOT require the user to hand-configure
- * authorization/token endpoints. Instead the client discovers them at runtime:
- *
- *   401 WWW-Authenticate (resource_metadata=...)         [RFC 9728 pointer]
- *     → GET /.well-known/oauth-protected-resource        [RFC 9728 PRM]
- *       → authorization_servers[0]
- *         → GET /.well-known/oauth-authorization-server  [RFC 8414]
- *            (fallback /.well-known/openid-configuration) [OIDC]
- *           → authorization_endpoint / token_endpoint / registration_endpoint
- *
- * This module is the pure-HTTP discovery layer (no PKCE, no browser, no token
- * storage — those compose on top). The path-aware fallback ordering mirrors
- * Claude Code's MCP client so KodaX resolves the same servers it does.
- */
-interface WwwAuthenticateChallenge {
-    readonly scheme: string;
-    readonly params: Record<string, string>;
-}
-/** The RFC 9728 `resource_metadata` URL a 401 challenge points at, if any. */
-declare function extractResourceMetadataUrl(header: string | undefined): string | undefined;
-/**
- * For a 403 `error="insufficient_scope"` challenge, the `scope` the server now
- * requires (space-separated). Undefined when the challenge is not a step-up.
- */
-declare function extractInsufficientScope(header: string | undefined): string | undefined;
-interface ProtectedResourceMetadata {
-    readonly authorizationServers: string[];
-    readonly resource?: string;
-    readonly scopesSupported?: string[];
-}
-/**
- * Discover the protected-resource metadata for an MCP server URL. Prefers the
- * `resource_metadata` URL from the 401 challenge; otherwise probes the
- * path-specific then root `/.well-known/oauth-protected-resource`.
- */
-declare function discoverProtectedResourceMetadata(options: {
-    serverUrl: string;
-    resourceMetadataUrl?: string;
-    fetchFn?: typeof fetch;
-}): Promise<ProtectedResourceMetadata | undefined>;
-interface AuthorizationServerMetadata {
-    readonly issuer?: string;
-    readonly authorizationEndpoint: string;
-    readonly tokenEndpoint: string;
-    readonly registrationEndpoint?: string;
-    readonly scopesSupported?: string[];
-    readonly codeChallengeMethodsSupported?: string[];
-}
-/** Discover an authorization server's endpoints. The first candidate returning
- *  both an authorization + token endpoint wins. */
-declare function discoverAuthorizationServerMetadata(options: {
-    authorizationServerUrl: string;
-    fetchFn?: typeof fetch;
-}): Promise<AuthorizationServerMetadata | undefined>;
-/**
- * End-to-end endpoint discovery: PRM → first authorization server → AS metadata.
- * Returns the resolved endpoints plus the resource indicator (RFC 8707) and the
- * scopes the resource advertises. Undefined when discovery fails at any step.
- */
-interface DiscoveredOAuthEndpoints extends AuthorizationServerMetadata {
-    /** RFC 8707 resource indicator (the MCP server's canonical URL). */
-    readonly resource?: string;
-    /** Scopes from the protected-resource document, when the AS omits them. */
-    readonly resourceScopesSupported?: string[];
-}
-declare function discoverOAuthEndpoints(options: {
-    serverUrl: string;
-    resourceMetadataUrl?: string;
-    fetchFn?: typeof fetch;
-}): Promise<DiscoveredOAuthEndpoints | undefined>;
-
-interface OAuthToken {
-    readonly accessToken: string;
-    readonly refreshToken?: string;
-    readonly expiresAt?: number;
-    readonly tokenType?: string;
-    readonly scope?: string;
-}
-
-/** A dynamically-registered (or pre-configured) OAuth client. */
-interface OAuthClientInfo {
-    readonly clientId: string;
-    readonly clientSecret?: string;
-}
-/**
- * RFC 7591 Dynamic Client Registration. Registers a public client (PKCE, no
- * secret) for the loopback redirect and returns the issued client_id.
- */
-declare function registerOAuthClient(options: {
-    registrationEndpoint: string;
-    redirectUri: string;
-    clientName: string;
-    scope?: string;
-    fetchFn?: typeof fetch;
-}): Promise<OAuthClientInfo>;
-/**
- * The host's consent gate for a login. Receives the authorization URL and must
- * return true to proceed (the user will open it in their browser). Returning
- * false aborts the login. KodaX never auto-opens the URL.
- */
-type OAuthLoginConsent = (authorizationUrl: string) => Promise<boolean>;
-interface PerformOAuthLoginOptions {
-    serverId: string;
-    /** The MCP server URL (resource) we are authenticating to. */
-    serverUrl: string;
-    /** resource_metadata URL from a 401 challenge, if one was seen. */
-    resourceMetadataUrl?: string;
-    /** A pre-configured client_id (skips dynamic registration). */
-    configuredClientId?: string;
-    /** Pre-configured scopes (override discovery). */
-    configuredScopes?: readonly string[];
-    /** For an insufficient_scope step-up: the elevated scope to request. */
-    stepUpScope?: string;
-    /** Host consent gate (anti-phishing) — receives the authorization URL. */
-    consent: OAuthLoginConsent;
-    /** Loopback callback port (defaults to {@link DEFAULT_OAUTH_REDIRECT_PORT}). */
-    redirectPort?: number;
-    fetchFn?: typeof fetch;
-}
-/**
- * Run the full interactive login and persist the resulting token. Returns the
- * token, or undefined when discovery fails, no client can be obtained, or the
- * user declines consent. Throws only on a hard protocol error (bad exchange).
- */
-declare function performOAuthLogin(options: PerformOAuthLoginOptions): Promise<OAuthToken | undefined>;
-/**
- * Return a still-valid cached token for a server, or undefined. (Discovery-based
- * refresh on expiry is driven by the connect flow, which knows the endpoints.)
- */
-declare function loadValidToken(serverId: string): Promise<OAuthToken | undefined>;
-
 /**
  * McpManager — v0.7.42 (extends FEATURE_186 MCP popout surface).
  *
@@ -697,5 +527,5 @@ declare class McpManager {
  */
 declare function createMcpManager(servers: McpServersConfig | undefined, options?: McpProviderOptions): McpManager;
 
-export { buildInitializeCapabilities as C, createMcpCapabilityId as E, createMcpManager as F, createMcpTransport as G, defaultMcpCacheDir as H, discoverAuthorizationServerMetadata as I, discoverOAuthEndpoints as J, discoverProtectedResourceMetadata as K, extractInsufficientScope as L, McpAuthRequiredError as M, extractResourceMetadataUrl as N, getMcpCachePaths as Q, loadValidToken as R, normalizeMcpCapabilityId as S, parseMcpCapabilityId as T, performOAuthLogin as U, registerOAuthClient as V, searchMcpCatalog as X, McpCapabilityProvider as c, McpExpiredSessionError as h, McpManager as j, McpServerRuntime as s };
-export type { AuthorizationServerMetadata as A, ProtectedResourceMetadata as B, DiscoveredOAuthEndpoints as D, OAuthClientInfo as O, PerformOAuthLoginOptions as P, WwwAuthenticateChallenge as W, McpCapabilityDescriptor as a, McpCapabilityKind as b, McpCapabilityRisk as d, McpCatalogItem as e, McpElicitRequest as f, McpElicitResult as g, McpIcon as i, McpProviderOptions as k, McpReverseCapabilities as l, McpRoot as m, McpSamplingRequest as n, McpSamplingResult as o, McpServerCatalog as p, McpServerCatalogSnapshot as q, McpServerLogs as r, McpServerRuntimeDiagnostics as t, McpServerStatus as u, McpServerToolList as v, McpToolTaskSupport as w, McpTransport as x, McpTransportEvents as y, OAuthLoginConsent as z };
+export { normalizeMcpCapabilityId as A, parseMcpCapabilityId as B, searchMcpCatalog as C, McpCapabilityProvider as b, McpManager as h, McpServerRuntime as q, buildInitializeCapabilities as v, createMcpCapabilityId as w, createMcpManager as x, defaultMcpCacheDir as y, getMcpCachePaths as z };
+export type { McpCapabilityDescriptor as M, McpCapabilityKind as a, McpCapabilityRisk as c, McpCatalogItem as d, McpElicitRequest as e, McpElicitResult as f, McpIcon as g, McpProviderOptions as i, McpReverseCapabilities as j, McpRoot as k, McpSamplingRequest as l, McpSamplingResult as m, McpServerCatalog as n, McpServerCatalogSnapshot as o, McpServerLogs as p, McpServerRuntimeDiagnostics as r, McpServerStatus as s, McpServerToolList as t, McpToolTaskSupport as u };