@rtrvr-ai/rover 3.0.1 → 4.0.1

package/README.md

@@ -39,12 +39,14 @@ Add this snippet before `</body>` on any page:
 <script src="https://rover.rtrvr.ai/embed.js" async></script>
 ```
 
-If RoverBook is enabled for the site in Rover Workspace, the generated install snippet also includes `https://rover.rtrvr.ai/roverbook.js` plus an inline attach block that calls `window.RoverBook.enableRoverBook(window.rover, ...)`. Copy the Workspace snippet as-is for production installs.
+If Agent analytics is enabled for the site in Rover Workspace, the generated install snippet also includes `https://rover.rtrvr.ai/roverbook.js` plus an inline attach block that calls `window.RoverBook.enableRoverBook(window.rover, ...)`. Copy the Workspace snippet as-is for production installs.
 
 Workspace also controls site mode:
 
-- `Full Rover agent`: action-capable Rover runtime
-- `RoverBook analytics-only`: embed-oriented RoverBook deployment with action tools disabled
+- `Rover Agent`: action-capable Rover runtime plus Agent analytics
+- `Agent Analytics`: embed-oriented analytics deployment with action tools disabled
+
+Workspace onboarding now also gives site owners a dedicated Journeys step for shortcuts, defaults new production site keys to `No expiry`, and exposes `Cloud sandboxes` as the single owner-facing switch for cloud execution plus approved third-party browsing.
 
 Get `siteId`, `publicKey` (`pk_site_*`), and optional `siteKeyId` from Rover Workspace:
 
@@ -76,7 +78,7 @@ Common patterns:
 - `allowedDomains: ['example.com']` with `registrable_domain` allows `example.com` and all subdomains.
 - `allowedDomains: ['*.example.com']` allows subdomains only, not the apex host.
 - `allowedDomains: ['app.example.com']` with `registrable_domain` allows `app.example.com` and its subdomains, but not sibling hosts.
-- `allowedDomains: ['example.com']` with `host_only` allows only the exact host `example.com`.
+- `allowedDomains: ['example.com']` with `host_only` allows only the exact host `example.com`; sibling subdomains are blocked unless you explicitly list them.
 
 ## Preview Helpers
 
@@ -85,8 +87,12 @@ The SDK also exports generic helper utilities for live demos and previews:
 ```ts
 import {
   attachLaunch,
+  createRoverAgentCardJson,
+  createRoverAgentDiscoveryTags,
   createRoverBookmarklet,
   createRoverConsoleSnippet,
+  createRoverOwnerInstallBundle,
+  createRoverServiceDescLinkHeader,
   createRoverScriptTagSnippet,
 } from '@rtrvr-ai/rover';
 ```
@@ -116,6 +122,10 @@ Before you use any of these helpers on another website:
   Best for quick one-click demos across many pages, with the same current-page limitations as manual injection.
 - `createRoverScriptTagSnippet(...)`
   Best for generating an actual snippet from known config values such as Workspace `siteId` and `publicKey`.
+- `createRoverOwnerInstallBundle(...)`
+  Best for canonical owner-facing install output when you need a body-safe runtime snippet plus separate head discovery HTML, `rover-site.json`, `agent-card.json`, and optional `llms.txt`.
+- `createRoverAgentCardJson(...)`, `createRoverAgentDiscoveryTags(...)`, `createRoverServiceDescLinkHeader(...)`
+  Best for publishing source-visible discovery metadata so arbitrary agents can find Rover skills before falling back to DOM automation.
 - `attachLaunch(...)`
   Best when you already created a launch elsewhere and want Rover to attach to it after boot.
 
@@ -167,6 +177,44 @@ const snippet = createRoverScriptTagSnippet({
 });
 ```
 
+### Example: canonical owner install bundle
+
+```ts
+import { createRoverOwnerInstallBundle } from '@rtrvr-ai/rover';
+
+const bundle = createRoverOwnerInstallBundle({
+  bootConfig: {
+    siteId: 'site_123',
+    publicKey: 'pk_site_123',
+    siteKeyId: 'key_123',
+    allowedDomains: ['example.com'],
+    domainScopeMode: 'registrable_domain',
+    cloudSandboxEnabled: true,
+    ui: {
+      shortcuts: [
+        { id: 'book_demo', label: 'Book demo', prompt: 'Help me book a demo.' },
+      ],
+    },
+  },
+  discovery: {
+    siteId: 'site_123',
+    siteUrl: 'https://example.com/',
+    siteName: 'Example Store',
+    roverSiteUrl: '/.well-known/rover-site.json',
+    agentCardUrl: '/.well-known/agent-card.json',
+    llmsUrl: '/llms.txt',
+  },
+  emitLlmsTxt: true,
+});
+
+bundle.bodyInstallHtml;     // paste before </body>
+bundle.headDiscoveryHtml;   // place in <head> or managed head custom code
+bundle.roverSiteJson;       // publish at /.well-known/rover-site.json
+bundle.agentCardJson;       // publish at /.well-known/agent-card.json
+bundle.serviceDescLinkHeader;
+bundle.llmsTxt;
+```
+
 ### Example: attach a pre-created launch
 
 ```ts
@@ -210,6 +258,52 @@ If you want a public extension that can use either config source, see the Previe
 - [https://github.com/rtrvr-ai/rover/tree/main/apps/preview-helper](https://github.com/rtrvr-ai/rover/tree/main/apps/preview-helper)
 - [https://www.rtrvr.ai/rover/docs/instant-preview-api](https://www.rtrvr.ai/rover/docs/instant-preview-api)
 
+### Agent Discovery Publishing
+
+Use the new discovery helpers when you want generic agents to see explicit Rover skills before they start clicking through the DOM:
+
+```ts
+import {
+  createRoverAgentCardJson,
+  createRoverAgentDiscoveryTags,
+  createRoverServiceDescLinkHeader,
+} from '@rtrvr-ai/rover';
+
+const agentCardJson = createRoverAgentCardJson({
+  siteUrl: 'https://example.com/',
+  siteName: 'Example Store',
+  shortcuts: [
+    {
+      id: 'start_checkout',
+      label: 'Start Checkout',
+      prompt: 'start checkout',
+      description: 'Launch the checkout flow directly.',
+      tags: ['checkout', 'commerce'],
+      examples: ['Start checkout for the current cart.'],
+      sideEffect: 'transactional',
+      requiresConfirmation: true,
+    },
+  ],
+});
+
+const discoveryTags = createRoverAgentDiscoveryTags({
+  siteUrl: 'https://example.com/',
+  siteName: 'Example Store',
+});
+
+const linkHeader = createRoverServiceDescLinkHeader({
+  agentCardUrl: '/.well-known/agent-card.json',
+  llmsUrl: '/llms.txt',
+});
+```
+
+Recommended rollout:
+
+1. Serve `roverSiteJson` at `/.well-known/rover-site.json`.
+2. Serve `agentCardJson` at `/.well-known/agent-card.json`.
+3. Add `discoveryTags` near the Rover snippet in page source.
+4. Add the `Link` header generated by `createRoverServiceDescLinkHeader(...)`.
+
 ### Hosted preview handoff behavior
 
 The open-source helper extension understands hosted preview handoff URLs that include:
@@ -327,9 +421,9 @@ const RoverWidget = dynamic(() => import('./RoverWidget'), { ssr: false });
 | `visitor` | `{ name?: string; email?: string }` | — | Optional visitor profile for greeting personalization. Recommended flow is async updates via `identify(...)` after login/user hydration. |
 | `apiBase` | `string` | `https://agent.rtrvr.ai` | Optional API base override. Rover uses `/v2/rover/*` under this base. |
 | `allowedDomains` | `string[]` | `[]` | Hostnames or patterns where Rover may operate. In `registrable_domain`, plain `example.com` covers the apex host and subdomains. |
-| `domainScopeMode` | `'registrable_domain' \| 'host_only'` | `'registrable_domain'` | How Rover interprets plain `allowedDomains` entries: `registrable_domain` = apex + subdomains, `host_only` = exact host only. |
-| `externalNavigationPolicy` | `'open_new_tab_notice' \| 'block' \| 'allow'` | `'open_new_tab_notice'` | External navigation policy |
-| `navigation.crossHostPolicy` | `'same_tab' \| 'open_new_tab'` | `'same_tab'` | In-scope cross-host navigation policy |
+| `domainScopeMode` | `'registrable_domain' \| 'host_only'` | `'registrable_domain'` | How Rover interprets plain `allowedDomains` entries: `registrable_domain` = apex + subdomains, `host_only` = exact host only unless you explicitly allow more hosts. |
+| `externalNavigationPolicy` | `'open_new_tab_notice' \| 'block' \| 'allow'` | `'open_new_tab_notice'` | Advanced / legacy external navigation override. Standard owner-facing installs rely on Rover's default new-tab-with-notice behavior outside allowed scope. |
+| `navigation.crossHostPolicy` | `'same_tab' \| 'open_new_tab'` | `'same_tab'` | Advanced / legacy in-scope cross-host override. Standard owner-facing installs let Rover choose the right tab automatically. |
 | `mode` | `'full' \| 'safe'` | `'full'` | Runtime mode |
 | `allowActions` | `boolean` | `true` | Enable or disable action tools |
 | `openOnInit` | `boolean` | `false` | Open panel immediately on boot |
@@ -413,14 +507,17 @@ const RoverWidget = dynamic(() => import('./RoverWidget'), { ssr: false });
 | Option | Type | Default | Description |
 |---|---|---|---|
 | `ui.agent.name` | `string` | `'Rover'` | Custom assistant name |
-| `ui.mascot.disabled` | `boolean` | `false` | Disable mascot video |
-| `ui.mascot.mp4Url` | `string` | default | Custom mascot MP4 URL |
-| `ui.mascot.webmUrl` | `string` | default | Custom mascot WebM URL |
-| `ui.muted` | `boolean` | `true` | Start with audio muted on first load; stored browser preference wins after the user toggles sound |
+| `ui.mascot.disabled` | `boolean` | `false` | Hide mascot media entirely |
+| `ui.mascot.imageUrl` | `string` | default | Custom mascot image URL. Works by itself or as the fallback/poster for custom video mascots |
+| `ui.mascot.mp4Url` | `string` | default | Custom mascot MP4 URL. Video is preferred when MP4 or WebM is provided |
+| `ui.mascot.webmUrl` | `string` | default | Custom mascot WebM URL. Video is preferred when MP4 or WebM is provided |
+| `ui.mascot.soundEnabled` | `boolean` | `false` | Owner gate for mascot sound. Video mascots stay silent unless this is explicitly `true`; image-only mascots remain silent |
+| `ui.muted` | `boolean` | `true` | Initial mute state only when mascot sound is enabled. Visitor preference is stored per Rover site after they toggle sound. |
 | `ui.thoughtStyle` | `'concise_cards' \| 'minimal'` | `'concise_cards'` | Thought rendering style |
 | `ui.panel.resizable` | `boolean` | `true` | Enables desktop freeform resizing plus phone/tablet snap-height resizing with per-device memory |
 | `ui.showTaskControls` | `boolean` | `true` | Show new/end task controls |
-| `ui.shortcuts` | `RoverShortcut[]` | `[]` | Suggested journeys (max 100 stored, max 12 rendered by default; lower site-key policy caps are enforced) |
+| `ui.shortcuts` | `RoverShortcut[]` | `[]` | Suggested journeys (max 100 stored, max 12 rendered by default; lower site-key policy caps are enforced). Shortcuts can also publish agent-facing metadata such as `tags`, `examples`, `inputSchema`, `outputSchema`, `sideEffect`, and `requiresConfirmation`. |
+| `cloudSandboxEnabled` | `boolean` | `false` | Owner-facing shorthand for cloud execution plus approved third-party browsing. When `true`, Rover materializes `tools.web.enableExternalWebContext=true` and `tools.web.scrapeMode='on_demand'`. |
 | `ui.greeting` | `{ text?, delay?, duration?, disabled? }` | — | Greeting bubble config (`{name}` token supported) |
 | `ui.voice` | `{ enabled?: boolean; language?: string; autoStopMs?: number }` | — | Browser dictation for supported Chromium browsers. Rover fills the draft live, waits for post-speech silence before stopping, and the user still sends manually. |
 
@@ -433,7 +530,8 @@ const RoverWidget = dynamic(() => import('./RoverWidget'), { ssr: false });
 | `tools.web.scrapeMode` | `'off' \| 'on_demand'` | `'off'` | On-demand external tab scrape mode |
 | `tools.web.allowDomains` | `string[]` | `[]` | External context allowlist |
 | `tools.web.denyDomains` | `string[]` | `[]` | External context denylist |
-| `tools.client` | `ClientToolDefinition[]` | `[]` | Runtime-registered client tools |
+| `tools.client` | `ClientToolDefinition[]` | `[]` | Runtime-registered client tools. Tool definitions can include `title`, `outputSchema`, and `annotations` (`whenToUse`, `whyUse`, `examples`, `sideEffect`, `requiresConfirmation`) to improve model tool selection and discovery-card quality. |
+| `agentDiscovery` | `{ enabled?, siteName?, description?, version?, siteUrl?, agentCardUrl?, roverSiteUrl?, llmsUrl?, hostSurfaceSelector?, preferExecution?, discoverySurface?, additionalSkills? }` | — | Optional overrides for Rover's generated discovery surfaces. `rover-site.json` is the authoritative rich profile, `agent-card.json` is the interop card, and `discoverySurface.beaconLabel` now feeds the visible seed/presence CTA text in production. Legacy `visibleCue` / `visibleCueLabel` remain compatibility inputs only. |
 | `pageConfig` | `RoverPageCaptureConfig` | — | Optional per-site page-capture overrides such as `disableAutoScroll`, settle timing, and sparse-tree retry settings |
 
 ### AI-Callable URLs (Deep Links)
@@ -442,7 +540,7 @@ Rover can be triggered via URL query parameters, turning any page into an AI-cal
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `deepLink.enabled` | `boolean` | `false` | Enable URL-triggered Rover |
+| `deepLink.enabled` | `boolean` | derived from `siteConfig.aiAccess.enabled` when available, otherwise `false` | Advanced manual override for URL-triggered Rover |
 | `deepLink.promptParam` | `string` | `'rover'` | Query parameter for natural-language prompts |
 | `deepLink.shortcutParam` | `string` | `'rover_shortcut'` | Query parameter for shortcut IDs |
 | `deepLink.consume` | `boolean` | `true` | Strip deep link params from URL after reading |
@@ -461,11 +559,11 @@ https://example.com?rover_shortcut=checkout_flow
 
 For AI or CLI-triggered entrypoints, prefer exact shortcut IDs for repeatable flows.
 
-When a site key or session token is used, Rover fetches cloud site config via `/v2/rover/session/open` (shortcuts + greeting + voice + pageConfig).
+When a site key or session token is used, Rover fetches cloud site config via `/v2/rover/session/open` (shortcuts + `businessType` + sparse `experience` overrides + legacy voice compatibility + `aiAccess` + `pageConfig`).
 If the same field exists in both cloud config and boot config, boot config wins.
-`deepLink` is boot/runtime only and is not persisted in cloud site config.
+`siteConfig.aiAccess.enabled` is the canonical owner-facing launch switch persisted from Workspace/Webflow. `deepLink` stays boot/runtime only for advanced manual overrides such as custom param names, explicit enable/disable, or disabling URL param consumption.
 
-If you enable `tools.web.scrapeMode: 'on_demand'`, use a site key capability profile that includes cloud scrape support.
+For owner-facing installs, prefer `cloudSandboxEnabled: true` instead of hand-wiring low-level scrape/browser flags. Rover materializes the current runtime fields from that shorthand for you.
 
 See [full configuration reference](https://github.com/rtrvr-ai/rover/blob/main/docs/INTEGRATION.md#configuration-reference).
 
@@ -484,13 +582,22 @@ The source-visible marker is optional but recommended:
 <script type="application/agent+json">{"task":"https://agent.rtrvr.ai/v1/tasks"}</script>
 ```
 
+For stronger pre-task discovery, publish `/.well-known/rover-site.json` as Rover's authoritative rich profile, publish `/.well-known/agent-card.json` as the interop card, add a `Link: </.well-known/agent-card.json>; rel="service-desc"` header, and include inline discovery tags generated by `createRoverAgentDiscoveryTags(...)`.
+
 ```http
 POST https://agent.rtrvr.ai/v1/tasks
 Content-Type: application/json
 
-{ "url": "https://www.rtrvr.ai", "prompt": "get me the latest blog post" }
+{
+  "url": "https://www.rtrvr.ai",
+  "goal": "Get me the latest blog post",
+  "capabilityId": "latest_blog_post",
+  "accept": { "modes": ["text", "json"] }
+}
 ```
 
+Compatibility aliases such as `{ "url": "...", "prompt": "..." }` and `{ "url": "...", "shortcutId": "..." }` still work, but the richer task envelope is the canonical contract.
+
 Callers may also provide structured visiting-agent metadata:
 
 ```http
@@ -499,7 +606,7 @@ Content-Type: application/json
 
 {
   "url": "https://www.rtrvr.ai",
-  "prompt": "get me the latest blog post",
+  "goal": "Get me the latest blog post",
   "agent": {
     "key": "gpt-5.4-demo-agent",
     "name": "GPT-5.4 Demo Agent",
@@ -539,13 +646,13 @@ Rover deep links like `?rover=` and `?rover_shortcut=` remain the simple browser
 
 Rover normalizes visiting-agent attribution in this order:
 
-1. verified signal
+1. verified signed signal
 2. explicit `agent` object on public task creation or handoffs
 3. heuristic headers such as `User-Agent`, `Signature-Agent`, `Signature`, `Signature-Input`, and `X-RTRVR-Client-Id`
 4. advanced local fallbacks such as RoverBook `identityResolver`
 5. anonymous fallback
 
-Current launch behavior emits `self_reported`, `heuristic`, and `anonymous`. `verified` remains reserved for a real verifier and is not inferred from plain headers alone.
+Trust tiers are `verified_signed`, `signed_directory_only`, `self_reported`, `heuristic`, and `anonymous`. Unsigned headers never escalate above `heuristic`.
 
 ### Cross-site workflows and handoffs
 
@@ -583,7 +690,7 @@ Runtime contract notes:
 - `plannerOnActError` applies only in `auto` mode and only when ACT has no usable outcome.
 - Typed conflicts: `stale_seq`, `stale_epoch`, `active_run_exists`.
 - `POST /command` stale/missing run is non-fatal for tab navigation decisions (`decision='stale_run'`).
-- Cross-registrable navigation preflight is resilient: if command-tab decision checks are unavailable, Rover falls back to local policy (in-scope targets follow `navigation.crossHostPolicy`, default `same_tab`; out-of-scope targets follow `externalNavigationPolicy`).
+- Cross-registrable navigation preflight is resilient: if decision checks are unavailable, Rover falls back to local runtime behavior. Standard installs open outside-domain pages in a new tab with notice and choose the right tab automatically for allowed-host hops; explicit legacy overrides still apply when present.
 - External intent routing: `/context/external` uses `read_context` (read/navigation-context prompts) or `act` (mutation prompts). Navigation-only external opens are represented by `POST /command` with `type='TAB_EVENT'` plus external placeholder tab handling.
 - Any normal user send starts a fresh task boundary (fresh `prevSteps`, fresh run-scoped tab order/scope).
 - `ask_user` answer submissions are the only continuation path and keep the same task boundary.
@@ -620,6 +727,7 @@ rover.send('Hello');
 | `newTask(options?)` | Start a new task, clearing context |
 | `endTask(options?)` | End the current task |
 | `getState()` | Get current runtime state |
+| `getAgentCard()` | Build the current Rover capability card from live shortcuts, client tools, and WebMCP metadata |
 | `update(config)` | Update configuration without rebooting |
 | `registerTool(def, handler)` | Register a client-side tool |
 | `requestSigned(url, init?)` | Issue a fetch signed with the current Rover session token and site/session headers |

package/dist/agentDiscovery.d.ts

@@ -0,0 +1,304 @@
+import type { RoverShortcut } from '@rover/ui';
+import { createRoverAgentDiscoverySnapshot } from '@rover/shared/lib/agent-discovery.js';
+import type { RoverAgentDiscoverySnapshot } from '@rover/shared/lib/types/index.js';
+export declare const DEFAULT_AGENT_CARD_PATH = "/.well-known/agent-card.json";
+export declare const DEFAULT_ROVER_SITE_PATH = "/.well-known/rover-site.json";
+export declare const DEFAULT_LLMS_PATH = "/llms.txt";
+export declare const ROVER_WEBMCP_DISCOVERY_GLOBAL = "__ROVER_WEBMCP_TOOL_DEFS__";
+export declare const ROVER_DISCOVERY_ACTION_SHEET_MAX_ACTIONS = 3;
+type JsonSchema = Record<string, any>;
+export type RoverDiscoveryExecutionPreference = 'auto' | 'browser' | 'cloud';
+export type RoverDiscoverySurfaceMode = 'silent' | 'beacon' | 'integrated' | 'debug';
+export type RoverDiscoverySurfaceBranding = 'site' | 'co' | 'rover';
+export type RoverDiscoveryHostSurface = 'auto' | 'existing-assistant' | 'floating-corner' | 'inline-primary';
+export type RoverDiscoveryActionReveal = 'click' | 'focus' | 'keyboard' | 'agent-handshake';
+export type RoverCapabilityResultMode = 'text' | 'markdown' | 'json' | 'observation' | 'artifacts';
+export type RoverSkillSideEffect = 'none' | 'read' | 'write' | 'transactional';
+export type RoverSkillInterface = 'task' | 'shortcut' | 'client_tool' | 'webmcp';
+export type RoverDiscoverySurfacePolicy = {
+    mode?: RoverDiscoverySurfaceMode;
+    branding?: RoverDiscoverySurfaceBranding;
+    hostSurface?: RoverDiscoveryHostSurface;
+    actionReveal?: RoverDiscoveryActionReveal;
+    beaconLabel?: string;
+    agentModeEntryHints?: string[];
+};
+export type RoverToolAnnotations = {
+    category?: string;
+    tags?: string[];
+    examples?: string[];
+    whenToUse?: string;
+    whyUse?: string;
+    sideEffect?: RoverSkillSideEffect;
+    requiresConfirmation?: boolean;
+    preferredInterface?: RoverSkillInterface;
+    priority?: 'primary' | 'secondary';
+};
+export type RoverAgentDiscoveryToolDefinition = {
+    name: string;
+    title?: string;
+    description?: string;
+    parameters?: Record<string, any>;
+    required?: string[];
+    schema?: JsonSchema;
+    outputSchema?: JsonSchema;
+    llmCallable?: boolean;
+    annotations?: RoverToolAnnotations | Record<string, any>;
+};
+export type RoverPublicSkillDefinition = {
+    id: string;
+    name: string;
+    description: string;
+    tags?: string[];
+    examples?: string[];
+    inputSchema?: JsonSchema;
+    outputSchema?: JsonSchema;
+    sideEffect?: RoverSkillSideEffect;
+    requiresConfirmation?: boolean;
+    preferredInterface?: RoverSkillInterface;
+    category?: 'primary' | 'secondary';
+    rover?: {
+        shortcutId?: string;
+        prompt?: string;
+        routing?: 'auto' | 'act' | 'planner';
+        toolName?: string;
+        task?: {
+            endpoint: string;
+            payload: Record<string, unknown>;
+            preferExecution: RoverDiscoveryExecutionPreference;
+        };
+        deepLink?: string;
+        source?: 'shortcut' | 'client_tool' | 'webmcp' | 'additional';
+    };
+};
+export type RoverCapabilityRecord = {
+    capabilityId: string;
+    version: string;
+    label: string;
+    description: string;
+    inputSchema?: JsonSchema;
+    outputSchema?: JsonSchema;
+    sideEffect?: RoverSkillSideEffect;
+    requiresConfirmation?: boolean;
+    preferredInterface?: RoverSkillInterface;
+    allowedExecutionModes: RoverDiscoveryExecutionPreference[];
+    resultModes: RoverCapabilityResultMode[];
+    pageScope?: string[];
+    analyticsTags?: string[];
+    rover?: RoverPublicSkillDefinition['rover'];
+};
+export type RoverPageDefinition = {
+    pageId: string;
+    route?: string;
+    label?: string;
+    capabilityIds?: string[];
+    entityHints?: string[];
+    formHints?: string[];
+    visibleCueLabel?: string;
+    beaconLabel?: string;
+    discoveryMode?: RoverDiscoverySurfaceMode;
+    hostSurface?: RoverDiscoveryHostSurface;
+    actionReveal?: RoverDiscoveryActionReveal;
+    agentModeEntryHints?: string[];
+    capabilitySummary?: string[];
+};
+export type RoverSiteProfile = {
+    identity: {
+        siteId?: string;
+        name: string;
+        description: string;
+        siteUrl: string;
+        version: string;
+    };
+    actions: RoverCapabilityRecord[];
+    pages: RoverPageDefinition[];
+    policies: {
+        preferredExecution: RoverDiscoveryExecutionPreference;
+        promptLaunchEnabled: boolean;
+        shortcutLaunchEnabled: boolean;
+        cloudBrowserAllowed: boolean;
+        delegatedHandoffs: boolean;
+    };
+    auth: {
+        taskEndpoint: string;
+        workflowEndpoint: string;
+        acceptsHttpMessageSignatures: boolean;
+        supportsUnsignedSelfReportedIdentity: boolean;
+    };
+    analytics: {
+        layer: 'roverbook';
+        taskIdField: 'taskId';
+        workflowIdField: 'workflowId';
+        capabilityIdField: 'capabilityId';
+        pageIdField: 'pageId';
+    };
+    currentPage?: RoverPageDefinition;
+    display: {
+        mode: RoverDiscoverySurfaceMode;
+        branding: RoverDiscoverySurfaceBranding;
+        hostSurface: RoverDiscoveryHostSurface;
+        actionReveal: RoverDiscoveryActionReveal;
+        beaconLabel?: string;
+        agentModeEntryHints: string[];
+        compactActionMaxActions: number;
+    };
+    artifacts: {
+        agentCardUrl: string;
+        roverSiteUrl: string;
+        llmsUrl?: string;
+        siteUrl: string;
+    };
+    interfaces?: RoverAgentCard['interfaces'];
+};
+export type RoverAgentCard = {
+    name: string;
+    description: string;
+    url: string;
+    version: string;
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+    capabilities: {
+        streaming: boolean;
+        publicTasks: boolean;
+        stateTransitions: boolean;
+        delegatedHandoffs: boolean;
+        webmcp: boolean;
+    };
+    skills: RoverPublicSkillDefinition[];
+    interfaces?: Array<{
+        type: 'task' | 'workflow' | 'site' | 'deep_link' | 'webmcp';
+        url: string;
+        description?: string;
+        available?: boolean;
+    }>;
+    extensions?: {
+        rover: {
+            siteId?: string;
+            siteUrl: string;
+            taskEndpoint: string;
+            workflowEndpoint: string;
+            serviceDescUrl: string;
+            roverSiteUrl: string;
+            llmsUrl?: string;
+            preferredExecution: RoverDiscoveryExecutionPreference;
+            promptLaunchEnabled: boolean;
+            shortcutLaunchEnabled: boolean;
+            cloudBrowserAllowed: boolean;
+            delegatedHandoffs: boolean;
+            instructions: string[];
+            capabilitiesGraph: RoverCapabilityRecord[];
+            pages: RoverPageDefinition[];
+            currentPage?: RoverPageDefinition;
+            discoverySurface: {
+                mode: RoverDiscoverySurfaceMode;
+                branding: RoverDiscoverySurfaceBranding;
+                hostSurface: RoverDiscoveryHostSurface;
+                actionReveal: RoverDiscoveryActionReveal;
+                beaconLabel?: string;
+                agentModeEntryHints: string[];
+                compactActionMaxActions: number;
+            };
+            shortcuts: Array<{
+                id: string;
+                label: string;
+                description?: string;
+                prompt: string;
+                routing?: 'auto' | 'act' | 'planner';
+            }>;
+            webmcp: {
+                available: boolean;
+                tools: string[];
+            };
+        };
+    };
+};
+export type RoverAgentDiscoveryConfig = {
+    enabled?: boolean;
+    siteUrl: string;
+    siteId?: string;
+    apiBase?: string;
+    siteName?: string;
+    description?: string;
+    version?: string;
+    agentCardUrl?: string;
+    roverSiteUrl?: string;
+    llmsUrl?: string;
+    visibleCue?: boolean;
+    discoverySurface?: RoverDiscoverySurfacePolicy;
+    hostSurfaceSelector?: string;
+    preferExecution?: RoverDiscoveryExecutionPreference;
+    shortcuts?: RoverShortcut[];
+    tools?: RoverAgentDiscoveryToolDefinition[];
+    webmcpTools?: RoverAgentDiscoveryToolDefinition[];
+    additionalSkills?: RoverPublicSkillDefinition[];
+    capabilities?: RoverCapabilityRecord[];
+    pages?: RoverPageDefinition[];
+    pageContext?: Omit<RoverPageDefinition, 'capabilityIds'> & {
+        capabilityIds?: string[];
+    };
+    aiAccess?: {
+        enabled?: boolean;
+        allowPromptLaunch?: boolean;
+        allowShortcutLaunch?: boolean;
+        allowCloudBrowser?: boolean;
+        allowDelegatedHandoffs?: boolean;
+    };
+};
+export type RoverAgentDiscoveryRuntimeConfig = Omit<RoverAgentDiscoveryConfig, 'siteUrl'> & {
+    siteUrl?: string;
+};
+export declare function sanitizeRoverAgentDiscoveryRuntimeConfig(raw: unknown): RoverAgentDiscoveryRuntimeConfig | undefined;
+export declare function createRoverAgentCard(config: RoverAgentDiscoveryConfig): RoverAgentCard;
+export declare function createRoverSiteProfile(config: RoverAgentDiscoveryConfig): RoverSiteProfile;
+export declare function buildRoverAgentDiscoveryPayloads(config: RoverAgentDiscoveryConfig): {
+    card: RoverAgentCard;
+    cardJson: string;
+    serviceDescHref: string;
+    roverSite: RoverSiteProfile;
+    roverSiteJson: string;
+    roverSiteHref: string;
+    pageManifest: RoverPageDefinition;
+    pageManifestJson: string;
+    llmsUrl?: string;
+    marker: {
+        task?: string;
+        card: string;
+        roverSite: string;
+        site?: string;
+        workflow?: string;
+        page?: string;
+        preferExecution?: RoverDiscoveryExecutionPreference;
+        discoveryMode?: RoverDiscoverySurfaceMode;
+        hostSurface?: RoverDiscoveryHostSurface;
+        actionReveal?: RoverDiscoveryActionReveal;
+        beaconLabel?: string;
+        skills: Array<{
+            id: string;
+            name: string;
+        }>;
+        capabilities: Array<{
+            capabilityId: string;
+            label: string;
+        }>;
+    };
+    markerJson: string;
+};
+export declare function createRoverAgentCardJson(config: RoverAgentDiscoveryConfig, options?: {
+    pretty?: boolean;
+}): string;
+export declare function createRoverWellKnownAgentCard(config: RoverAgentDiscoveryConfig, options?: {
+    pretty?: boolean;
+}): string;
+export declare function createRoverSiteProfileJson(config: RoverAgentDiscoveryConfig, options?: {
+    pretty?: boolean;
+}): string;
+export declare function createRoverWellKnownSiteProfile(config: RoverAgentDiscoveryConfig, options?: {
+    pretty?: boolean;
+}): string;
+export declare function createRoverServiceDescLinkHeader(config: {
+    agentCardUrl?: string;
+    llmsUrl?: string;
+}): string;
+export declare function createRoverAgentDiscoveryTags(config: RoverAgentDiscoveryConfig): string;
+export { createRoverAgentDiscoverySnapshot };
+export type { RoverAgentDiscoverySnapshot };