indusagi 0.13.6 → 0.13.8

package/dist/types/connectors-sarvam/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Public types for the Sarvam MCP integration.
+ *
+ * The Sarvam DX exposes an MCP server that runs as a stdio subprocess
+ * (`uvx sarvam-mcp`). Auth is a single dashboard-issued API key passed via
+ * the `SARVAM_API_KEY` environment variable. These types describe how a
+ * caller hands that key — plus a few cosmetic knobs — to
+ * {@link connectSarvamMcp} and gets back a runtime {@link ToolBox} ready to
+ * drop into `createAgent({ tools })`.
+ */
+import type { ToolBox } from "../runtime/contract/index.js";
+import type { MCPClient } from "../facade/mcp-core/client.js";
+/** Options for {@link connectSarvamMcp}. */
+export interface ConnectSarvamMcpOptions {
+    /** Sarvam dashboard API key. Falls back to process.env.SARVAM_API_KEY. */
+    readonly apiKey?: string;
+    /** Stable id used for tool-name prefixing (default: "sarvam"). */
+    readonly id?: string;
+    /** Override Sarvam API base URL. Falls back to SARVAM_API_BASE_URL env, then "https://api.sarvam.ai". */
+    readonly baseUrl?: string;
+    /** Override where the Sarvam MCP server writes audio/docs files. Falls back to SARVAM_MCP_BASE_PATH env, then "~/Desktop". */
+    readonly basePath?: string;
+    /** Subprocess command. Default: "uvx". */
+    readonly command?: string;
+    /** Subprocess args. Default: ["sarvam-mcp"]. */
+    readonly args?: readonly string[];
+    /** Extra env for the subprocess. SARVAM_API_KEY and the *_BASE_URL/_BASE_PATH vars above are merged on top. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Connect timeout in ms (default 60_000 — uvx may download on first run). */
+    readonly timeoutMs?: number;
+    /** Optional logger for diagnostics. */
+    readonly logger?: {
+        debug(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}
+/** The handle returned by {@link connectSarvamMcp}. */
+export interface SarvamMcpConnection {
+    /** Stable id used for tool prefixing. */
+    readonly id: string;
+    /** Runtime ToolBox ready for `createAgent({ tools: sarvam.toolBox })`. */
+    readonly toolBox: ToolBox;
+    /** Names of every remote tool (already prefixed). */
+    readonly toolNames: readonly string[];
+    /** Underlying MCPClient (escape hatch). */
+    readonly client: MCPClient;
+    /** Disconnect and kill the spawned uvx child. Idempotent. */
+    close(): Promise<void>;
+}

package/dist/types/connectors-zoho/connect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Connect to a Zoho MCP server.
+ *
+ * Validates the URL, builds an HTTP-backed {@link MCPClient} (Streamable HTTP by
+ * default, legacy SSE when `useSse: true`), wires an OAuth 2.1 + PKCE auth
+ * provider for the transport when `auth` is `"auto"` (default) or `"oauth"`,
+ * opens the connection, then bridges the remote tool catalog into a runtime
+ * {@link ToolBox} via {@link mcpClientToToolBox} using `options.id` (default
+ * `"zoho"`) as the tool-name prefix so two servers can never collide.
+ *
+ * On 401 from Zoho:
+ *   1. SDK discovers the auth server (RFC 9728 / 8414)
+ *   2. Browser opens for PKCE login
+ *   3. Local callback captures the code
+ *   4. `transport.finishAuth(code)` exchanges tokens
+ *   5. Reconnect with Bearer token
+ *
+ * Tokens persist to `~/.config/indusagi/credentials/mcp/<id>.json` (mode 0600).
+ */
+import type { ConnectZohoMcpOptions, ZohoMcpConnection } from "./types.js";
+/** Open a Zoho MCP connection and return a ready-to-use toolbox + client. */
+export declare function connectZohoMcp(options: ConnectZohoMcpOptions): Promise<ZohoMcpConnection>;

package/dist/types/connectors-zoho/connectors-zoho.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for {@link connectZohoMcp}.
+ *
+ * A small `FakeMCPClient` stands in for the SDK-backed client. We use
+ * `vi.mock` to redirect the `MCPClient` import in `./connect.js` to a
+ * factory that returns our fake — no network, no vendor SDK, no
+ * monkey-patching of live modules. The fake records every method call so
+ * assertions can pin exactly what the connector did.
+ */
+export {};

package/dist/types/connectors-zoho/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Public barrel for the Zoho MCP connector.
+ *
+ *   - {@link connectZohoMcp} — the high-level "give me a working toolbox"
+ *     entry point that takes a Zoho console URL.
+ *   - {@link zohoToolBoxFromClient} — the lower-level adapter for callers who
+ *     already hold a connected {@link MCPClient}.
+ *   - {@link ConnectZohoMcpOptions} / {@link ZohoMcpConnection} — the public
+ *     types for those two entry points.
+ */
+export { connectZohoMcp } from "./connect.js";
+export { zohoToolBoxFromClient } from "./toolbox.js";
+export type { ConnectZohoMcpOptions, ZohoMcpConnection } from "./types.js";

package/dist/types/connectors-zoho/toolbox.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Thin re-export wrapper so power users can also import just the toolbox
+ * adapter without going through {@link connectZohoMcp}.
+ *
+ * `zohoToolBoxFromClient` is equivalent to
+ *   `mcpClientToToolBox(client, { namePrefix: options.id ?? "zoho", ... })`
+ * — it just defaults the prefix to the Zoho id.
+ */
+import type { McpToToolBoxOptions } from "../facade/mcp-core/toolbox-bridge.js";
+import type { MCPClient } from "../facade/mcp-core/client.js";
+import type { ToolBox } from "../runtime/contract/index.js";
+/**
+ * Wrap a connected {@link MCPClient} as a runtime {@link ToolBox} with a
+ * Zoho-friendly prefix. Equivalent to
+ * `mcpClientToToolBox(client, { namePrefix: options.id ?? "zoho", ... })`.
+ */
+export declare function zohoToolBoxFromClient(client: MCPClient, options?: {
+    id?: string;
+} & Omit<McpToToolBoxOptions, "namePrefix">): Promise<ToolBox>;

package/dist/types/connectors-zoho/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Public types for the Zoho MCP integration.
+ *
+ * The Zoho DX exposes a remote MCP server URL from the Zoho developer console.
+ * These types describe how a caller hands that URL — plus a few cosmetic
+ * knobs — to {@link connectZohoMcp} and gets back a runtime
+ * {@link ToolBox} ready to drop into `createAgent({ tools })`.
+ */
+/** Options for {@link connectZohoMcp}. */
+export interface ConnectZohoMcpOptions {
+    /** The MCP server URL from Zoho console → Connect tab. */
+    readonly url: string;
+    /** Stable id used for tool-name prefixing (default: "zoho"). */
+    readonly id?: string;
+    /**
+     * Auth mode:
+     *  - "auto" (default): wire OAuth 2.1 + PKCE; let the SDK drive discovery and
+     *    token refresh on 401. Persists tokens to `~/.config/indusagi/credentials/mcp/<id>.json`.
+     *  - "oauth": same as "auto", explicit.
+     *  - "none": no client OAuth; pass the URL through as-is (Zoho may have
+     *    embedded a token, or you may have set a bearer via `headers`).
+     */
+    readonly auth?: "auto" | "oauth" | "none";
+    /** Optional static headers (e.g. Authorization). Use with care. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Request timeout in ms (default 30_000). */
+    readonly timeoutMs?: number;
+    /** Use the legacy SSE transport instead of Streamable HTTP. Default: false. */
+    readonly useSse?: boolean;
+    /** Override the credentials directory (default: `~/.config/indusagi/credentials/mcp/`). */
+    readonly tokenStorePath?: string;
+    /** Override the OAuth redirect URI (default: `http://127.0.0.1:<random>/callback`). */
+    readonly redirectUrl?: string;
+    /** Open the browser for the OAuth round (default: true in TTY, false in CI). */
+    readonly openBrowser?: boolean;
+    /** OAuth scopes to request (default: server-advertised). */
+    readonly scopes?: readonly string[];
+    /** Optional logger for diagnostics. */
+    readonly logger?: {
+        debug(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}
+/** The handle returned by {@link connectZohoMcp}. */
+export interface ZohoMcpConnection {
+    /** Stable id used for tool prefixing. */
+    readonly id: string;
+    /** Runtime ToolBox ready for `createAgent({ tools: zoho.toolBox })`. */
+    readonly toolBox: import("../runtime/contract/index.js").ToolBox;
+    /** Names of every remote tool (already prefixed). */
+    readonly toolNames: readonly string[];
+    /** Underlying MCPClient (escape hatch). */
+    readonly client: import("../facade/mcp-core/client.js").MCPClient;
+    /** Disconnect from the MCP server. Idempotent. */
+    close(): Promise<void>;
+}

package/dist/types/facade/mcp-core/client.d.ts

@@ -17,6 +17,7 @@
  * roots/list, sampling, ping), and bounded reconnect on a dropped stream /
  * expired session — none of which the hand-rolled POST-only transport did.
  */
+import { type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import type { MCPServerConfig, MCPToolDefinition, MCPResource, MCPPrompt, MCPToolCallResult, MCPLogHandler, MCPProgressHandler, MCPElicitationHandler, MCPRoot } from "./types.js";
 /**
  * Options for creating an MCP client.
@@ -36,6 +37,22 @@ export interface MCPClientOptions {
     enableProgressTracking?: boolean;
     /** Filesystem roots to expose to the server */
     roots?: MCPRoot[];
+    /**
+     * OAuth client provider for the Streamable HTTP / SSE transport. When set,
+     * the SDK handles 401 → discover → PKCE → token-exchange → retry, plus
+     * mid-session refresh, automatically. Ignored for stdio.
+     *
+     * For first-time interactive auth the provider should also expose
+     * `waitForAuthorizationCode(): Promise<string>` (our
+     * {@link import("./oauth/provider.js").McpOAuthClientProvider} does). After
+     * the SDK throws UnauthorizedError we await that code, call
+     * `transport.finishAuth(code)`, and reconnect — matching the official
+     * MCP SDK CLI example.
+     */
+    authProvider?: OAuthClientProvider & {
+        waitForAuthorizationCode?: () => Promise<string>;
+        dispose?: () => void;
+    };
 }
 /**
  * MCP Client - manages connection to a single MCP server.
@@ -90,6 +107,21 @@ export declare class MCPClient {
      */
     connect(): Promise<void>;
     private doConnect;
+    /**
+     * If `err` is an OAuth challenge and we have a provider + finishAuth-capable
+     * transport, wait for the browser code, exchange tokens, then reconnect on a
+     * **fresh** transport (the first transport is already `start()`ed and cannot
+     * be reused — see StreamableHTTPClientTransport.start).
+     *
+     * Matches the official SDK CLI example (`simpleOAuthClient`):
+     *   finishAuth(code) → new StreamableHTTPClientTransport → client.connect again
+     *
+     * Client.connect already called `close()` on init failure, so the Client is
+     * free to attach a new transport.
+     */
+    private tryFinishOAuthAndReconnect;
+    /** Turn raw SDK / network errors into a clearer MCPError for callers. */
+    private wrapConnectError;
     /**
      * Build the SDK transport for the configured server.
      *

package/dist/types/facade/mcp-core/index.d.ts

@@ -27,6 +27,10 @@
 import { MCPClientPool } from "./client-pool.js";
 export { MCPClient, type MCPClientOptions } from "./client.js";
 export { MCPClientPool, type MCPClientPoolOptions, type MCPServerStatus } from "./client-pool.js";
+export { mcpClientToToolBox } from "./toolbox-bridge.js";
+export type { McpToToolBoxOptions } from "./toolbox-bridge.js";
+export * as oauth from "./oauth/index.js";
+export type { McpOAuthClientProvider } from "./oauth/index.js";
 export { MCPServer, createMCPServer, type MCPServerOptions } from "./server.js";
 export { createMCPAgentToolFactory, registerMCPToolsInRegistry, createMCPToolsMap, createMCPToolsRecord, type MCPToolClient, } from "./tool-factory.js";
 export { jsonSchemaToTypeBox, applyPassthrough, convertMCPInputSchema, convertMCPOutputSchema, } from "./schema-converter.js";

package/dist/types/facade/mcp-core/oauth/flow.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Local-callback server for MCP OAuth.
+ *
+ * The MCP SDK OAuth flow for CLIs is:
+ *   1. Pre-bind a 127.0.0.1 callback server → known `redirect_uri`
+ *   2. Pass that URL as `OAuthClientProvider.redirectUrl`
+ *   3. On 401 the SDK opens the browser via `redirectToAuthorization`
+ *   4. SDK returns REDIRECT → transport throws UnauthorizedError
+ *   5. Caller waits for the browser hit, then `transport.finishAuth(code)`
+ *   6. Reconnect
+ *
+ * This module owns steps 1 and 5's wait half. Browser open lives in
+ * {@link openBrowser}; the provider and MCPClient wire the rest.
+ */
+/**
+ * A pre-bound OAuth callback listener.
+ *
+ * Bind once before the MCP connect attempt so `redirect_uri` in the authorize
+ * request matches a real listening port. Then call {@link OAuthCallbackServer.waitForCode}
+ * after the SDK throws UnauthorizedError.
+ */
+export interface OAuthCallbackServer {
+    /** Absolute redirect URI, e.g. `http://127.0.0.1:54321/callback`. */
+    readonly redirectUri: string;
+    /** Bound port. */
+    readonly port: number;
+    /**
+     * Wait for the browser to hit the callback with `?code=…`.
+     * If `expectedState` is set, a mismatched `state` rejects.
+     */
+    waitForCode(expectedState?: string): Promise<string>;
+    /** Tear down the listener. Idempotent. */
+    close(): void;
+}
+/**
+ * Bind a one-shot OAuth callback server on 127.0.0.1 (random free port).
+ *
+ * Important: the 5‑minute wait timer starts only when {@link OAuthCallbackServer.waitForCode}
+ * is called (i.e. when the SDK actually needs browser OAuth). If tokens are already
+ * on disk and connect succeeds without OAuth, we must NOT arm a timer — otherwise a
+ * later orphan rejection crashes the process with:
+ *   "oauth-callback: timed out after … waiting for browser login"
+ */
+export declare function startOAuthCallbackServer(options?: {
+    timeoutMs?: number;
+    logger?: {
+        debug(msg: string): void;
+        warn(msg: string): void;
+    };
+}): Promise<OAuthCallbackServer>;
+/**
+ * Back-compat helper used by older call sites: bind + wait in one shot.
+ * Prefer {@link startOAuthCallbackServer} so `redirect_uri` is known before authorize.
+ */
+export declare function waitForAuthorizationCode(expectedState: string, options?: {
+    timeoutMs?: number;
+    logger?: {
+        debug(msg: string): void;
+        warn(msg: string): void;
+    };
+}): Promise<{
+    code: string;
+    redirectUri: string;
+    port: number;
+    close(): void;
+}>;
+/**
+ * Open the user's browser to the auth URL. Falls back silently if the runtime
+ * has no GUI (CI, headless containers). The caller should always log the URL
+ * too so the user can open it manually.
+ */
+export declare function openBrowser(url: string): Promise<boolean>;

package/dist/types/facade/mcp-core/oauth/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public barrel for the MCP OAuth submodule.
+ *
+ * The MCP OAuth flow is large (RFC 9728 discovery, RFC 7636 PKCE, RFC 7591
+ * dynamic registration, plus a browser redirect handler), but the
+ * indus-rebuild package only contributes the pieces the official
+ * `@modelcontextprotocol/sdk` cannot provide itself: a persistent token store
+ * and a local-callback HTTP server. The orchestrator (`auth()`) and the
+ * PKCE / refresh primitives all come from the SDK — re-export them so a
+ * power user can call them directly without reaching into the SDK.
+ */
+export { createMcpOAuthProvider, type McpOAuthClientProvider, } from "./provider.js";
+export type { McpClientInfo, McpOAuthConfig, McpOAuthState, McpTokenSet } from "./types.js";
+export { readMcpOAuthState, writeMcpOAuthState, clearMcpOAuthState, resolveCredentialsDir, credentialsPath, } from "./token-store.js";
+export { waitForAuthorizationCode, startOAuthCallbackServer, openBrowser, } from "./flow.js";
+export type { OAuthCallbackServer } from "./flow.js";
+export { auth, discoverOAuthServerInfo, startAuthorization, exchangeAuthorization, refreshAuthorization, registerClient, extractWWWAuthenticateParams, } from "@modelcontextprotocol/sdk/client/auth.js";
+export type { OAuthTokens, OAuthClientMetadata, OAuthClientInformationMixed } from "@modelcontextprotocol/sdk/shared/auth.js";

package/dist/types/facade/mcp-core/oauth/oauth.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for the MCP OAuth submodule.
+ *
+ * The tests focus on what *we* add (token-store persistence, provider plumbing,
+ * URL parsing) rather than re-validating the SDK. Every test uses a temp dir
+ * and never reads or writes the real `~/.config/indusagi/credentials/mcp/`.
+ */
+export {};

package/dist/types/facade/mcp-core/oauth/provider.d.ts

@@ -0,0 +1,51 @@
+/**
+ * An `OAuthClientProvider` implementation that persists every state transition
+ * to disk and coordinates a local callback server for the browser redirect.
+ *
+ * Matches the official SDK CLI pattern (`simpleOAuthClient`):
+ *   - `redirectToAuthorization` only opens the browser (does NOT wait)
+ *   - the MCP transport throws `UnauthorizedError` after REDIRECT
+ *   - the caller awaits {@link McpOAuthClientProvider.waitForAuthorizationCode}
+ *   - then calls `transport.finishAuth(code)` and reconnects
+ *
+ * The callback server is pre-bound at provider creation so `redirect_uri` is a
+ * real `http://127.0.0.1:<port>/callback` before the authorize request is sent.
+ */
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { McpOAuthConfig } from "./types.js";
+/**
+ * The provider object returned by {@link createMcpOAuthProvider}.
+ *
+ * Implements every required method of the SDK's `OAuthClientProvider`.
+ */
+export interface McpOAuthClientProvider {
+    readonly id: string;
+    readonly credentialsDir: string;
+    /** Real callback URL (pre-bound). */
+    readonly redirectUrl: string;
+    readonly clientMetadata: OAuthClientMetadata;
+    state(): string;
+    clientInformation(): OAuthClientInformationMixed | undefined;
+    saveClientInformation(client: OAuthClientInformationMixed): void;
+    tokens(): OAuthTokens | undefined;
+    saveTokens(tokens: OAuthTokens): void;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    saveCodeVerifier(codeVerifier: string): void;
+    codeVerifier(): string;
+    invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery"): void;
+    /**
+     * Wait for the browser OAuth round to complete after UnauthorizedError.
+     * Returns the authorization code for `transport.finishAuth(code)`.
+     */
+    waitForAuthorizationCode(): Promise<string>;
+    /** Tear down the local callback listener. Call after connect succeeds or fails. */
+    dispose(): void;
+    /** Last authorization URL (for logging / manual open). */
+    lastAuthorizationUrl(): string | undefined;
+}
+/**
+ * Build a persistent `OAuthClientProvider` for one MCP server.
+ *
+ * Always async: pre-binds the callback port so `redirectUrl` is real.
+ */
+export declare function createMcpOAuthProvider(config: McpOAuthConfig): Promise<McpOAuthClientProvider>;

package/dist/types/facade/mcp-core/oauth/token-store.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Persistent token store for MCP OAuth state.
+ *
+ * One JSON file per server id under `<credentialsDir>/<id>.json`. On POSIX we
+ * create the file with mode 0600 so only the owning user can read tokens; on
+ * other platforms we fall back to the umask default. Tokens and PKCE verifiers
+ * are short-lived material that must never leak to a multi-user host.
+ *
+ * The store is deliberately synchronous — every method is small and the caller
+ * is already in an async context, so wrapping in fs.promises would just add
+ * microtask overhead for no benefit.
+ */
+import type { McpOAuthState } from "./types.js";
+/** Resolve the credentials directory, honoring the override when supplied. */
+export declare function resolveCredentialsDir(override?: string): string;
+/** File path for a given server id. */
+export declare function credentialsPath(credentialsDir: string, id: string): string;
+/**
+ * Read the persisted state for `id`, or `undefined` if nothing was stored yet.
+ * Returns `undefined` rather than throwing on missing-file so callers can
+ * treat the cold start as "needs authorization".
+ */
+export declare function readMcpOAuthState(credentialsDir: string, id: string): McpOAuthState | undefined;
+/**
+ * Write state atomically: temp file in the same directory + rename, so a
+ * crash mid-write cannot leave a half-formed token file. Creates the parent
+ * directory if needed.
+ */
+export declare function writeMcpOAuthState(credentialsDir: string, state: McpOAuthState): void;
+/** Remove the state file. Idempotent. */
+export declare function clearMcpOAuthState(credentialsDir: string, id: string): void;

package/dist/types/facade/mcp-core/oauth/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Types for the MCP OAuth submodule.
+ *
+ * The MCP spec delegates OAuth to the official SDK (RFC 9728 Protected Resource
+ * Metadata discovery, RFC 7636 PKCE, RFC 7591 Dynamic Client Registration).
+ * This submodule supplies only the persistent state and the local-redirect
+ * capture the SDK cannot do on its own — the rest of the flow (PKCE challenge
+ * generation, discovery, token exchange, refresh) is delegated to
+ * `@modelcontextprotocol/sdk/client/auth.js`.
+ */
+/**
+ * The persistent token set we keep on disk across agent invocations.
+ *
+ * Aligned with the SDK's `OAuthTokens` shape so we can hand it straight back
+ * to the SDK without translation. `client_id` / `client_secret` come from
+ * RFC 7591 dynamic registration when the server supports it.
+ */
+export interface McpTokenSet {
+    /** OAuth access token; sent as `Authorization: Bearer <accessToken>`. */
+    readonly access_token: string;
+    /** Long-lived refresh token; used to mint new access tokens without a browser. */
+    readonly refresh_token?: string;
+    /** Optional scope string echoed back from the auth server. */
+    readonly scope?: string;
+    /** Token type; "Bearer" by default. */
+    readonly token_type?: string;
+    /** Absolute epoch-ms deadline derived from the server's `expires_in`. */
+    readonly expires_at?: number;
+}
+/**
+ * RFC 7591 client information persisted after dynamic registration. Many MCP
+ * servers do not require pre-registration, but when they do we need to reuse
+ * the issued client_id on every subsequent connection.
+ */
+export interface McpClientInfo {
+    readonly client_id: string;
+    readonly client_secret?: string;
+    readonly client_id_issued_at?: number;
+    readonly client_secret_expires_at?: number;
+}
+/**
+ * Per-server state persisted to disk. Keyed by stable server id (defaults to
+ * the MCP URL host). One file per id keeps isolation and rotation simple.
+ */
+export interface McpOAuthState {
+    /** Stable id (typically the MCP server URL host). */
+    readonly id: string;
+    /** When the state was last written, epoch-ms. */
+    readonly updatedAt: number;
+    /** Tokens from the last successful auth round. */
+    tokens?: McpTokenSet;
+    /** Client info from RFC 7591 dynamic registration, if performed. */
+    client?: McpClientInfo;
+    /** RFC 9728 protected resource metadata, cached to skip re-discovery. */
+    resourceMetadata?: unknown;
+    /** RFC 8414 authorization server metadata, cached to skip re-discovery. */
+    authServerMetadata?: unknown;
+    /** PKCE code verifier held between `startAuthorization` and the callback. */
+    codeVerifier?: string;
+    /** OAuth `state` parameter held between start and callback for CSRF check. */
+    state?: string;
+}
+/**
+ * Configuration passed when wiring up an OAuth-aware MCP client.
+ */
+export interface McpOAuthConfig {
+    /** Stable id used for the on-disk file name and the SDK's session. */
+    readonly id: string;
+    /** Override path to the credentials directory. Default: `~/.config/indusagi/credentials/mcp/`. */
+    readonly credentialsDir?: string;
+    /** Where to listen for the OAuth callback. Default: `http://127.0.0.1:<random>/callback`. */
+    readonly redirectUrl?: string;
+    /** Client metadata sent to RFC 7591 dynamic registration. */
+    readonly clientMetadata?: {
+        readonly client_name?: string;
+        readonly client_uri?: string;
+        readonly logo_uri?: string;
+        readonly contacts?: readonly string[];
+        readonly tos_uri?: string;
+        readonly policy_uri?: string;
+        readonly redirect_uris?: readonly string[];
+        readonly token_endpoint_auth_method?: "none" | "client_secret_basic" | "client_secret_post";
+        readonly grant_types?: readonly string[];
+        readonly response_types?: readonly string[];
+        readonly scope?: string;
+    };
+    /** Open the browser for the user to complete the auth round. Default: true in TTY. */
+    readonly openBrowser?: boolean;
+    /** Skip opening the browser and print the URL instead. */
+    readonly logger?: {
+        debug(msg: string): void;
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}

package/dist/types/facade/mcp-core/toolbox-bridge.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Bridge a connected {@link MCPClient} into the runtime's {@link ToolBox} shape.
+ *
+ * `mcpClientToToolBox` is the entry point most callers want: it asks the
+ * connected client for its remote tool catalog, wraps each one with
+ * {@link defineTool} so the model sees a normal `ToolDescriptor`, and returns a
+ * {@link ToolBox} that drops straight into `createAgent({ tools })`. Every
+ * remote tool is registered under `"<prefix>__<name>"` so two MCP servers
+ * advertising the same name never collide.
+ *
+ * The mapping intentionally projects the MCP result into the kernel's
+ * {@link ToolContentBlock} vocabulary:
+ *   - `text` blocks pass through verbatim;
+ *   - `image` blocks become a one-line text mention (we do not ship raw
+ *     base64 to the model through this seam; structured payloads travel on
+ *     `structuredContent` instead);
+ *   - `resource` blocks become a `[resource <uri>]` mention;
+ *   - `structuredContent`, if present, is appended as a JSON content block.
+ */
+import type { MCPClient } from "./client.js";
+import type { MCPToolDefinition } from "./types.js";
+import type { ToolBox } from "../../runtime/contract/index.js";
+/** Options for {@link mcpClientToToolBox}. */
+export interface McpToToolBoxOptions {
+    /**
+     * Prefix each tool name with `"<prefix>__"`. Default: `"mcp"`. Two clients
+     * bridged in the same agent should use distinct prefixes.
+     */
+    readonly namePrefix?: string;
+    /** Optional filter — return false to skip a tool. */
+    readonly filter?: (tool: MCPToolDefinition) => boolean;
+    /** Logger for diagnostics. */
+    readonly logger?: {
+        debug(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}
+/**
+ * Wrap a connected {@link MCPClient} as a runtime {@link ToolBox}.
+ *
+ * Each remote tool becomes a prefixed descriptor (`"<prefix>__<name>"`) whose
+ * invocation is forwarded to `client.callTool` with the model's input passed
+ * through unchanged. Results are projected from MCP content blocks onto the
+ * kernel's `ToolContentBlock` vocabulary.
+ */
+export declare function mcpClientToToolBox(client: MCPClient, options?: McpToToolBoxOptions): Promise<ToolBox>;

package/dist/types/facade/mcp-core/toolbox-bridge.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for {@link mcpClientToToolBox}.
+ *
+ * A small inline `FakeMCPClient` stands in for the real client: it tracks
+ * calls and scripts the responses of `listTools` / `callTool`. No network,
+ * no vi.mock — the codebase prefers stubbed fakes.
+ */
+export {};

package/dist/types/index.d.ts

@@ -9,6 +9,8 @@ export * as runtime from "./runtime";
 export * as capabilities from "./capabilities";
 export * as interop from "./interop";
 export * as saas from "./connectors-saas";
+export * as zoho from "./connectors-zoho";
+export * as sarvamMcp from "./connectors-sarvam";
 export * as swarm from "./swarm";
 export * as smithy from "./smithy";
 export * as tracing from "./tracing";

package/dist/types/llmgateway/contract/model-card.d.ts

@@ -9,7 +9,7 @@
  * The upstream organization that owns a model. This is the *vendor* identity,
  * independent of which HTTP dialect we speak to reach it (see {@link ApiKind}).
  */
-export type ProviderId = "anthropic" | "openai" | "google" | "google-vertex" | "amazon" | "azure" | "nvidia" | "kimi" | "ollama" | "mock";
+export type ProviderId = "anthropic" | "openai" | "google" | "google-vertex" | "amazon" | "azure" | "nvidia" | "kimi" | "minimax" | "minimax-cn" | "ollama" | "mock";
 /**
  * The concrete request/response wire protocol a connector implements. Several
  * providers share a dialect (everything OpenAI-compatible speaks

package/dist/types/llmgateway/credentials/secrets.d.ts

@@ -17,6 +17,8 @@
  *   - Azure OpenAI ..... AZURE_OPENAI_API_KEY, then AZURE_API_KEY
  *   - NVIDIA ........... NVIDIA_API_KEY
  *   - Kimi (Moonshot) .. MOONSHOT_API_KEY, then KIMI_API_KEY
+ *   - MiniMax .......... MINIMAX_API_KEY (global api.minimax.io)
+ *   - MiniMax CN ....... MINIMAX_API_KEY, then MINIMAX_CN_API_KEY (api.minimaxi.com)
  *   - Ollama / mock .... (no secret required)
  */
 import type { CredentialResolver, ProviderId } from "../contract";