@kodax-ai/kodax 0.7.63 → 0.7.67

package/dist/types-chunks/{types.d-1CnTg7Sd.d.ts → guardrail.d-Ds7JHxR1.d.ts}

@@ -1,5 +1,4 @@
-import { J as Guardrail, bq as RunnerToolCall, f as Agent, h as AgentMessage, bt as RunnerToolResult, bC as Span, a2 as KodaXInputArtifact } from './process.d-CY2g03Mb.js';
-import { R as KodaXTaskResultMetadata } from './types.d-Bp4Lm1jv.js';
+import { aw as Guardrail, cf as RunnerToolCall, f as Agent, I as AgentMessage, ci as RunnerToolResult, cr as Span } from './types.d-DG9B4SMm.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-MR6LwMB2.d.ts → guardrail.d-vSaBe64I.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 { bq as RunnerToolCall } from './process.d-CY2g03Mb.js';
-import { g as ToolGuardrail } from './types.d-1CnTg7Sd.js';
+import { cf as RunnerToolCall } from './types.d-DG9B4SMm.js';
+import { d as ToolGuardrail } from './guardrail.d-Ds7JHxR1.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 };

package/dist/types-chunks/oauth-login.d-Bgb4rdLN.d.ts

@@ -0,0 +1,174 @@
+import { a as McpServerConfig } from './config.d-CJy1WENT.js';
+
+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>;
+
+export { McpAuthRequiredError as M, McpExpiredSessionError as a, createMcpTransport as f, discoverAuthorizationServerMetadata as g, discoverOAuthEndpoints as h, discoverProtectedResourceMetadata as i, extractInsufficientScope as j, extractResourceMetadataUrl as k, loadValidToken as l, performOAuthLogin as p, registerOAuthClient as r };
+export type { AuthorizationServerMetadata as A, DiscoveredOAuthEndpoints as D, OAuthClientInfo as O, PerformOAuthLoginOptions as P, WwwAuthenticateChallenge as W, McpTransport as b, McpTransportEvents as c, OAuthLoginConsent as d, ProtectedResourceMetadata as e };