@kodax-ai/kodax 0.7.63 → 0.7.66

package/dist/types-chunks/{guardrail.d-MR6LwMB2.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 { bq as RunnerToolCall } from './process.d-CY2g03Mb.js';
-import { g as ToolGuardrail } from './types.d-1CnTg7Sd.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 };

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 };