@tangle-network/agent-app 0.45.54 → 0.45.55

package/dist/brand/index.d.ts

@@ -1,9 +1,17 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-export { TangleKnot } from '@tangle-network/brand';
-
+/**
+ * Tangle brand components for Agent App surfaces.
+ *
+ * The visual mark stays owned by `@tangle-network/brand`; this module only
+ * preserves Agent App's existing `Logo` properties and supplies `BrandHeader`.
+ *
+ *   import { Logo, TangleKnot, BrandHeader } from '@tangle-network/agent-app/brand'
+ */
+import { TangleKnot } from '@tangle-network/brand';
+import type { ReactNode } from 'react';
+/** Render the canonical, theme-independent Tangle knot mark. */
+export { TangleKnot };
 /** Define properties to customize the logo variant, size, style, and icon display options. */
-interface LogoProps {
+export interface LogoProps {
     /** Preserved for compatibility; the canonical Tangle lockup is used. */
     variant?: 'sandbox';
     size?: 'sm' | 'md' | 'lg' | 'xl';
@@ -12,9 +20,9 @@ interface LogoProps {
     iconOnly?: boolean;
 }
 /** Render the canonical Tangle lockup through Agent App's existing API. */
-declare function Logo({ variant, size, className, iconOnly, }: LogoProps): react.JSX.Element;
+export declare function Logo({ variant, size, className, iconOnly, }: LogoProps): import("react").JSX.Element;
 /** Define properties for a brand header including optional title, children, and CSS class name. */
-interface BrandHeaderProps {
+export interface BrandHeaderProps {
     /** Product name rendered next to the knot. Omit for a mark-only header. */
     title?: string;
     /** Right-aligned slot for nav, actions, theme toggles. */
@@ -22,6 +30,4 @@ interface BrandHeaderProps {
     className?: string;
 }
 /** Shared app-shell header with the canonical Tangle mark. */
-declare function BrandHeader({ title, children, className }: BrandHeaderProps): react.JSX.Element;
-
-export { BrandHeader, type BrandHeaderProps, Logo, type LogoProps };
+export declare function BrandHeader({ title, children, className }: BrandHeaderProps): import("react").JSX.Element;

package/dist/brand-extraction/extract.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Brand-kit extraction engine.
+ *
+ * Given a website URL (or raw HTML), parse the page and pull a typed BrandKit:
+ * logo candidates, color palette, fonts, and prominent images. Parsing is
+ * regex-based on purpose — this runs on Cloudflare Workers and other edge
+ * runtimes where DOM libraries (jsdom/cheerio) are unavailable, and the page
+ * structures we read (link tags, meta tags, CSS custom properties, font-family
+ * declarations) are flat enough that a DOM buys nothing.
+ *
+ * Degrades gracefully: a missing favicon, no CSS tokens, or an image-only page
+ * each narrow the kit rather than failing it. The ONLY hard failures are a bad
+ * input (no html and no fetch) and a fetch error — both returned as a typed
+ * `{ succeeded: false }` outcome so callers never mistake an empty kit for a
+ * real one.
+ */
+import type { BrandExtractionResult, BrandKit, ExtractBrandKitOptions } from './types';
+/** Normalize a user-supplied site URL: add https:// when scheme-less, validate. */
+export declare function normalizeSiteUrl(raw: string): string | null;
+/** Normalize any CSS color literal to #rrggbb / #rrggbbaa hex, or null. */
+export declare function normalizeColor(raw: string): string | null;
+/** Parse already-fetched HTML into a BrandKit. Pure — no network. Exposed so
+ *  callers that hold the HTML (or want to combine multiple pages) can reuse the
+ *  parsing without re-fetching. */
+export declare function parseBrandKit(html: string, sourceUrl: string, maxPerList?: number): BrandKit;
+/**
+ * Fetch a website (or use supplied HTML) and extract its BrandKit.
+ *
+ * Returns a typed outcome — callers MUST check `succeeded`. A fetch failure or
+ * empty input is a real, surfaced error, never an empty kit masquerading as a
+ * result. Parsing itself never throws: a malformed page yields a sparse kit
+ * with warnings, which is information, not failure.
+ */
+export declare function extractBrandKit(url: string, options?: ExtractBrandKitOptions): Promise<BrandExtractionResult>;

package/dist/brand-extraction/index.d.ts

@@ -1,215 +1,13 @@
 /**
- * Typed contract for a brand kit extracted from a website (+ optional shared
- * source files). The extractor degrades gracefully: every field is best-effort,
- * absence is represented explicitly (empty arrays, undefined), never faked.
- *
- * A consuming product (gtm, creative) maps this onto its own durable brand
- * store — see the gtm `WorkspaceBrand`. This module owns only extraction; it
- * does NOT persist, render, or judge confidence.
- */
-/** A logo / brand-mark candidate discovered on a page. */
-interface BrandLogoCandidate {
-    /** Absolute URL to the asset. */
-    url: string;
-    /** Where it came from — drives ranking and lets callers cite provenance. */
-    source: 'favicon' | 'apple-touch-icon' | 'og:image' | 'img-logo' | 'svg-inline' | 'manifest';
-    /** Higher = more likely the canonical logo. 0..1. */
-    confidence: number;
-    /** Declared width in px when known (from <link sizes> or <img width>). */
-    width?: number;
-    /** Declared height in px when known. */
-    height?: number;
-    /** MIME type when inferable from the extension. */
-    mimeType?: string;
-    /** alt / title text when present — a "logo" alt is a strong signal. */
-    alt?: string;
-}
-/** A color extracted from the page, with where it was seen. */
-interface BrandColor {
-    /** Normalized 6- or 8-digit `#rrggbb` / `#rrggbbaa` hex (lowercase). */
-    hex: string;
-    /** How many distinct declarations referenced this color (popularity proxy). */
-    occurrences: number;
-    /** True when sourced from a `:root` CSS custom property (highest fidelity). */
-    fromToken: boolean;
-    /** The custom-property name when fromToken (e.g. `--accent`). */
-    tokenName?: string;
-}
-/** A font-family discovered in CSS, with role inference. */
-interface BrandFont {
-    /** Primary family name, unquoted (e.g. `Inter`, `Playfair Display`). */
-    family: string;
-    /** The full declared stack as written, in order. */
-    stack: string[];
-    /** Inferred role from the selector the declaration was attached to. */
-    role: 'display' | 'body' | 'unknown';
-    /** Declaration count — popularity proxy for picking the dominant family. */
-    occurrences: number;
-}
-/** A prominent product / hero image candidate (not a logo). */
-interface BrandImage {
-    url: string;
-    source: 'og:image' | 'twitter:image' | 'img-hero' | 'img-content';
-    /** alt text when present. */
-    alt?: string;
-    width?: number;
-    height?: number;
-}
-/**
- * The full extracted kit. The shape every consumer reads. Each list is ranked
- * best-first; empty lists mean "found nothing", never a fabricated default.
- */
-interface BrandKit {
-    /** The site the kit was extracted from (normalized, absolute). */
-    sourceUrl: string;
-    /** Best-guess brand / product name from <title>, og:site_name, manifest. */
-    name?: string;
-    /** Tagline / description from meta description or og:description. */
-    description?: string;
-    /** Logo candidates, ranked best-first. */
-    logos: BrandLogoCandidate[];
-    /** Colors, ranked by token-first then popularity. */
-    palette: BrandColor[];
-    /** Fonts, ranked display-then-body then popularity. */
-    fonts: BrandFont[];
-    /** Prominent images (hero / og), ranked best-first. */
-    images: BrandImage[];
-    /** Absolute URLs / labels the kit was derived from — for provenance. */
-    extractedFrom: string[];
-}
-/**
- * Typed outcome. Callers MUST inspect `succeeded` before reading `kit`.
- * No silent empties: a fetch failure is `succeeded:false` with a real error,
- * NOT an empty BrandKit that downstream code mistakes for "this brand has
- * nothing".
- */
-type BrandExtractionResult = {
-    succeeded: true;
-    kit: BrandKit;
-    warnings: string[];
-} | {
-    succeeded: false;
-    error: string;
-    stage: 'fetch' | 'parse' | 'input';
-};
-/** Fetch boundary, injectable so callers (Workers, Node, tests) supply their
- *  own fetch and so tests can run fully offline against fixture HTML. */
-type FetchLike = (url: string, init?: {
-    signal?: AbortSignal;
-    headers?: Record<string, string>;
-}) => Promise<{
-    ok: boolean;
-    status: number;
-    text(): Promise<string>;
-    headers?: {
-        get(name: string): string | null;
-    };
-}>;
-/** Define options for extracting brand kit data including HTML input, fetch method, timeout, and list limits */
-interface ExtractBrandKitOptions {
-    /** Raw HTML for the page. When supplied, no network fetch happens — used by
-     *  tests and by callers that already hold the HTML. */
-    html?: string;
-    /** Fetch implementation. Required when `html` is omitted. */
-    fetchImpl?: FetchLike;
-    /** Per-request timeout in ms (default 15000). Applied to the page fetch. */
-    timeoutMs?: number;
-    /** Cap on each ranked list (default 12). Keeps payloads bounded. */
-    maxPerList?: number;
-}
-
-/**
- * Brand-kit extraction engine.
- *
- * Given a website URL (or raw HTML), parse the page and pull a typed BrandKit:
- * logo candidates, color palette, fonts, and prominent images. Parsing is
- * regex-based on purpose — this runs on Cloudflare Workers and other edge
- * runtimes where DOM libraries (jsdom/cheerio) are unavailable, and the page
- * structures we read (link tags, meta tags, CSS custom properties, font-family
- * declarations) are flat enough that a DOM buys nothing.
- *
- * Degrades gracefully: a missing favicon, no CSS tokens, or an image-only page
- * each narrow the kit rather than failing it. The ONLY hard failures are a bad
- * input (no html and no fetch) and a fetch error — both returned as a typed
- * `{ succeeded: false }` outcome so callers never mistake an empty kit for a
- * real one.
- */
-
-/** Normalize a user-supplied site URL: add https:// when scheme-less, validate. */
-declare function normalizeSiteUrl(raw: string): string | null;
-/** Normalize any CSS color literal to #rrggbb / #rrggbbaa hex, or null. */
-declare function normalizeColor(raw: string): string | null;
-/** Parse already-fetched HTML into a BrandKit. Pure — no network. Exposed so
- *  callers that hold the HTML (or want to combine multiple pages) can reuse the
- *  parsing without re-fetching. */
-declare function parseBrandKit(html: string, sourceUrl: string, maxPerList?: number): BrandKit;
-/**
- * Fetch a website (or use supplied HTML) and extract its BrandKit.
- *
- * Returns a typed outcome — callers MUST check `succeeded`. A fetch failure or
- * empty input is a real, surfaced error, never an empty kit masquerading as a
- * result. Parsing itself never throws: a malformed page yields a sparse kit
- * with warnings, which is information, not failure.
- */
-declare function extractBrandKit(url: string, options?: ExtractBrandKitOptions): Promise<BrandExtractionResult>;
-
-/**
- * Pure mapping helpers from an extracted BrandKit onto consumable shapes.
- *
- * Extraction yields ranked candidate lists; products need decided roles
- * (background vs accent, display vs body). These helpers make the obvious,
- * defensible default choice and expose the reasoning so a confirmation UI can
- * show "we picked X — change it?". They NEVER invent a value: when a role can't
- * be filled from the kit, it is omitted, and the caller decides the fallback.
- */
-
-/** Relative luminance (0..1) of an #rrggbb(aa) hex — for light/dark sorting. */
-declare function luminance(hex: string): number;
-/** Define a color palette with background, surface, text, and accent colors for UI elements */
-interface DecidedPalette {
-    /** Lightest neutral — page background. */
-    background?: string;
-    /** A raised neutral one step from background. */
-    surface?: string;
-    /** Darkest readable color — primary text. */
-    textPrimary?: string;
-    /** Mid-tone neutral — secondary text. */
-    textSecondary?: string;
-    /** Most saturated / popular brand color — accent. */
-    accent?: string;
-    /** Readable text color to sit on the accent (black or white by contrast). */
-    accentText?: string;
-}
-/**
- * Assign palette roles from the ranked colors. Heuristic, not authoritative —
- * a confirmation step should let the user correct it. Roles only appear when
- * the kit actually contained a color that fits.
- */
-declare function decidePalette(palette: BrandColor[]): DecidedPalette;
-/** Define font selections for display and body text with optional BrandFont properties */
-interface DecidedFonts {
-    display?: BrandFont;
-    body?: BrandFont;
-}
-/** Pick a display and body font from the ranked list. When only one usable
- *  font exists it fills both roles — a single-typeface brand is valid. */
-declare function decideFonts(fonts: BrandFont[]): DecidedFonts;
-/** Everything a confirmation step needs from a kit, with roles decided. */
-interface DecidedBrandKit {
-    name?: string;
-    description?: string;
-    sourceUrl: string;
-    palette: DecidedPalette;
-    fonts: DecidedFonts;
-    /** Best logo URL, when any candidate was found. */
-    primaryLogoUrl?: string;
-    /** All logo URLs, ranked. */
-    logoUrls: string[];
-    /** Prominent image URLs, ranked. */
-    imageUrls: string[];
-    extractedFrom: string[];
-}
-/** Collapse a raw BrandKit into decided roles — the shape a product persists. */
-declare function decideBrandKit(kit: BrandKit): DecidedBrandKit;
-
-export { type BrandColor, type BrandExtractionResult, type BrandFont, type BrandImage, type BrandKit, type BrandLogoCandidate, type DecidedBrandKit, type DecidedFonts, type DecidedPalette, type ExtractBrandKitOptions, type FetchLike, decideBrandKit, decideFonts, decidePalette, extractBrandKit, luminance, normalizeColor, normalizeSiteUrl, parseBrandKit };
+ * @tangle-network/agent-app/brand-extraction
+ *
+ * Reusable brand-kit extraction: given a website URL (or raw HTML), produce a
+ * typed BrandKit — logos, palette, fonts, images — with a typed outcome and
+ * graceful degradation. Edge-safe (regex parsing, no DOM dependency). Pure
+ * mechanism: no persistence, no rendering. Consumers (gtm, creative) map the
+ * decided kit onto their own durable brand store via the `map` helpers.
+ */
+export * from './types';
+export { extractBrandKit, parseBrandKit, normalizeSiteUrl, normalizeColor } from './extract';
+export { decideBrandKit, decidePalette, decideFonts, luminance, } from './map';
+export type { DecidedBrandKit, DecidedPalette, DecidedFonts } from './map';

package/dist/brand-extraction/map.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Pure mapping helpers from an extracted BrandKit onto consumable shapes.
+ *
+ * Extraction yields ranked candidate lists; products need decided roles
+ * (background vs accent, display vs body). These helpers make the obvious,
+ * defensible default choice and expose the reasoning so a confirmation UI can
+ * show "we picked X — change it?". They NEVER invent a value: when a role can't
+ * be filled from the kit, it is omitted, and the caller decides the fallback.
+ */
+import type { BrandColor, BrandFont, BrandKit } from './types';
+/** Relative luminance (0..1) of an #rrggbb(aa) hex — for light/dark sorting. */
+export declare function luminance(hex: string): number;
+/** Define a color palette with background, surface, text, and accent colors for UI elements */
+export interface DecidedPalette {
+    /** Lightest neutral — page background. */
+    background?: string;
+    /** A raised neutral one step from background. */
+    surface?: string;
+    /** Darkest readable color — primary text. */
+    textPrimary?: string;
+    /** Mid-tone neutral — secondary text. */
+    textSecondary?: string;
+    /** Most saturated / popular brand color — accent. */
+    accent?: string;
+    /** Readable text color to sit on the accent (black or white by contrast). */
+    accentText?: string;
+}
+/**
+ * Assign palette roles from the ranked colors. Heuristic, not authoritative —
+ * a confirmation step should let the user correct it. Roles only appear when
+ * the kit actually contained a color that fits.
+ */
+export declare function decidePalette(palette: BrandColor[]): DecidedPalette;
+/** Define font selections for display and body text with optional BrandFont properties */
+export interface DecidedFonts {
+    display?: BrandFont;
+    body?: BrandFont;
+}
+/** Pick a display and body font from the ranked list. When only one usable
+ *  font exists it fills both roles — a single-typeface brand is valid. */
+export declare function decideFonts(fonts: BrandFont[]): DecidedFonts;
+/** Everything a confirmation step needs from a kit, with roles decided. */
+export interface DecidedBrandKit {
+    name?: string;
+    description?: string;
+    sourceUrl: string;
+    palette: DecidedPalette;
+    fonts: DecidedFonts;
+    /** Best logo URL, when any candidate was found. */
+    primaryLogoUrl?: string;
+    /** All logo URLs, ranked. */
+    logoUrls: string[];
+    /** Prominent image URLs, ranked. */
+    imageUrls: string[];
+    extractedFrom: string[];
+}
+/** Collapse a raw BrandKit into decided roles — the shape a product persists. */
+export declare function decideBrandKit(kit: BrandKit): DecidedBrandKit;

package/dist/brand-extraction/types.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Typed contract for a brand kit extracted from a website (+ optional shared
+ * source files). The extractor degrades gracefully: every field is best-effort,
+ * absence is represented explicitly (empty arrays, undefined), never faked.
+ *
+ * A consuming product (gtm, creative) maps this onto its own durable brand
+ * store — see the gtm `WorkspaceBrand`. This module owns only extraction; it
+ * does NOT persist, render, or judge confidence.
+ */
+/** A logo / brand-mark candidate discovered on a page. */
+export interface BrandLogoCandidate {
+    /** Absolute URL to the asset. */
+    url: string;
+    /** Where it came from — drives ranking and lets callers cite provenance. */
+    source: 'favicon' | 'apple-touch-icon' | 'og:image' | 'img-logo' | 'svg-inline' | 'manifest';
+    /** Higher = more likely the canonical logo. 0..1. */
+    confidence: number;
+    /** Declared width in px when known (from <link sizes> or <img width>). */
+    width?: number;
+    /** Declared height in px when known. */
+    height?: number;
+    /** MIME type when inferable from the extension. */
+    mimeType?: string;
+    /** alt / title text when present — a "logo" alt is a strong signal. */
+    alt?: string;
+}
+/** A color extracted from the page, with where it was seen. */
+export interface BrandColor {
+    /** Normalized 6- or 8-digit `#rrggbb` / `#rrggbbaa` hex (lowercase). */
+    hex: string;
+    /** How many distinct declarations referenced this color (popularity proxy). */
+    occurrences: number;
+    /** True when sourced from a `:root` CSS custom property (highest fidelity). */
+    fromToken: boolean;
+    /** The custom-property name when fromToken (e.g. `--accent`). */
+    tokenName?: string;
+}
+/** A font-family discovered in CSS, with role inference. */
+export interface BrandFont {
+    /** Primary family name, unquoted (e.g. `Inter`, `Playfair Display`). */
+    family: string;
+    /** The full declared stack as written, in order. */
+    stack: string[];
+    /** Inferred role from the selector the declaration was attached to. */
+    role: 'display' | 'body' | 'unknown';
+    /** Declaration count — popularity proxy for picking the dominant family. */
+    occurrences: number;
+}
+/** A prominent product / hero image candidate (not a logo). */
+export interface BrandImage {
+    url: string;
+    source: 'og:image' | 'twitter:image' | 'img-hero' | 'img-content';
+    /** alt text when present. */
+    alt?: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * The full extracted kit. The shape every consumer reads. Each list is ranked
+ * best-first; empty lists mean "found nothing", never a fabricated default.
+ */
+export interface BrandKit {
+    /** The site the kit was extracted from (normalized, absolute). */
+    sourceUrl: string;
+    /** Best-guess brand / product name from <title>, og:site_name, manifest. */
+    name?: string;
+    /** Tagline / description from meta description or og:description. */
+    description?: string;
+    /** Logo candidates, ranked best-first. */
+    logos: BrandLogoCandidate[];
+    /** Colors, ranked by token-first then popularity. */
+    palette: BrandColor[];
+    /** Fonts, ranked display-then-body then popularity. */
+    fonts: BrandFont[];
+    /** Prominent images (hero / og), ranked best-first. */
+    images: BrandImage[];
+    /** Absolute URLs / labels the kit was derived from — for provenance. */
+    extractedFrom: string[];
+}
+/**
+ * Typed outcome. Callers MUST inspect `succeeded` before reading `kit`.
+ * No silent empties: a fetch failure is `succeeded:false` with a real error,
+ * NOT an empty BrandKit that downstream code mistakes for "this brand has
+ * nothing".
+ */
+export type BrandExtractionResult = {
+    succeeded: true;
+    kit: BrandKit;
+    warnings: string[];
+} | {
+    succeeded: false;
+    error: string;
+    stage: 'fetch' | 'parse' | 'input';
+};
+/** Fetch boundary, injectable so callers (Workers, Node, tests) supply their
+ *  own fetch and so tests can run fully offline against fixture HTML. */
+export type FetchLike = (url: string, init?: {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+    headers?: {
+        get(name: string): string | null;
+    };
+}>;
+/** Define options for extracting brand kit data including HTML input, fetch method, timeout, and list limits */
+export interface ExtractBrandKitOptions {
+    /** Raw HTML for the page. When supplied, no network fetch happens — used by
+     *  tests and by callers that already hold the HTML. */
+    html?: string;
+    /** Fetch implementation. Required when `html` is omitted. */
+    fetchImpl?: FetchLike;
+    /** Per-request timeout in ms (default 15000). Applied to the page fetch. */
+    timeoutMs?: number;
+    /** Cap on each ranked list (default 12). Keeps payloads bounded. */
+    maxPerList?: number;
+}

package/dist/catalog/index.d.ts

@@ -1,105 +1,15 @@
 /**
- * Model catalogue — computed live from the Tangle Router, never hand-curated.
- * Lifted from tuner-agent so every agent app's model picker shares one
- * filter/dedupe/rank/feature pipeline instead of re-deriving it.
+ * Browser-safe model-catalogue subpath.
  *
- * The router's /models endpoint returns every routeable model (~200), which is
- * unusable as a picker list: it mixes chat models with TTS/embedding/realtime
- * endpoints, dated snapshots alias their parents, and provider-prefixed ids
- * duplicate canonical ones. This module turns that into a product catalogue:
+ * `./runtime` is a SERVER barrel: alongside the catalogue it re-exports
+ * `createAgentRuntime`/`runAppToolLoop`, which import
+ * `@tangle-network/agent-runtime` (node:util, child_process). Any client
+ * component that imports a `/runtime` VALUE ships Node-only code into its
+ * route bundle and the module throws on load — this broke the chat route on
+ * legal-agent (#256) and the home composer on tax-agent (#372).
  *
- *   filter (chat-capable, routeable) → dedupe (snapshot/prefix/:free aliases)
- *   → rank (provider tier, family, version) → feature (best model per family)
- *   → default (env override or first featured)
- *
- * Freshness is automatic: everything is derived from the live router response,
- * so new models surface as soon as the router lists them. The only static
- * knowledge here is slow-moving: provider display order and family name
- * patterns (e.g. "claude-sonnet-*", "gpt-N"). A new Sonnet or GPT release
- * outranks its predecessor by version comparison with zero code change; only
- * a brand-new *family name* (rare) needs a one-line rule addition.
- */
-interface RouterModel {
-    id: string;
-    name?: string;
-    description?: string;
-    _provider?: string;
-    pricing?: {
-        prompt?: string | null;
-        completion?: string | null;
-    };
-    context_length?: number;
-    architecture?: {
-        modality?: string;
-        input_modalities?: string[];
-        output_modalities?: string[];
-    };
-    supported_parameters?: string[];
-    routeability?: {
-        status?: string;
-        routeable?: boolean;
-        provider?: string;
-    };
-}
-/** Define the structure and capabilities of a catalog item with optional pricing and feature flags */
-interface CatalogModel {
-    id: string;
-    name: string;
-    provider: string;
-    description?: string;
-    contextLength?: number;
-    pricing?: {
-        prompt?: string;
-        completion?: string;
-    };
-    supportsTools: boolean;
-    supportsReasoning: boolean;
-    featured: boolean;
-}
-/** Define a catalog containing models with a default ID and fetch timestamp */
-interface ModelCatalog {
-    defaultModelId: string | null;
-    fetchedAt: string;
-    models: CatalogModel[];
-}
-/** Strip provider prefix, :free suffix, and trailing date stamps. */
-declare function normalizeModelId(id: string): string;
-/**
- * Can this router entry serve a text chat turn?
- *
- * The router lists every routeable endpoint, which is not the same list a chat
- * picker should show: measured against the live catalogue (504 entries), this
- * rejects 35 — image generators, TTS voices, embedding models, and the
- * audio-IN transcription endpoints (`whisper-1`, `gpt-4o-transcribe`, …) that
- * emit text but cannot take a text prompt.
- *
- * A model whose metadata omits either modality list is KEPT. The router is the
- * source of that metadata and it is occasionally sparse; dropping a usable
- * model because a field is missing is the worse failure of the two.
- *
- * Exported because a picker needs the same answer `buildCatalog` uses — the
- * fleet had this predicate copied into a product component, where its narrower
- * spelling let the 10 transcription endpoints through.
- */
-declare function isChatCapableModel(m: RouterModel): boolean;
-/**
- * Pure catalogue pipeline. `preferredDefault` (typically the MODEL_NAME env
- * var) wins when it survives filtering; otherwise the first featured model.
- */
-declare function buildCatalog(raw: RouterModel[], opts?: {
-    preferredDefault?: string;
-}): ModelCatalog;
-/**
- * Fetch the router model list and build the catalogue, with an in-isolate
- * cache (TTL 5 min). On router failure a stale catalogue is served rather
- * than erroring the picker.
+ * This subpath re-exports ONLY the pure catalogue pipeline (no Node imports,
+ * no agent-runtime) so pickers and client hooks have a safe import target.
+ * Server code may keep importing from `./runtime`; the two share one source.
  */
-declare function fetchModelCatalog(cfg: {
-    baseUrl: string;
-    apiKey: string;
-    preferredDefault?: string;
-}): Promise<ModelCatalog>;
-/** Test-only: clear the catalogue cache. */
-declare function __resetCatalogCache(): void;
-
-export { type CatalogModel, type ModelCatalog, type RouterModel, __resetCatalogCache, buildCatalog, fetchModelCatalog, isChatCapableModel, normalizeModelId };
+export { buildCatalog, fetchModelCatalog, isChatCapableModel, normalizeModelId, __resetCatalogCache, type CatalogModel, type ModelCatalog, type RouterModel, } from '../runtime/model-catalog';

package/dist/chat-react/composer-mode-controls.d.ts

@@ -0,0 +1,14 @@
+import type { ComposerPlanModeSelection } from './types';
+export interface ComposerModeControlsProps {
+    /**
+     * Plan-approval mode. Products pass it only when the selected backend can
+     * propose a plan and wait for approval; omitted means nothing renders.
+     */
+    planMode?: ComposerPlanModeSelection;
+}
+/**
+ * The shared plan-mode toggle for the left side of an agent composer.
+ * Plan mode is a behavioral switch, not part of the profile/backend/model/
+ * thinking identity controls on the right.
+ */
+export declare function ComposerModeControls({ planMode }: ComposerModeControlsProps): import("react").JSX.Element | null;