/**
 * MCP protocol version constants and predicates.
 *
 * `McpProtocolVersion` is the user-facing pin a server connection can be
 * locked to. Values are wire literals — they go directly into
 * `_meta.io.modelcontextprotocol/protocolVersion` and into the
 * `MCP-Protocol-Version` HTTP header.
 *
 * **Validate-then-route discipline:**
 *   - Trust boundaries (Convex validator, REST input parser, UI form
 *     submit) MUST gate on `isKnownProtocolVersion(v)` first. Typo strings
 *     like `"DRAFT-2027-zzz"` (and the retired pre-RC placeholder
 *     `"DRAFT-2026-v1"`) fail here.
 *   - Inside trusted code (the factory, the preview client) use
 *     `isStatelessProtocolVersion(v)` for routing. It returns true for
 *     anything not on the closed `STATEFUL_PROTOCOL_VERSIONS` set —
 *     correct only after membership has been validated upstream.
 *
 * A hand-mirrored copy lives in the backend at
 * `mcpjam-backend/convex/lib/mcpProtocolVersion.ts`. Keep them in sync;
 * adding a new version requires updating both, plus the Convex schema
 * validators in `mcpjam-backend/convex/schema.ts`.
 */
/**
 * Every MCP protocol version a server connection can be pinned to.
 *
 * MUST stay chronological: `protocolVersionLabel` reads the last element as
 * the newest revision, so every protocol dropdown in the inspector marks
 * whatever sits at the tail as "Latest". Append new revisions; never insert
 * or reorder. UI ordering is separate — the dropdowns reverse this for
 * display.
 */
declare const MCP_PROTOCOL_VERSIONS: readonly ["2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28"];
type McpProtocolVersion = (typeof MCP_PROTOCOL_VERSIONS)[number];
/**
 * Product label for a revision, shared by every protocol dropdown so they
 * cannot disagree about which revision is current:
 *
 * - **Latest** = newest known revision, derived above.
 * - Every other revision renders bare — a fixed marker on them would be one
 *   more string to walk forward by hand.
 */
declare function protocolVersionLabel(version: McpProtocolVersion): string;
/**
 * Membership predicate. Use this at trust boundaries to reject typo /
 * unknown values before any routing logic runs.
 */
declare function isKnownProtocolVersion(v: string): v is McpProtocolVersion;
/**
 * Routing predicate — returns true for any string NOT on the stateful
 * list. ONLY call after `isKnownProtocolVersion(v)`; otherwise typo
 * strings will route as stateless.
 */
declare function isStatelessProtocolVersion(v: string): boolean;

/**
 * HostConfig v2 — portable type surface.
 *
 * SOURCE OF TRUTH. This module is the canonical home of the host-config
 * shape, canonicalizer, and hash.
 *
 * The canonicalizer is no longer hand-mirrored: mcpjam-backend PR #409
 * collapsed the mirror into a one-import delegation, so
 * `convex/lib/hostConfigV2.ts` IMPORTS `canonicalizeHostConfigV2` from
 * `@mcpjam/sdk/host-config/internal`. There is exactly one canonicalizer and
 * one golden-vector fixture (`sdk/tests/host-config-parity.test.ts`) — no
 * cross-repo parity ritual, and nothing to regenerate unless you
 * intentionally change an existing vector's canonical output.
 *
 * The backend does still hand-mirror the TYPES and, more importantly, keeps
 * an explicit persistence projection that copies known fields onto the stored
 * document. A new optional field added here is hashed by the shared
 * canonicalizer but will NOT be persisted until that projection and the
 * Convex validator learn about it — so ship the backend half in the same
 * change set as anything that must round-trip.
 *
 * Pure + browser-safe: no `convex/values`, no `ctx.db`, no Node-only APIs.
 */

/**
 * Identifier of a host-config host style. Storage is a free-form string —
 * the canonical "what's a registered host" check lives in the inspector
 * client's `lib/host-styles` registry, not here. Treated as an opaque
 * pointer into that registry so users can register custom hosts (BYO)
 * without a backend deploy.
 */
type HostConfigStyle = string;
/**
 * Public alias of {@link HostConfigStyle}. **Intentionally `string`**, not a
 * closed union — the host registry is extensible (users can register custom
 * host styles via the client's `lib/host-styles` registry without an SDK or
 * backend deploy). Don't "tighten" this to `'mcpjam' | 'claude' | 'chatgpt'`;
 * it would break BYO hosts.
 */
type HostStyleId = HostConfigStyle;
/**
 * Opaque MCP server identifier. The backend brands this as `Id<'servers'>`;
 * the portable core treats it as a plain string because the canonicalizer
 * only sorts/dedupes serverIds — it never dereferences them.
 */
type ServerId = string;
declare const HOST_CONFIG_SCHEMA_VERSION_V2 = 2;
/**
 * Every harness id the persistence layer accepts. This is the portable
 * **persistence-contract source of truth**: the inspector's server registry and
 * the backend's hand-mirrored validator each assert parity with this list (so the
 * copies can't silently drift), and the canonicalizer rejects anything not in it.
 * Adding a runtime is a one-line addition here + a registry adapter + tests —
 * never a schema migration (absent ⇒ emulated still hashes byte-identically).
 */
declare const HARNESS_IDS: readonly ["claude-code", "codex"];
/**
 * Which real agent **harness** runs a host's turn. Absent ⇒ the MCPJam
 * **emulated** loop — the only historical behavior, so pre-feature rows hash
 * byte-identically (the key is simply never written). `"claude-code"` runs the
 * turn inside a real Claude Code runtime via the AI SDK harness; `"codex"` runs
 * OpenAI Codex. Extensible to additional runtimes (e.g. `"pi"`) later without a
 * schema migration.
 */
type Harness = (typeof HARNESS_IDS)[number];
/** Type guard — the single membership check every layer routes through. */
declare function isHarness(value: unknown): value is Harness;
type McpToolResultImageRenderPlacement = "none" | "collapsed" | "inline";
type McpToolResultImageRenderingPolicy = {
    placement?: McpToolResultImageRenderPlacement;
    directContent?: {
        image?: boolean;
    };
    embeddedResources?: {
        blob?: {
            image?: boolean;
        };
    };
    linkedResources?: {
        blob?: {
            image?: boolean;
        };
    };
};
type McpToolResultImageRendering = McpToolResultImageRenderingPolicy;
/**
 * Permissions Policy feature tokens corresponding to the four
 * SEP-1865 spec permissions. These are the KEBAB-CASE browser tokens
 * (as they appear in iframe `allow=` attributes), NOT the camelCase
 * mcpProfile.permissions.allow keys. The canonicalizer uses this list to
 * drop these features from `allowFeatures` (they belong in
 * `permissions.allow`).
 *
 * Naming gap (intentional): `permissions.allow.clipboardWrite` (camel,
 * spec field name) ↔ `allowFeatures["clipboard-write"]` (kebab,
 * Permissions Policy token). Do NOT normalize casing on either side.
 */
declare const SEP_1865_PERMISSION_FEATURES: readonly ["camera", "microphone", "geolocation", "clipboard-write"];
type HostConfigConnectionDefaults = {
    headers: Record<string, string>;
    requestTimeout: number;
};
/**
 * Whether the simulated client mirrors `x-mcp-header`-annotated tool
 * arguments into `Mcp-Param-*` HTTP headers on `tools/call`
 * (SEP-2243, integrated into MCP `2026-07-28`).
 *
 * - `"mirror"` — spec-conforming, and the behavior you get when the field is
 *   absent. Declared arguments ride as `Mcp-Param-{Name}` headers.
 * - `"omit"` — simulate a NON-conforming client that never sends them. Real
 *   clients in the wild are uneven here (browser clients never mirror;
 *   MCPJam itself didn't until #3620), so this is how you check what your
 *   server does when the headers don't arrive — including whether it answers
 *   `-32020 HeaderMismatch` rather than silently serving the request.
 *
 * A property of the simulated CLIENT, not of one server, so it lives here
 * rather than on `serverConnectionOverrides`. An enum rather than a boolean
 * to leave room for future modes (e.g. a deliberately-corrupt value).
 */
type ToolParamHeaderMirroring = "mirror" | "omit";
/**
 * How the simulated client walks paginated list results (`tools/list`,
 * `resources/list`, `resources/templates/list`, `prompts/list`).
 *
 * - `"full"` — follow `nextCursor` to exhaustion (spec-conforming client
 *   behavior, and what an ABSENT field means).
 * - `"firstPageOnly"` — treat page one as the complete result, the way
 *   several real hosts notoriously do. Lets a server author answer "do my
 *   important tools survive a first-page-only host?".
 *
 * Deliberate interaction: the SEP-2243 `Mcp-Param-*` mirroring source is
 * the aggregated list cache, so under this mode params are mirrored only
 * for page-one tools — which is exactly how such a client really behaves.
 *
 * Era- and transport-agnostic: pagination has existed since `2025-03-26`,
 * and the enforcement seam is a transport wrapper (not the fetch layer), so
 * it applies on stdio as well as Streamable HTTP. Only the cursor-less
 * aggregation is truncated — an explicit-cursor request is the debugger's
 * own manual paging, not something the emulated client did.
 */
type PaginationTraversalMode = "full" | "firstPageOnly";
/**
 * Whether the simulated client drives MRTR (multi-round tool result) at
 * all — i.e. whether it understands `resultType: "input_required"` and
 * retries the original request with `inputResponses`, or treats the result
 * as terminal. Real clients differ on whether they implement the 2026
 * pattern at all, which is the fact this models.
 *
 * - `"full"` — drive `input_required` rounds (and what an ABSENT field
 *   means).
 * - `"none"` — no MRTR: the modern connection must not advertise a
 *   capability the MRTR bridge would have to fulfill (advertise = enforce),
 *   and an `input_required` result surfaces to the caller instead of
 *   silently looping.
 *
 * WHICH elicitation modes an MRTR-capable client fulfills is a separate,
 * already-modeled fact: `clientCapabilities.elicitation.{form,url}`.
 * This knob is only about the retry loop existing.
 */
type MrtrSupport = "full" | "none";
type CspDomainSet = {
    connectDomains?: string[];
    resourceDomains?: string[];
    frameDomains?: string[];
    baseUriDomains?: string[];
};
type HostConfigMcpProfileV1 = {
    profileVersion: 1;
    mcpProtocolVersion?: McpProtocolVersion | "auto";
    toolParamHeaderMirroring?: ToolParamHeaderMirroring;
    paginationTraversal?: PaginationTraversalMode;
    mrtrSupport?: MrtrSupport;
    toolListChanged?: {
        listens?: boolean;
        refetches?: boolean;
    };
    initialize?: {
        supportedProtocolVersions?: string[];
        clientInfo?: Record<string, unknown>;
    };
    apps?: {
        sandbox?: {
            csp?: {
                mode?: "host-default" | "declared" | "relaxed";
                restrictTo?: CspDomainSet;
                cspDirectives?: Record<string, string[]>;
                extensions?: Record<string, unknown>;
            };
            permissions?: {
                mode?: "resource-declared" | "deny-all" | "custom";
                allow?: Record<string, boolean>;
                extensions?: Record<string, unknown>;
            };
            browserStorage?: {
                localStorage?: boolean;
                sessionStorage?: boolean;
                indexedDB?: boolean;
            };
            sandboxAttrs?: string[];
            allowFeatures?: Record<string, string>;
        };
        uiInitialize?: {
            hostInfo?: Record<string, unknown>;
        };
        compatRuntime?: {
            openaiApps?: boolean;
            openaiAppsOverrides?: OpenAiAppsCapabilities;
        };
        mcpAppsOverrides?: McpAppsCapabilities;
    };
    extensions?: Record<string, unknown>;
};
type OpenAiAppsCapabilities = {
    callTool?: boolean;
    sendFollowUpMessage?: boolean;
    setWidgetState?: boolean;
    requestDisplayMode?: "all" | "fullscreen-only" | "none";
    notifyIntrinsicHeight?: boolean;
    openExternal?: boolean;
    setOpenInAppUrl?: boolean;
    requestModal?: boolean;
    uploadFile?: boolean;
    selectFiles?: boolean;
    getFileDownloadUrl?: boolean;
    requestCheckout?: boolean;
    requestClose?: boolean;
};
type McpAppsCapabilities = {
    availableDisplayModes?: ("inline" | "fullscreen" | "pip")[];
    toolInputPartial?: boolean;
    toolCancelled?: boolean;
    hostContextChanged?: boolean;
    resourceTeardown?: boolean;
    toolInfo?: boolean;
    openLinks?: boolean;
    serverTools?: boolean;
    serverResources?: boolean;
    logging?: boolean;
    updateModelContext?: boolean;
    message?: boolean;
    sandboxPermissions?: boolean;
    cspFrameDomains?: boolean;
    cspBaseUriDomains?: boolean;
    cspConnectDomains?: {
        fetch?: boolean;
        xhr?: boolean;
        websocket?: boolean;
    };
    cspResourceDomains?: {
        script?: boolean;
        stylesheet?: boolean;
        image?: boolean;
        font?: boolean;
        media?: boolean;
    };
    resourceCacheTtl?: boolean;
    toolResult?: {
        structuredContent?: boolean;
        content?: {
            text?: boolean;
            image?: boolean;
            audio?: boolean;
            resource?: boolean;
            resourceLink?: boolean;
        };
    };
    resourcePrefersBorder?: boolean;
    downloadFile?: boolean;
    requestTeardown?: boolean;
    widgetDisplayModeRequests?: "accept" | "user-initiated-only" | "decline";
};
declare const OAUTH_PROFILE_EVIDENCE_STATUSES: readonly ["verified", "refuted", "unverifiable"];
/**
 * Verification state of a single profile field.
 *   `verified`     — read in first-party source or official docs.
 *   `refuted`      — positive evidence the claim is FALSE. Carries the true
 *                    value, so a refutation is durable and can't be
 *                    re-proposed later (HP-45 "keep refuted lore out").
 *   `unverifiable` — could not be confirmed. Carries a reason, never a value.
 */
type OAuthProfileEvidenceStatus = (typeof OAUTH_PROFILE_EVIDENCE_STATUSES)[number];
/**
 * A profile field plus the evidence behind it.
 *
 * The union is the load-bearing part: `value` exists on the verified/refuted
 * arm ONLY. There is no way to spell "I think it's X but I couldn't check" —
 * that input is a type error in TS and a canonicalizer throw for untyped JS
 * callers. Downstream consumers (HP-43 emulator enforcement) can therefore
 * treat "has a value" as "is evidence-backed" without a second check.
 */
type OAuthProfileEvidence<T> = {
    status: "verified" | "refuted";
    value: T;
    /** Citation: an absolute URL, or `repo/path.ts:123`. Non-empty. */
    source: string;
    /** ISO calendar date (`YYYY-MM-DD`) the evidence was captured. */
    capturedAt: string;
} | {
    status: "unverifiable";
    /** Why it could not be confirmed (e.g. "closed-source client"). */
    reason: string;
    /** Optional: when the attempt was made, for staleness tracking. */
    capturedAt?: string;
};
declare const OAUTH_AUTH_MODELS: readonly ["oauth2-dcr", "oauth2-cimd", "oauth2-preregistered", "api-key", "none"];
/**
 * One way a client can authenticate to an MCP server.
 *
 * `oauth2-cimd` (Client ID Metadata Documents) is kept distinct from
 * `oauth2-dcr`: both obtain a client identity, but DCR self-asserts metadata
 * to a `registration_endpoint` (RFC 7591) while CIMD anchors identity to a
 * fetchable URL. A server that supports one does not necessarily support the
 * other, so collapsing them would lose the distinction the emulator needs.
 */
type OAuthAuthModel = (typeof OAUTH_AUTH_MODELS)[number];
/**
 * An MCP authorization-spec revision, as its `YYYY-MM-DD` stamp.
 *
 * Deliberately NOT `McpProtocolVersion`. That enum is the set of revisions
 * *this inspector speaks*, which is a different set from the revisions a
 * third-party client implements: Cline's bundled SDK supports `2024-11-05`
 * and `2024-10-07`, and `rmcp` pins `2024-11-05` on OAuth discovery — none of
 * which are members. Reusing the enum silently made real, sourced findings
 * unrecordable. Validated by FORMAT (a real calendar date), not membership,
 * so a client on an older or newer revision than we support is still
 * expressible.
 */
type OAuthSpecRevision = string;
/**
 * What we actually know about a client's OAuth spec revision.
 *
 * Two arms, because the evidence comes in two genuinely different strengths
 * and collapsing them would overstate the weaker one:
 *
 *   `constant`   — a literal revision string exists in the client's source.
 *                  `revisions` is the EXACT set it implements (clients are
 *                  often multi-revision: MCPJam ships four state machines).
 *   `behavioral` — no revision constant exists anywhere in the client (this
 *                  is the real state of VS Code), so the revision is inferred
 *                  from observed OAuth shape — e.g. an RFC 9728 PRM ladder
 *                  implies 2025-06-18 or later. `minimumRevision` is a FLOOR,
 *                  NOT an exact value.
 *
 * Keeping the floor distinct from the exact set is what lets a behavioral
 * finding be recorded as `verified` honestly: the verified claim is "at least
 * this revision", not "exactly this revision".
 */
type OAuthSpecVersionClaim = {
    basis: "constant";
    revisions: OAuthSpecRevision[];
} | {
    basis: "behavioral";
    minimumRevision: OAuthSpecRevision;
};
/**
 * Whether the client hardcodes `MCP-Protocol-Version` or negotiates it.
 * Discriminated so "pinned" cannot be recorded without the pinned value.
 */
type OAuthProtocolVersionPinning = {
    mode: "pinned";
    version: OAuthSpecRevision;
} | {
    mode: "negotiated";
};
/**
 * The exact identity a client asserts at Dynamic Client Registration.
 *
 * Per RFC 7591 this metadata is self-asserted and therefore attacker
 * controllable, so it is NOT a sound input to server authorization policy —
 * but servers in the wild DO gate on `clientName`, so emulators must replay
 * these strings byte-exactly to reproduce real-world behavior. Recorded as
 * observation, not endorsement.
 */
type OAuthDcrIdentity = {
    clientName?: string;
    redirectUris?: string[];
    userAgent?: string;
};
/**
 * Per-host OAuth handshake profile. Every field optional and absent-by-default
 * so a host that has not been investigated yet hashes byte-identically to a
 * pre-feature row.
 */
type HostConfigOAuthProfileV1 = {
    profileVersion: 1;
    /** RFC 8707: does the client send `resource` on /authorize + /token? */
    sendsResourceIndicator?: OAuthProfileEvidence<boolean>;
    /**
     * Which MCP authorization spec revision(s) the client's OAuth layer
     * implements. Drives the discovery ladder — notably, clients on
     * `2025-03-26` assume same-origin AS endpoints. Modeled as the spec
     * revision, NOT as a standalone "same-origin" quirk flag, so the behavior
     * is derived from one fact instead of duplicated across two fields that can
     * disagree.
     *
     * This is the OAUTH layer only. The MCP layer's version lives in
     * `protocolVersionPinning`, and the two genuinely disagree in the wild —
     * Goose runs a PRM-era OAuth ladder while hard-pinning 2025-03-26 on MCP.
     */
    oauthSpecVersion?: OAuthProfileEvidence<OAuthSpecVersionClaim>;
    protocolVersionPinning?: OAuthProfileEvidence<OAuthProtocolVersionPinning>;
    dcrIdentity?: OAuthProfileEvidence<OAuthDcrIdentity>;
    /**
     * Every auth model the client supports, **in preference order** — the first
     * entry is what it reaches for first.
     *
     * A list rather than a single value because real clients are almost never
     * single-mode: Claude advertises six paths, Slack four, and both Codex and
     * Goose try static headers/bearer BEFORE falling back to OAuth on a 401.
     * Recording only a primary mode would discard the fallbacks an emulator has
     * to reproduce, and recording an unordered set would discard the precedence.
     *
     * Order is therefore semantic and is preserved verbatim — NOT sorted (same
     * convention as `mcpProfile.initialize.supportedProtocolVersions`).
     * Duplicates are rejected rather than deduped, since a repeated entry means
     * the caller's precedence list is ambiguous.
     *
     * `none` is the one entry that is not a mechanism but the absence of one —
     * it is how "this client has no auth" is spelled (see `oauthProfile` on
     * `HostConfigInputV2`). It is therefore rejected unless it is the SOLE
     * entry: `["none", "oauth2-dcr"]` claims the client both does and does not
     * authenticate, which is not a preference an emulator can honor.
     */
    authModel?: OAuthProfileEvidence<OAuthAuthModel[]>;
    extensions?: Record<string, unknown>;
};
declare const OAUTH_SCOPE_REQUEST_MODES: readonly ["omit", "fixed", "challenge", "all-supported"];
type OAuthScopeRequestMode = (typeof OAUTH_SCOPE_REQUEST_MODES)[number];
/**
 * How a client populates the `scope` parameter on the authorization request.
 *
 *   `omit`          — never sends `scope`.
 *   `fixed`         — always sends the same captured scope list. Discriminated
 *                     so "fixed" cannot be recorded without the scopes (same
 *                     convention as `OAuthProtocolVersionPinning`). Order is
 *                     the captured wire order — preserved verbatim, duplicates
 *                     rejected — because the emulator replays the scope string
 *                     byte-exactly.
 *   `challenge`     — echoes the scopes from the `WWW-Authenticate` challenge.
 *   `all-supported` — sends the AS metadata's `scopes_supported`.
 */
type OAuthScopeRequest = {
    mode: "omit";
} | {
    mode: "fixed";
    scopes: string[];
} | {
    mode: "challenge";
} | {
    mode: "all-supported";
};
declare const OAUTH_TOKEN_ENDPOINT_AUTH_METHODS: readonly ["none", "client_secret_basic", "client_secret_post"];
/**
 * RFC 7591 `token_endpoint_auth_method` a client asserts at registration and
 * honors at the token endpoint. Closed set — a future method must be added
 * here deliberately, not smuggled in as a free string.
 */
type OAuthTokenEndpointAuthMethod = (typeof OAUTH_TOKEN_ENDPOINT_AUTH_METHODS)[number];
/**
 * Per-host OAuth handshake profile, version 2 (HP-43 emulator inputs).
 *
 * V2 exists alongside V1 — V1 canonicalization is FROZEN and V1 rows are
 * never rewritten, so every existing content-addressed hash stays valid. A
 * profile opts into V2 by writing `profileVersion: 2`; absent fields are
 * omitted from the canonical JSON exactly like V1 (never null/default-filled).
 *
 * Differences from V1, both in service of byte-exact wire replay:
 *   - two new evidence-backed fields: `scopeRequest` and
 *     `tokenEndpointAuthMethod`;
 *   - `dcrIdentity.redirectUris` preserves the CAPTURED order and rejects
 *     duplicates, where V1 deduped + sorted. The registration body the
 *     emulator sends must match what the real client sent, and that includes
 *     array order.
 *   - `dcrIdentity.clientName` is stored verbatim, where V1 trimmed —
 *     surrounding whitespace in a capture is part of the string a server may
 *     gate on. Empty/whitespace-only is still rejected as a missing capture.
 */
type HostConfigOAuthProfileV2 = {
    profileVersion: 2;
    sendsResourceIndicator?: OAuthProfileEvidence<boolean>;
    oauthSpecVersion?: OAuthProfileEvidence<OAuthSpecVersionClaim>;
    protocolVersionPinning?: OAuthProfileEvidence<OAuthProtocolVersionPinning>;
    dcrIdentity?: OAuthProfileEvidence<OAuthDcrIdentity>;
    authModel?: OAuthProfileEvidence<OAuthAuthModel[]>;
    scopeRequest?: OAuthProfileEvidence<OAuthScopeRequest>;
    tokenEndpointAuthMethod?: OAuthProfileEvidence<OAuthTokenEndpointAuthMethod>;
    extensions?: Record<string, unknown>;
};
/** Either profile version. V1 rows stay V1 — there is no auto-upgrade. */
type HostConfigOAuthProfile = HostConfigOAuthProfileV1 | HostConfigOAuthProfileV2;
type HostConfigComputerKind = "personal" | "ephemeral";
type HostConfigComputer = {
    kind: HostConfigComputerKind;
    workdir?: string;
};
type HostConfigComputerInput = {
    kind: HostConfigComputerKind;
    toolset?: "bash";
    workdir?: string;
};
/**
 * Skill selection policy for a host (OpenAI plugin import, PR SDK-2).
 * Controls which project skills a selection-aware runtime advertises.
 * Plugin-imported skills are ordinary materialized skill rows and are
 * selectable by id here exactly like any standalone skill — the UI groups
 * them by plugin provenance, but there is no separate selection channel.
 *
 * Input-side union:
 *   - absent (`undefined`)          → legacy all-visible behavior.
 *   - `{ mode: "all-visible" }`     → explicit spelling of the same behavior;
 *                                     canonicalized to ABSENT (see
 *                                     `canonicalizeSkillSelection`).
 *   - `{ mode: "explicit", skillIds }` → only the listed skills;
 *                                     `skillIds: []` means "explicitly none"
 *                                     and hashes distinctly from absent.
 */
type HostConfigSkillSelection = {
    mode: "all-visible";
} | {
    mode: "explicit";
    skillIds: string[];
};
/**
 * Canonical-side skill selection. Only the explicit variant survives
 * canonicalization — `{ mode: "all-visible" }` collapses to absent so one
 * runtime behavior has exactly one content-addressed identity.
 */
type CanonicalHostConfigSkillSelection = {
    mode: "explicit";
    skillIds: string[];
};
type McpToolResultBlobVisibility = {
    enabled?: boolean;
    image?: boolean;
    audio?: boolean;
    document?: boolean;
    video?: boolean;
    otherBinary?: boolean;
};
type ModelVisibleMcpToolResults = {
    directContent?: {
        text?: boolean;
        image?: boolean;
        audio?: boolean;
    };
    embeddedResources?: {
        text?: boolean;
        blob?: McpToolResultBlobVisibility;
    };
    linkedResources?: {
        text?: boolean;
        blob?: McpToolResultBlobVisibility;
    };
};
type HostConfigInputV2 = {
    hostStyle: HostConfigStyle;
    modelId: string;
    systemPrompt: string;
    temperature: number;
    requireToolApproval: boolean;
    progressiveToolDiscovery?: boolean;
    respectToolVisibility?: boolean;
    computer?: HostConfigComputerInput | null;
    harness?: Harness;
    serverIds?: Array<ServerId>;
    optionalServerIds?: Array<ServerId>;
    builtInToolIds?: ReadonlyArray<string>;
    skillSelection?: HostConfigSkillSelection;
    modelVisibleMcpToolResults?: ModelVisibleMcpToolResults;
    mcpToolResultImageRendering?: McpToolResultImageRendering;
    connectionDefaults: HostConfigConnectionDefaults;
    clientCapabilities: Record<string, unknown>;
    hostContext: Record<string, unknown>;
    hostCapabilitiesOverride?: Record<string, unknown>;
    chatUiOverride?: Record<string, unknown>;
    mcpProfile?: HostConfigMcpProfileV1;
    oauthProfile?: HostConfigOAuthProfile;
    serverConnectionOverrides?: Record<string, {
        headersOverride?: Record<string, string>;
        requestTimeoutOverride?: number;
        mcpProtocolVersionOverride?: McpProtocolVersion;
    }>;
};
type CanonicalHostConfigV2 = {
    schemaVersion: typeof HOST_CONFIG_SCHEMA_VERSION_V2;
    hostStyle: HostConfigStyle;
    modelId: string;
    systemPrompt: string;
    temperature: number;
    requireToolApproval: boolean;
    progressiveToolDiscovery?: boolean;
    respectToolVisibility?: boolean;
    computer?: HostConfigComputer;
    harness?: Harness;
    serverIds: Array<ServerId>;
    optionalServerIds: Array<ServerId>;
    builtInToolIds?: Array<string>;
    skillSelection?: CanonicalHostConfigSkillSelection;
    modelVisibleMcpToolResults?: ModelVisibleMcpToolResults;
    mcpToolResultImageRendering?: McpToolResultImageRendering;
    connectionDefaults: HostConfigConnectionDefaults;
    clientCapabilities: Record<string, unknown>;
    hostContext: Record<string, unknown>;
    hostCapabilitiesOverride?: Record<string, unknown>;
    chatUiOverride?: Record<string, unknown>;
    mcpProfile?: HostConfigMcpProfileV1;
    oauthProfile?: HostConfigOAuthProfile;
    serverConnectionOverrides?: Record<string, {
        headersOverride?: Record<string, string>;
        requestTimeoutOverride?: number;
        mcpProtocolVersionOverride?: McpProtocolVersion;
    }>;
};

export { type OAuthProfileEvidenceStatus as A, type OAuthProtocolVersionPinning as B, type CanonicalHostConfigV2 as C, type OAuthScopeRequestMode as D, type OAuthSpecRevision as E, type OAuthSpecVersionClaim as F, SEP_1865_PERMISSION_FEATURES as G, type HostConfigSkillSelection as H, isHarness as I, MCP_PROTOCOL_VERSIONS as J, type MrtrSupport as K, type OpenAiAppsCapabilities as L, type McpProtocolVersion as M, isKnownProtocolVersion as N, type OAuthScopeRequest as O, type PaginationTraversalMode as P, isStatelessProtocolVersion as Q, protocolVersionLabel as R, type ServerId as S, type ToolParamHeaderMirroring as T, type HostConfigConnectionDefaults as a, type HostConfigMcpProfileV1 as b, type HostStyleId as c, type ModelVisibleMcpToolResults as d, type McpToolResultImageRendering as e, type Harness as f, type HostConfigComputer as g, type McpToolResultImageRenderingPolicy as h, type McpToolResultImageRenderPlacement as i, type McpAppsCapabilities as j, type OAuthTokenEndpointAuthMethod as k, type HostConfigInputV2 as l, type HostConfigOAuthProfile as m, type CanonicalHostConfigSkillSelection as n, type CspDomainSet as o, HARNESS_IDS as p, HOST_CONFIG_SCHEMA_VERSION_V2 as q, type HostConfigOAuthProfileV1 as r, type HostConfigOAuthProfileV2 as s, OAUTH_AUTH_MODELS as t, OAUTH_PROFILE_EVIDENCE_STATUSES as u, OAUTH_SCOPE_REQUEST_MODES as v, OAUTH_TOKEN_ENDPOINT_AUTH_METHODS as w, type OAuthAuthModel as x, type OAuthDcrIdentity as y, type OAuthProfileEvidence as z };