@nxisai/agent-harness 0.4.1 → 0.6.0

package/src/harness/tools/site-pages.ts

@@ -0,0 +1,288 @@
+/**
+ * The site's pages, and which of them a record belongs to.
+ *
+ * A result the agent finds is a record — a plumber, a product — and the
+ * visitor usually wants the page it came from. The record rarely says: a
+ * business's `url` is its website, often the site root. Typed retrieval also
+ * holds the site's `WebPage` records, and every Action names the page its form
+ * is on, so between them most records can be traced back to a page.
+ *
+ * Only pages on this origin are ever returned: whatever a record claims, the
+ * agent does not send a visitor to another site.
+ *
+ * @module
+ */
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { McpServerInfo } from '../../types.js';
+import type { NxisAction } from '../../webmcp-contract.js';
+import { queryTypedRecords, samePage } from './site-actions.js';
+
+const SCHEMA_NS = 'https://schema.org/';
+const CACHE_TTL_MS = 10 * 60 * 1000;
+const CACHE_PREFIX = 'nxis:site-pages:v1:';
+
+/** A page on the site, as the agent can name it. */
+export interface SitePage {
+  /** Absolute URL, on this origin. */
+  url: string;
+  /** What the page is called, for the visitor and the model. */
+  name: string;
+  /** The `@id`s of the records the page is about, when its record says. */
+  about?: string[];
+  /** Pages this one points a reader at: its `significantLink` and `relatedLink`. */
+  links?: string[];
+  /** The `@id` of the breadcrumb trail extracted from this page, when it has one. */
+  breadcrumb?: string;
+}
+
+type Obj = Record<string, unknown>;
+
+const isObj = (v: unknown): v is Obj => !!v && typeof v === 'object' && !Array.isArray(v);
+const schemaValue = (o: Obj, prop: string): unknown => o[prop] ?? o[SCHEMA_NS + prop];
+const str = (v: unknown): string | undefined => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
+const bareType = (t: string): string => t.replace(/^.*[/#]/, '');
+const types = (o: Obj): string[] =>
+  (Array.isArray(o['@type']) ? o['@type'] : [o['@type']]).filter((t): t is string => typeof t === 'string').map(bareType);
+
+/** A name compared the way a person would: case, spacing and punctuation aside. */
+const normal = (s: string): string => s.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+
+/**
+ * A URL resolved against the origin, if it stays on it.
+ *
+ * Crawled pages often record a path (`/listings/x.html`) rather than a URL.
+ */
+function onOrigin(raw: unknown, origin: string): string | null {
+  const s = str(raw);
+  if (!s) return null;
+  try {
+    const url = new URL(s, origin);
+    return url.origin === new URL(origin).origin ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Every `@id` (or URL) a reference property points at. */
+function refs(v: unknown): string[] {
+  const list = Array.isArray(v) ? v : [v];
+  return list
+    .map((r) => (isObj(r) ? str(r['@id']) ?? str(schemaValue(r, 'url')) : str(r)))
+    .filter((r): r is string => !!r);
+}
+
+/**
+ * Read one typed-retrieval record as a page.
+ *
+ * @param raw - A record as returned by `nxis_query`.
+ * @param origin - The site's origin; pages elsewhere are refused.
+ * @returns The page, or null when the record is not a page, has no URL on
+ * this origin, or has no name.
+ */
+export function parsePage(raw: unknown, origin: string): SitePage | null {
+  if (!isObj(raw) || !types(raw).some((t) => t.endsWith('Page'))) return null;
+  const url = onOrigin(schemaValue(raw, 'url'), origin);
+  const name = str(schemaValue(raw, 'name')) ?? str(schemaValue(raw, 'headline'));
+  if (!url || !name) return null;
+  const about = [...refs(schemaValue(raw, 'mainEntity')), ...refs(schemaValue(raw, 'about'))];
+  // What the page points at, which is how an agent follows a page's own links rather than only
+  // the hierarchy above it. Kept as published; the platform stores them absolute.
+  const links = [...new Set([...refs(schemaValue(raw, 'significantLink')), ...refs(schemaValue(raw, 'relatedLink'))])];
+  const breadcrumb = refs(schemaValue(raw, 'breadcrumb'))[0];
+  return {
+    url,
+    name,
+    ...(about.length ? { about } : {}),
+    ...(links.length ? { links } : {}),
+    ...(breadcrumb ? { breadcrumb } : {}),
+  };
+}
+
+/**
+ * The pages the site's actions live on, named for what each is about.
+ *
+ * An action whose field is fixed to one value — the business a quote goes
+ * to — names its page better than the page's path does.
+ */
+export function pagesFromActions(actions: NxisAction[], origin: string): SitePage[] {
+  const pages: SitePage[] = [];
+  for (const action of actions) {
+    const url = onOrigin(action.target['nxis:pageUrl'], origin);
+    if (!url) continue;
+    const named = (action.input ?? []).find((i) => i.defaultValue && !i['nxis:valueOption']);
+    const name = named?.defaultValue ?? slugName(url);
+    if (name) pages.push({ url, name });
+  }
+  return pages;
+}
+
+/** `/listings/detroit-metro-plumbing.html` → `detroit metro plumbing`. */
+function slugName(url: string): string {
+  const slug = new URL(url).pathname.split('/').filter(Boolean).pop() ?? '';
+  return slug.replace(/\.\w+$/, '').replace(/[-_]+/g, ' ') || 'home';
+}
+
+/**
+ * Pages from any number of sources, each page once.
+ *
+ * The first source to name a page wins its name, so pass the page records
+ * before anything inferred.
+ */
+export function mergePages(...lists: SitePage[][]): SitePage[] {
+  const out: SitePage[] = [];
+  for (const page of lists.flat()) {
+    const same = out.find((p) => samePage(p.url, page.url));
+    if (!same) out.push({ ...page });
+    else {
+      if (page.about?.length) same.about = [...new Set([...(same.about ?? []), ...page.about])];
+      if (page.links?.length) same.links = [...new Set([...(same.links ?? []), ...page.links])];
+      if (page.breadcrumb && !same.breadcrumb) same.breadcrumb = page.breadcrumb;
+    }
+  }
+  return out;
+}
+
+/**
+ * The page a record came from, when it can be told.
+ *
+ * In order of how much each is to be trusted: the record naming its page, its
+ * id when that is formed from a page (`page.html#organization`), the record
+ * being a page, the record's own URL when it is a page of this site rather than
+ * its root, a page that says it is about the record, and last a page with the
+ * record's exact name.
+ *
+ * @param entity - The record, compact or IRI-keyed.
+ * @param pages - The site's pages.
+ * @param origin - The site's origin.
+ * @returns The page, or null when none can be told apart.
+ */
+export function pageForEntity(entity: Obj, pages: SitePage[], origin: string): SitePage | null {
+  if (!isObj(entity)) return null;
+  const name = str(schemaValue(entity, 'name')) ?? str(schemaValue(entity, 'headline'));
+  const known = (url: string): SitePage =>
+    pages.find((p) => samePage(p.url, url)) ?? { url, name: name ?? slugName(url) };
+
+  for (const ref of refs(schemaValue(entity, 'mainEntityOfPage'))) {
+    const url = onOrigin(ref, origin);
+    if (url) return known(url);
+  }
+
+  // An id built from its page (`page.html#organization`) names the page: everything before the
+  // fragment. Only with a fragment and below the root: a site-wide id (`/#organization/...`) names
+  // no page, and the hash-suffixed ids stored before (`page.html/23400b...`) are not pages either.
+  const idPage = pageOfId(str(entity['@id']), origin);
+  if (idPage) return known(idPage);
+
+  const own = onOrigin(schemaValue(entity, 'url'), origin);
+  if (own && (types(entity).some((t) => t.endsWith('Page')) || new URL(own).pathname !== '/')) {
+    return known(own);
+  }
+
+  const id = str(entity['@id']);
+  if (id) {
+    const about = pages.filter((p) => p.about?.includes(id));
+    if (about.length === 1) return about[0];
+  }
+
+  if (name) {
+    const named = pages.filter((p) => normal(p.name) === normal(name));
+    if (named.length === 1) return named[0];
+  }
+  return null;
+}
+
+/**
+ * The page an id formed from it names, or null.
+ *
+ * nxis-sdn-api forms a page entity's id as the page URL plus a fragment, so the page is the id with
+ * the fragment removed.
+ */
+function pageOfId(id: string | undefined, origin: string): string | null {
+  if (!id || !id.includes('#')) return null;
+  const url = onOrigin(id, origin);
+  if (!url) return null;
+  const page = new URL(url);
+  page.hash = '';
+  return page.pathname === '/' ? null : page.href;
+}
+
+/**
+ * The page a visitor or model means, by name or by address.
+ *
+ * @param wanted - A page name, a URL, or a path.
+ * @param pages - The site's pages.
+ * @param origin - The site's origin.
+ * @returns The page, or null when nothing matches or several do equally.
+ */
+export function findPage(wanted: string, pages: SitePage[], origin: string): SitePage | null {
+  const w = wanted.trim();
+  if (!w) return null;
+  if (/^(https?:\/\/|\/)/i.test(w)) {
+    const url = onOrigin(w, origin);
+    return url ? (pages.find((p) => samePage(p.url, url)) ?? null) : null;
+  }
+  const n = normal(w);
+  const exact = pages.filter((p) => normal(p.name) === n);
+  if (exact.length === 1) return exact[0];
+  const partial = pages.filter((p) => normal(p.name).includes(n) || n.includes(normal(p.name)));
+  return partial.length === 1 ? partial[0] : null;
+}
+
+/** Options for {@link loadSitePages}. */
+export interface SitePagesOptions {
+  /** The origin pages must belong to. Defaults to the page's own. */
+  origin?: string;
+  /** Where the list is cached between page loads. Defaults to `sessionStorage`; null disables. */
+  storage?: Storage | null;
+  /** How long a cached list is reused, in milliseconds. Defaults to ten minutes. */
+  ttlMs?: number;
+  /** The clock, for tests. */
+  now?: () => number;
+}
+
+function defaultStorage(): Storage | null {
+  try {
+    return typeof sessionStorage === 'undefined' ? null : sessionStorage;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Every page record on the site, on this origin.
+ *
+ * Cached in the tab like the site's actions, so moving between pages costs
+ * one request per session.
+ *
+ * @throws When the query fails. The caller decides whether that matters.
+ */
+export async function loadSitePages(
+  client: Client,
+  info: Pick<McpServerInfo, 'endpoint'>,
+  opts: SitePagesOptions = {},
+): Promise<SitePage[]> {
+  const origin = opts.origin ?? location.origin;
+  const storage = opts.storage === undefined ? defaultStorage() : opts.storage;
+  const now = (opts.now ?? Date.now)();
+  const key = CACHE_PREFIX + info.endpoint;
+
+  try {
+    const entry = JSON.parse(storage?.getItem(key) || 'null') as { fetchedAt: number; pages: SitePage[] } | null;
+    const fresh = entry && now - entry.fetchedAt <= (opts.ttlMs ?? CACHE_TTL_MS) && entry.fetchedAt <= now;
+    if (fresh && Array.isArray(entry.pages)) return entry.pages;
+  } catch {
+    // A corrupt entry is a refetch.
+  }
+
+  const pages = mergePages(
+    (await queryTypedRecords(client, 'Page'))
+      .map((r) => parsePage(r, origin))
+      .filter((p): p is SitePage => p !== null),
+  );
+  try {
+    storage?.setItem(key, JSON.stringify({ fetchedAt: now, pages }));
+  } catch {
+    // Full or blocked storage costs a refetch on the next page, nothing more.
+  }
+  return pages;
+}

package/src/harness/tools/source.ts

@@ -0,0 +1,353 @@
+/**
+ * Assembles the page's toolset from both of its sources.
+ *
+ * Tools come from two places: those registered on the page itself, and those
+ * from a remote MCP server discovered through `.well-known` and bridged in.
+ * Both end up in `document.modelContext`, so the harness discovers them with a
+ * single call and treats them alike, distinguishing only read from write via
+ * each tool's annotations.
+ *
+ * {@link connectTools} is awaited rather than run as a load-time side effect,
+ * so a caller knows when the toolset is complete.
+ *
+ * @module
+ */
+
+import { registerRemoteTools, type BridgeOptions } from './bridge.js';
+import { ensureModelContext } from './local-context.js';
+import { connectMcp } from './client.js';
+import { discoverMcpServer } from './discovery.js';
+import { loadSiteActions, type SiteActionsOptions } from './site-actions.js';
+import { registerSiteActionTools } from './action-tools.js';
+import { loadSitePages, mergePages, pagesFromActions, type SitePage } from './site-pages.js';
+import { registerOpenPageTool, OPEN_PAGE_TOOL, type OpenPageOptions } from './open-page.js';
+import {
+  applyTrails,
+  buildNav,
+  loadSiteTrails,
+  registerPageLinksTool,
+  PAGE_LINKS_TOOL,
+  type SiteNav,
+} from './site-nav.js';
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { McpServerInfo, ModelContext } from '../../types.js';
+import type { NxisAction } from '../../webmcp-contract.js';
+
+const READY_TIMEOUT_MS = 20000;
+const POLL_INTERVAL_MS = 200;
+
+/** The outcome of {@link connectTools}. */
+export interface ConnectResult {
+  /** The registry the tools were registered into, or null if none was found. */
+  modelContext: ModelContext | null;
+  /** Remote tool names bridged in. Empty when discovery failed or was skipped. */
+  remoteTools: string[];
+  /**
+   * Every Action on the site, from any page, that belongs to this origin.
+   *
+   * Empty when discovery failed, the query failed, or it was turned off with
+   * {@link ConnectOptions.siteActions}.
+   */
+  siteActions: NxisAction[];
+  /**
+   * The tools registered for {@link siteActions}.
+   *
+   * Fewer than the actions: those that share a name and a set of fields become
+   * one tool that chooses between them.
+   */
+  siteTools: string[];
+  /**
+   * The site's pages the agent can open and link results to: its page
+   * records, and the pages its actions live on.
+   */
+  sitePages: SitePage[];
+  /**
+   * The site's graph: which pages sit under which, and what points at what,
+   * from its breadcrumb trails and its pages' links. Empty when the site
+   * publishes no trails and its pages link nothing.
+   */
+  siteNav?: SiteNav;
+  /** Why remote tools or site actions are absent, when they are. Never fatal. */
+  warning?: string;
+}
+
+/** The page's model context, from either of the two places it may appear. */
+function getModelContext(): ModelContext | null {
+  return document.modelContext ?? navigator.modelContext ?? null;
+}
+
+/**
+ * Wait for a WebMCP provider to appear on the page.
+ *
+ * @param timeout - How long to wait, in milliseconds.
+ * @returns The model context, or null if none appears in time.
+ */
+export function waitForModelContext(timeout = READY_TIMEOUT_MS): Promise<ModelContext | null> {
+  const immediate = getModelContext();
+  if (immediate) return Promise.resolve(immediate);
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const iv = setInterval(() => {
+      const mc = getModelContext();
+      if (mc) {
+        clearInterval(iv);
+        resolve(mc);
+      } else if (Date.now() - started > timeout) {
+        clearInterval(iv);
+        resolve(null);
+      }
+    }, POLL_INTERVAL_MS);
+  });
+}
+
+/** Options for {@link connectTools}. */
+export interface ConnectOptions {
+  /** How long to wait for a WebMCP provider before falling back. */
+  timeout?: number;
+  /**
+   * Register into a local registry when the page has no WebMCP provider.
+   *
+   * Defaults to true, so a working MCP server still yields tools on a page with
+   * no WebMCP implementation. Pass false to require a real provider.
+   */
+  fallback?: boolean;
+  /** Override which of the server's tools are bridged in. */
+  accept?: BridgeOptions['accept'];
+  /**
+   * Fetch the site's Actions from every page, not only this one.
+   *
+   * Defaults to true. Pass false to skip the query, or an options object to
+   * override the origin check or the cache.
+   */
+  siteActions?: boolean | SiteActionsOptions;
+  /**
+   * Register `open_page`, so the agent can take the visitor to a page.
+   *
+   * Defaults to true when site actions are fetched. Pass false to leave it
+   * out, or options to supply the conversation to continue on arrival.
+   */
+  openPage?: boolean | OpenPageOptions;
+}
+
+/**
+ * Wait for a tool registry, then bridge in a remote MCP server's tools.
+ *
+ * Every remote failure is caught and reported as
+ * {@link ConnectResult.warning}: discovery, CORS and network problems leave the
+ * page's own tools working, and a site with no MCP server is an ordinary case
+ * rather than an error.
+ *
+ * Connects each registry once. A second call for the same registry, such as a
+ * page script and the element both connecting, returns the first call's result
+ * rather than registering the same tools again, which a native `modelContext`
+ * rejects as a duplicate.
+ *
+ * @param apiKey - Key for the remote server's private tools. Public tools need
+ * none, and the element never supplies one: a key readable in the page is a
+ * published key. Pass one only where it is short-lived and scoped, such as a
+ * token your backend mints per session.
+ * @param opts - Timeout, local-registry fallback, and a tool filter. Only the
+ * first call's options apply to a registry.
+ * @returns The registry, the remote tools bridged in, and any warning.
+ */
+export async function connectTools(
+  apiKey?: string,
+  opts: ConnectOptions = {},
+): Promise<ConnectResult> {
+  const waited = await waitForModelContext(opts.timeout ?? READY_TIMEOUT_MS);
+  const mc = waited ?? (opts.fallback === false ? null : ensureModelContext());
+  if (!mc) {
+    return {
+      modelContext: null,
+      remoteTools: [],
+      siteActions: [],
+      siteTools: [],
+      sitePages: [],
+      warning: 'WebMCP (document.modelContext) unavailable — no tools registered.',
+    };
+  }
+
+  let connection = connections.get(mc);
+  if (!connection) {
+    connection = connectRegistry(mc, apiKey, opts);
+    connections.set(mc, connection);
+  }
+  return connection;
+}
+
+/** One connection per registry, shared by every caller. */
+const connections = new WeakMap<ModelContext, Promise<ConnectResult>>();
+
+async function connectRegistry(
+  mc: ModelContext,
+  apiKey: string | undefined,
+  opts: ConnectOptions,
+): Promise<ConnectResult> {
+  let info: McpServerInfo;
+  let client: Client;
+  let remoteTools: string[];
+  try {
+    info = await discoverMcpServer();
+    client = await connectMcp(info, apiKey);
+    remoteTools = await registerRemoteTools(client, mc, info, { accept: opts.accept });
+  } catch (err) {
+    // No server, so no page list — but the address bar still says where the visitor is, and
+    // "home" and "back" need nothing else. An unreachable corpus is not a reason to lose those.
+    if (opts.openPage !== false) await registerNavigationOnly(mc, opts.openPage);
+    return {
+      modelContext: mc,
+      remoteTools: [],
+      siteActions: [],
+      siteTools: [],
+      sitePages: [],
+      warning: `remote tool bootstrap failed — on-page tools still work: ${errorText(err)}`,
+    };
+  }
+
+  if (opts.siteActions === false) {
+    return { modelContext: mc, remoteTools, siteActions: [], siteTools: [], sitePages: [] };
+  }
+
+  const siteOpts = typeof opts.siteActions === 'object' ? opts.siteActions : {};
+
+  // Each read stands on its own. They used to share one `try`, so a corpus the server was rate
+  // limiting took the navigation tools down with it: the agent lost the tool that says which page
+  // it is on — a question needing no read at all — because a different query had failed.
+  let siteActions: NxisAction[] = [];
+  let siteTools: string[] = [];
+  let warning: string | undefined;
+  try {
+    siteActions = await loadSiteActions(client, info, siteOpts);
+    siteTools = await registerSiteActionTools(mc, siteActions);
+  } catch (err) {
+    warning = `site actions unavailable — this page's own actions still work: ${errorText(err)}`;
+    console.warn(`[nxis-mcp] ${warning}`);
+  }
+
+  const site = await connectPages(mc, client, info, siteActions, siteOpts, opts.openPage);
+  return { modelContext: mc, remoteTools, siteActions, siteTools, sitePages: site.pages, siteNav: site.nav, warning };
+}
+
+/**
+ * The site's pages, and the tool that opens them.
+ *
+ * A failed page query is not worth a warning of its own: the pages the
+ * actions live on still make a usable list.
+ */
+async function connectPages(
+  mc: ModelContext,
+  client: Client,
+  info: McpServerInfo,
+  actions: NxisAction[],
+  siteOpts: SiteActionsOptions,
+  openPage: ConnectOptions['openPage'],
+): Promise<{ pages: SitePage[]; nav: SiteNav }> {
+  const origin = siteOpts.origin ?? location.origin;
+  let records: SitePage[] = [];
+  try {
+    records = await loadSitePages(client, info, siteOpts);
+  } catch (err) {
+    console.warn(`[nxis-mcp] page records unavailable, using action pages only: ${errorText(err)}`);
+  }
+  const pages = mergePages(records, pagesFromActions(actions, origin));
+  if (!pages.length) {
+    // Registered anyway: "where am I", "home" and "back" are answerable from the address bar, and a
+    // page list that failed to load is the moment a visitor most needs them.
+    console.info('[nxis-mcp] no page records; navigation is by address');
+  }
+
+  // The pages and what they link, now; the hierarchy on demand. Connecting already spends two
+  // reads (actions, pages), and a site's rate limit counts them — the public plan allows three a
+  // minute, so a third here would leave the visitor's first question waiting on the limit. The
+  // trails are fetched the first time navigation needs them, and folded into this same graph.
+  const nav = buildNav(pages, [], origin);
+  let trails: Promise<SiteNav> | null = null;
+  const loadNav = (): Promise<SiteNav> =>
+    (trails ??= loadSiteTrails(client, info, siteOpts)
+      .then((found) => {
+        console.info(`[nxis-mcp] ${found.length} breadcrumb trail(s)`);
+        return applyTrails(nav, found);
+      })
+      .catch((err) => {
+        // Asked again next time: a rate limit now is not a site without trails.
+        trails = null;
+        console.warn(`[nxis-mcp] breadcrumb trails unavailable, navigation is by name: ${errorText(err)}`);
+        return nav;
+      }));
+
+  if (openPage !== false) {
+    const registered = await registerOpenPageTool(mc, pages, {
+      origin,
+      nav,
+      loadNav,
+      ...(typeof openPage === 'object' ? openPage : {}),
+    });
+    if (registered) console.info(`[nxis-mcp] ${OPEN_PAGE_TOOL}: ${pages.length} page(s)`);
+    const links = await registerPageLinksTool(mc, nav, { loadNav });
+    if (links) console.info(`[nxis-mcp] ${PAGE_LINKS_TOOL}: where the visitor is, and what leads where`);
+  }
+  return { pages, nav };
+}
+
+/** The navigation tools with nothing but the page's own address to go on. */
+async function registerNavigationOnly(mc: ModelContext, openPage: ConnectOptions['openPage']): Promise<void> {
+  const origin = typeof location === 'undefined' ? '' : location.origin;
+  const nav = buildNav([], [], origin);
+  await registerOpenPageTool(mc, [], { origin, nav, ...(typeof openPage === 'object' ? openPage : {}) });
+  await registerPageLinksTool(mc, nav);
+}
+
+const errorText = (err: unknown): string => String((err as Error)?.message || err);
+
+export { discoverMcpServer, connectMcp, registerRemoteTools, loadSiteActions };
+export {
+  registerSiteActionTools,
+  buildSiteActionTools,
+  withoutShadowedTools,
+  handoffFor,
+  findPageTool,
+  awaitPageTool,
+  pageToolRef,
+  siteToolName,
+  selectSiteTools,
+} from './action-tools.js';
+export { resumePendingAction } from './resume.js';
+export {
+  loadSitePages,
+  parsePage,
+  pagesFromActions,
+  mergePages,
+  pageForEntity,
+  findPage,
+} from './site-pages.js';
+export type { SitePage, SitePagesOptions } from './site-pages.js';
+export { buildOpenPageTool, registerOpenPageTool, resolveDestination, visitFor, OPEN_PAGE_TOOL } from './open-page.js';
+export {
+  applyTrails,
+  buildNav,
+  buildPageLinksTool,
+  describeNav,
+  loadSiteTrails,
+  nameOf,
+  navFor,
+  parentOf,
+  parseTrail,
+  registerPageLinksTool,
+  PAGE_LINKS_TOOL,
+} from './site-nav.js';
+export type { NavLink, PageNav, SiteNav, SiteTrail, SiteTrailsOptions, TrailLevel } from './site-nav.js';
+export type { OpenPageOptions, Destination } from './open-page.js';
+export type { ResumeOutcome, ResumeOptions } from './resume.js';
+export type { SiteActionTool, Handoff, PageToolRef } from './action-tools.js';
+export {
+  savePendingAction,
+  takePendingAction,
+  clearPendingAction,
+  savePendingVisit,
+  takePendingVisit,
+  setConversationSource,
+} from './pending-action.js';
+export type { PendingAction, PendingVisit } from './pending-action.js';
+export { parseAction, samePage, sameActionPage } from './site-actions.js';
+export type { SiteActionsOptions } from './site-actions.js';
+export { ensureModelContext, LocalModelContext } from './local-context.js';