/**
 * The provider host — this agent acting as an MCP *server*.
 *
 * The rest of the bridge runs the agent as a client of external servers
 * ({@link ServerEndpoint}, {@link ServerFleet}). This module is the mirror image:
 * a {@link ProviderHost} stands up an MCP server over the official SDK and
 * publishes *our* built-in tools — a {@link ToolBox} assembled by the
 * capabilities layer — so an external MCP client can enumerate and invoke them.
 *
 * The host is a thin,
 * stateless adapter in two directions:
 *
 *   - **Catalog.** A `tools/list` request answers with the box's
 *     {@link ToolBox.descriptors}, each mapped to the MCP tool shape
 *     (`{ name, description, inputSchema }`).
 *   - **Dispatch.** A `tools/call` request is routed straight into
 *     `box.runner.run`, and the resulting {@link ToolOutcome} is projected onto
 *     the MCP call result (`{ content: [{ type: 'text', text }], isError }`).
 *
 * Tool arguments and outputs are the only translation surface: MCP carries
 * `arguments` as a record and expects `content` blocks back, while our runtime
 * speaks `input: unknown` and `output: unknown`.
 */
import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
import type { ToolBox } from "../../runtime/contract";
/** Identifying metadata the host advertises to connecting MCP clients. */
export interface ProviderHostInfo {
    /** The server name surfaced during MCP initialization. */
    readonly name: string;
    /** The server version surfaced during MCP initialization. */
    readonly version: string;
}
/**
 * An MCP server exposing this agent's built-in tools to external clients.
 *
 * The host is inert until {@link ProviderHost.connect} binds it to a transport;
 * once bound, the underlying SDK server answers `tools/list` and `tools/call`
 * for the lifetime of the connection.
 */
export interface ProviderHost {
    /**
     * Bind the host to a transport and begin serving. The transport governs how a
     * client reaches the host (stdio pipe, SSE stream, in-memory pair); the host
     * is transport-agnostic. Resolves once the MCP session is established.
     */
    connect(transport: Transport): Promise<void>;
}
/**
 * Stand up a {@link ProviderHost} over the box's tools.
 *
 * The returned host is not yet listening — wire it to a transport with
 * {@link ProviderHost.connect}. The two MCP request handlers are registered
 * eagerly against a fresh SDK {@link Server}; both close over `box`, so each
 * `tools/list` reflects the box's descriptors at call time and each
 * `tools/call` dispatches through the box's live runner.
 *
 * @param box  the assembled tool box whose tools are published
 * @param info optional identity advertised to clients; defaults to a generic
 *             provider identity when omitted
 */
export declare function createProviderHost(box: ToolBox, info?: ProviderHostInfo): ProviderHost;
