//#region src/validate.d.ts
/**
 * Semantic validation of A2UI v0.9 component trees (OSS-162).
 *
 * The middleware's streaming path only checks *structural* completeness (array
 * closed, each item has a `component` string). This module adds the *semantic*
 * checks whose failures otherwise blow up at render time in `@a2ui/web_core`
 * ("Component not found", "Catalog not found", unresolved bindings) — turning
 * them into machine-readable errors the recovery loop can feed back to the
 * sub-agent.
 *
 * Used by BOTH the adapter (to decide whether to retry) and the middleware (to
 * decide whether to paint) so the two never disagree on what "valid" means.
 */
/** A single, machine-readable validation failure. */
interface A2UIValidationError {
  code: "empty_components" | "missing_id" | "missing_component_type" | "duplicate_id" | "no_root" | "unknown_component" | "missing_required_prop" | "unresolved_child" | "child_cycle" | "unresolved_binding";
  /** A JSON-pointer-ish locator, e.g. `components[2].component`. */
  path: string;
  /** Human/LLM-readable description (fed back to the sub-agent on retry). */
  message: string;
}
interface ValidateA2UIResult {
  valid: boolean;
  errors: A2UIValidationError[];
}
/**
 * Inline JSON-Schema catalog (mirrors the middleware's `A2UIInlineCatalogSchema`):
 * component name → JSON Schema whose `required` lists mandatory props.
 */
interface A2UIValidationCatalog {
  components: Record<string, {
    required?: string[];
    properties?: Record<string, unknown>;
    [k: string]: unknown;
  }>;
}
interface ValidateA2UIInput {
  components: Array<Record<string, unknown>>;
  /** The surface's data model; used to resolve absolute binding paths. */
  data?: Record<string, unknown>;
  /** When omitted, catalog-dependent checks (membership, required props) are skipped. */
  catalog?: A2UIValidationCatalog;
  /**
   * Resolve absolute binding paths against `data`. Default `true`. Set `false`
   * at the streaming component-close boundary, where the component tree has
   * closed but the data model has not streamed yet — resolving bindings there
   * would false-positive (and trigger spurious retries). The adapter re-runs
   * full validation (bindings included) once the complete args arrive.
   */
  validateBindings?: boolean;
}
/**
 * Validate a flat A2UI v0.9 component array.
 *
 * Structural checks always run. Catalog membership + required-prop checks run
 * only when `catalog` is supplied. Absolute binding paths (`/foo`) are resolved
 * against `data`; relative template paths (`name`) are left alone — they resolve
 * per-item inside a repeated template and flagging them would produce false
 * positives (and spurious retries).
 */
declare function validateA2UIComponents(input: ValidateA2UIInput): ValidateA2UIResult;
//#endregion
//#region src/recovery.d.ts
/** Default attempt cap (initial try + retries). Configurable per call. */
declare const MAX_A2UI_ATTEMPTS = 3;
/** Activity type the middleware/client use for the recovery status channel. */
declare const A2UI_RECOVERY_ACTIVITY_TYPE = "a2ui_recovery";
/**
 * Developer-configurable recovery surface (Tyler's requirement). The threshold
 * is behavioral, not a hardcoded number: `showRetryUIAfter` lets the host decide
 * when the "Retrying…" status becomes perceptible enough to show.
 */
interface A2UIRecoveryConfig {
  /** Attempt cap (initial + retries). Default `MAX_A2UI_ATTEMPTS`. */
  maxAttempts?: number;
  /** When the (client-side) "Retrying UI generation…" status may appear. */
  showRetryUIAfter?: {
    ms?: number;
    attempts?: number;
  };
}
/** One attempt's outcome — surfaced to the adapter via `onAttempt` for status + dev traces. */
interface A2UIAttemptRecord {
  /** 1-based attempt number. */
  attempt: number;
  ok: boolean;
  errors: A2UIValidationError[];
}
interface RunA2UIRecoveryInput {
  /** The prepared sub-agent system prompt (output of `prepareA2UIRequest`). */
  basePrompt: string;
  /** Inline catalog for semantic validation; omit for structural-only. */
  catalog?: A2UIValidationCatalog;
  config?: A2UIRecoveryConfig;
  /**
   * Run the sub-agent once with `prompt` (already augmented with prior errors on
   * retries) and return its `render_a2ui` args `{surfaceId, components, data}`,
   * or `null` if the model produced no tool call.
   */
  invokeSubagent: (prompt: string, attempt: number) => Promise<Record<string, unknown> | null>;
  /** Turn validated `render_a2ui` args into the final operations envelope. */
  buildEnvelope: (args: Record<string, unknown>) => string;
  /** Per-attempt callback for emitting recovery status + dev logs. */
  onAttempt?: (record: A2UIAttemptRecord) => void;
}
interface RunA2UIRecoveryResult {
  /** Either the validated operations envelope, or a structured hard-failure envelope. */
  envelope: string;
  attempts: A2UIAttemptRecord[];
  ok: boolean;
}
/** Render structured errors as a compact, model-readable list. */
declare function formatValidationErrors(errors: A2UIValidationError[]): string;
/** Append a fix-it block describing the prior attempt's errors. No-op when there are none. */
declare function augmentPromptWithValidationErrors(prompt: string, errors: A2UIValidationError[]): string;
/**
 * Drive the validate→retry loop. Returns the validated envelope on success, or a
 * structured `a2ui_recovery_exhausted` envelope once the cap is hit. Never retries
 * an attempt whose components validated (the adapter must commit it).
 */
declare function runA2UIGenerationWithRecovery(input: RunA2UIRecoveryInput): Promise<RunA2UIRecoveryResult>;
//#endregion
//#region src/index.d.ts
/** Container key the A2UI middleware looks for in tool results. */
declare const A2UI_OPERATIONS_KEY = "a2ui_operations";
/** Default catalog id used when the subagent does not specify one. */
declare const BASIC_CATALOG_ID = "https://a2ui.org/specification/v0_9/basic_catalog.json";
/** A single A2UI v0.9 server-to-client operation. */
type A2UIOperation = Record<string, unknown>;
declare function createSurface(surfaceId: string, catalogId: string): A2UIOperation;
declare function updateComponents(surfaceId: string, components: Array<Record<string, unknown>>): A2UIOperation;
declare function updateDataModel(surfaceId: string, data: unknown, path?: string): A2UIOperation;
/**
 * JSON schema for the inner ``render_a2ui`` tool. Framework adapters bind
 * this on the subagent's model with ``tool_choice="render_a2ui"`` so the
 * structured-output call produces ``{surfaceId, components, data}``. The
 * catalog id is owned by the factory, not the subagent — the subagent can't
 * invent a catalog the host hasn't registered.
 */
declare const RENDER_A2UI_TOOL_DEF: {
  type: "function";
  function: {
    name: string;
    description: string;
    parameters: {
      type: string;
      properties: {
        surfaceId: {
          type: string;
          description: string;
        };
        components: {
          type: string;
          description: string;
          items: {
            type: string;
          };
        };
        data: {
          type: string;
          description: string;
        };
      };
      required: string[];
    };
  };
};
/**
 * Build the prompt prefix from AG-UI state context entries + the A2UI
 * component catalog. Framework integrations conventionally extract the
 * catalog into ``state["ag-ui"]["a2ui_schema"]`` and forward other context
 * entries (generation guidelines, design guidelines) under
 * ``state["ag-ui"]["context"]``.
 */
declare function buildContextPrompt(state: Record<string, unknown>): string;
/**
 * Context-entry description the ``@ag-ui/a2ui-middleware`` stamps onto the A2UI
 * component schema it injects into ``RunAgentInput.context``. Single home for
 * the constant so every framework adapter splits on the same string. MUST stay
 * byte-identical to ``A2UI_SCHEMA_CONTEXT_DESCRIPTION`` in
 * ``@ag-ui/a2ui-middleware`` (this is a wire contract, not prose).
 */
declare const A2UI_SCHEMA_CONTEXT_DESCRIPTION: string;
/**
 * Split AG-UI context entries into the A2UI component-schema entry and the
 * rest. The schema entry is the one whose ``description`` exactly equals
 * ``A2UI_SCHEMA_CONTEXT_DESCRIPTION``. Returns ``[schemaValue, regularContext]``:
 * adapters route ``schemaValue`` to ``state["ag-ui"]["a2ui_schema"]`` (rendered
 * as ``## Available Components`` by ``buildContextPrompt``) and ``regularContext``
 * to ``state["ag-ui"]["context"]``. Entries are returned unchanged.
 */
declare function splitA2UISchemaContext(context: Array<Record<string, unknown>> | undefined | null): [string | undefined, Array<Record<string, unknown>>];
/**
 * Find the frontend-registered A2UI catalog in run ``state``, returning
 * ``[componentSchema, catalogId]`` or ``undefined`` when no catalog is present.
 * Framework-agnostic, so every adapter resolves the catalog the same way.
 * Both delivery shapes live under the canonical ``state["ag-ui"]`` key:
 * - Schema entry: ``state["ag-ui"]["a2ui_schema"]``, a JSON string
 *   ``{"catalogId": ..., "components": [...]}`` (toolkit reads the schema from
 *   state for the prompt itself, so only the id is surfaced here).
 * - Catalog context entry: an ``state["ag-ui"]["context"]`` entry whose
 *   description mentions ``"A2UI catalog"``; the value lists catalogs as
 *   ``"- <catalogId>"`` lines, the first being the custom catalog.
 */
declare function resolveA2UICatalog(state: Record<string, unknown>): [string | undefined, string | undefined] | undefined;
interface PriorSurface {
  components: Array<Record<string, unknown>>;
  data: unknown;
  catalogId?: string;
}
/**
 * Locate the most recent rendered state for ``surfaceId`` in message history.
 *
 * Walks backwards looking for a tool result whose content is a JSON string
 * containing ``a2ui_operations`` for the given surface. Returns the
 * reconstructed ``{components, data, catalogId}``, or ``undefined`` if no
 * matching surface is found.
 */
declare function findPriorSurface(messages: Array<any>, surfaceId: string): PriorSurface | undefined;
interface EditContext {
  surfaceId: string;
  prior: PriorSurface;
  changes?: string;
}
/**
 * Default generation guidance (tool-call contract, id/path/data-binding rules).
 * Applied when `A2UIGuidelines.generationGuidelines` is unset (`undefined`).
 * Ported verbatim from the legacy `copilotkit.a2ui` defaults (OSS-248).
 */
declare const DEFAULT_GENERATION_GUIDELINES = "Generate A2UI v0.9 JSON.\n\n## A2UI Protocol Instructions\n\nA2UI (Agent to UI) is a protocol for rendering rich UI surfaces from agent responses.\n\nCRITICAL: You MUST call the render_a2ui tool with ALL of these arguments:\n- surfaceId: A unique ID for the surface (e.g. \"product-comparison\")\n- components: REQUIRED \u2014 the A2UI component array. NEVER omit this. Use a List with\n  children: { componentId: \"card-id\", path: \"/items\" } for repeating cards.\n- data: OPTIONAL \u2014 a JSON object written to the root of the surface data model.\n  Use for pre-filling form values or providing data for path-bound components.\n- every component must have the \"component\" field specifying the component type (e.g. \"Text\", \"Image\", \"Row\", \"Column\", \"List\", \"Button\", etc.)\n\nCOMPONENT ID RULES:\n- Every component ID must be unique within the surface.\n- A component MUST NOT reference itself as child/children. This causes a\n  circular dependency error. For example, if a component has id=\"avatar\",\n  its child must be a DIFFERENT id (e.g. \"avatar-img\"), never \"avatar\".\n- The child/children tree must be a DAG \u2014 no cycles allowed.\n\nPATH RULES FOR TEMPLATES:\nComponents inside a repeating List use RELATIVE paths (no leading slash).\nThe path is resolved relative to each array item automatically.\nIf List has children: { componentId: \"card\", path: \"/items\" } and item has key \"name\",\nuse { \"path\": \"name\" } (NO leading slash \u2014 relative to item).\nCRITICAL: Do NOT use \"/name\" (absolute) inside templates \u2014 use \"name\" (relative).\nThe List's own path (\"/items\") uses a leading slash (absolute), but all\ncomponents INSIDE the template card use paths WITHOUT leading slash.\nDo NOT use \"/items/0/name\" or \"/items/{@key}/name\" \u2014 just \"name\".\n\nDATA MODEL:\nThe \"data\" key in the tool args is a plain JSON object that initializes the surface\ndata model. Components bound to paths (e.g. \"value\": { \"path\": \"/form/name\" })\nread from and write to this data model. Examples:\n  For forms:  \"data\": { \"form\": { \"name\": \"Alice\", \"email\": \"\" } }\n  For lists:  \"data\": { \"items\": [{\"name\": \"Product A\"}, {\"name\": \"Product B\"}] }\n  For mixed:  \"data\": { \"form\": { \"query\": \"\" }, \"results\": [...] }\n\nFORMS AND TWO-WAY DATA BINDING:\nTo create editable forms, bind input components to data model paths using { \"path\": \"...\" }.\nThe client automatically writes user input back to the data model at the bound path.\nCRITICAL: Using a literal value (e.g. \"value\": \"\") makes the field READ-ONLY.\nYou MUST use { \"path\": \"...\" } to make inputs editable.\n\nAll input components use \"value\" as the binding property:\n- TextField:     \"value\": { \"path\": \"/form/fieldName\" }\n- CheckBox:      \"value\": { \"path\": \"/form/isChecked\" }\n- Slider:        \"value\": { \"path\": \"/form/sliderVal\" }\n- DateTimeInput: \"value\": { \"path\": \"/form/date\" }\n- ChoicePicker:  \"value\": { \"path\": \"/form/choices\" }\n\nTo retrieve form values when a button is clicked, include \"context\" with path references\nin the button's action. Paths are resolved to their current values at click time:\n  \"action\": { \"event\": { \"name\": \"submit\", \"context\": { \"userName\": { \"path\": \"/form/name\" } } } }\n\nTo pre-fill form values, pass initial data via the \"data\" tool argument:\n  \"data\": { \"form\": { \"name\": \"Markus\" } }\n\nFORM EXAMPLE (editable text field with pre-filled value + submit button):\n  \"components\": [\n    { \"id\": \"root\", \"component\": \"Card\", \"child\": \"form-col\" },\n    { \"id\": \"form-col\", \"component\": \"Column\", \"children\": [\"name-field\", \"submit-row\"] },\n    { \"id\": \"name-field\", \"component\": \"TextField\", \"label\": \"Name\", \"value\": { \"path\": \"/form/name\" } },\n    { \"id\": \"submit-row\", \"component\": \"Row\", \"justify\": \"end\", \"children\": [\"submit-btn\"] },\n    { \"id\": \"submit-btn\", \"component\": \"Button\", \"child\": \"btn-text\", \"variant\": \"primary\",\n      \"action\": { \"event\": { \"name\": \"submit\", \"context\": { \"userName\": { \"path\": \"/form/name\" } } } } },\n    { \"id\": \"btn-text\", \"component\": \"Text\", \"text\": \"Submit\" }\n  ],\n  \"data\": { \"form\": { \"name\": \"Markus\" } }";
/**
 * Default design guidance (visual hierarchy, layout, imagery, action format).
 * Applied when `A2UIGuidelines.designGuidelines` is unset (`undefined`).
 * Ported verbatim from the legacy `copilotkit.a2ui` defaults (OSS-248).
 */
declare const DEFAULT_DESIGN_GUIDELINES = "Create polished, visually appealing interfaces:\n- Always include a title heading (h2) for the surface, outside the List.\n  Wrap in a Column: [title, list] as root.\n- For card templates, create clear visual hierarchy:\n  - h3 for primary text (names, titles)\n  - h2 for featured numbers (prices, scores) \u2014 makes them stand out\n  - caption for secondary info (ratings, categories, metadata)\n  - body for descriptions\n- Use Divider between logical sections within cards.\n- Use Row with justify=\"spaceBetween\" for label-value pairs\n  (e.g. \"Rating\" on left, \"4.5/5\" on right).\n- Include images when relevant (logos, icons, product photos):\n  - Use Image component with variant=\"smallFeature\" or \"avatar\"\n  - Prefer company logos for branded products \u2014 Google favicons are reliable:\n    https://www.google.com/s2/favicons?domain=sony.com&sz=128\n    https://www.google.com/s2/favicons?domain=bose.com&sz=128\n  - For generic icons: https://placehold.co/128x128/EEE/999?text=\uD83C\uDFA7\n  - Do NOT invent Unsplash photo-IDs \u2014 they will 404. Only use real, known URLs.\n- Use horizontal List direction for side-by-side comparison cards.\n- Keep cards clean \u2014 avoid clutter. Whitespace is good.\n- Use consistent surfaceIds (lowercase, hyphenated).\n- NEVER use the same ID for a component and its child \u2014 this creates a\n  circular dependency. E.g. if id=\"avatar\", child must NOT be \"avatar\".\n- Both Row and Column support \"justify\" and \"align\".\n- Add Button for interactivity. Button needs child (Text ID) + action.\n  Action MUST use this exact nested format:\n    \"action\": { \"event\": { \"name\": \"myAction\", \"context\": { \"key\": \"value\" } } }\n  The \"event\" key holds an OBJECT with \"name\" (required) and \"context\" (optional).\n  Do NOT use a flat format like {\"event\": \"name\"} \u2014 \"event\" must be an object.\n  Use variant=\"primary\" for main action buttons, variant=\"borderless\" for links.\n- For forms: wrap fields in a Card with a Column. Place the submit button in a\n  Row with justify=\"end\". Every input MUST use path binding on the \"value\" property\n  (e.g. \"value\": { \"path\": \"/form/name\" }) to be editable. The submit button's action\n  context MUST reference the same paths to capture the user's input.\n\nUse the SAME surfaceId as the main surface. Match action names to Button action event names.";
/**
 * Prompt knobs threaded from the host through the adapter into the subagent
 * prompt. The toolkit owns this shape so a new knob is added here (and rendered
 * in `buildSubagentPrompt`) without editing any framework adapter — each adapter
 * forwards this bag verbatim.
 *
 * Per-field semantics (mirrors the legacy `a2ui_prompt` defaults):
 *   - key absent / `undefined` → the built-in `DEFAULT_*` block is used.
 *   - `""` (empty string)      → that block is suppressed (no section emitted).
 *   - any other string         → replaces the default for that block.
 *
 * `compositionGuide` has no default; it is appended only when provided.
 */
interface A2UIGuidelines {
  generationGuidelines?: string;
  designGuidelines?: string;
  compositionGuide?: string;
}
interface BuildSubagentPromptInput {
  /** Output of ``buildContextPrompt(state)``. */
  contextPrompt: string;
  /** Generation/design/composition prompt knobs (per-field defaults applied). */
  guidelines?: A2UIGuidelines;
  /** When set, instructs the subagent to edit a prior surface in place. */
  editContext?: EditContext;
}
/**
 * Compose the full system prompt the subagent sees.
 *
 * Section order: generation guidelines → design guidelines → context + catalog
 * (from ``contextPrompt``) → composition guide → edit-existing-surface block.
 * Faithful to the legacy ``a2ui_prompt`` ordering (generation lead, design
 * header, then available components).
 *
 * Generation and design fall back per-field to ``DEFAULT_GENERATION_GUIDELINES``
 * / ``DEFAULT_DESIGN_GUIDELINES`` when unset (``undefined``); an empty string
 * suppresses the block.
 */
declare function buildSubagentPrompt(input: BuildSubagentPromptInput): string;
interface AssembleOpsInput {
  /** ``"create"`` to render a new surface, ``"update"`` to modify a prior one. */
  intent: "create" | "update";
  surfaceId: string;
  catalogId: string;
  components: Array<Record<string, unknown>>;
  data?: Record<string, unknown>;
}
/**
 * Produce the final A2UI v0.9 operation list for a render result.
 *
 * ``create`` emits ``[createSurface, updateComponents, updateDataModel?]``.
 * ``update`` skips ``createSurface`` so the frontend reconciles the existing
 * surface in place instead of erroring (per v0.9 spec, ``createSurface`` on
 * an existing id is invalid).
 */
declare function assembleOps(input: AssembleOpsInput): A2UIOperation[];
/**
 * Wrap a list of A2UI operations as the JSON envelope the A2UI middleware
 * looks for in tool results.
 */
declare function wrapAsOperationsEnvelope(ops: A2UIOperation[]): string;
/**
 * Wrap an error as the JSON string a subagent tool returns when it can't
 * produce a surface. Keeps the error shape consistent across frameworks.
 */
declare function wrapErrorEnvelope(message: string): string;
/** Surface id used when the subagent omits ``surfaceId`` on a create. */
declare const DEFAULT_SURFACE_ID = "dynamic-surface";
/** Default name the outer A2UI tool is advertised under to the main planner. */
declare const GENERATE_A2UI_TOOL_NAME = "generate_a2ui";
/** Default description shown to the main agent's planner. */
declare const GENERATE_A2UI_TOOL_DESCRIPTION: string;
/** Planner-facing descriptions for the outer tool's three arguments. */
declare const GENERATE_A2UI_ARG_DESCRIPTIONS: {
  readonly intent: "'create' to render a new surface; 'update' to modify a surface previously rendered in this conversation. Defaults to 'create'.";
  readonly target_surface_id: "Required when intent='update'. The surface id of the prior render to modify.";
  readonly changes: "Optional natural-language description of the changes to apply when intent='update'.";
};
interface A2UIToolParams<TModel = unknown> {
  /** Chat model the subagent invokes for structured A2UI output. The one
   *  framework-specific field — typed per framework via the generic. */
  model: TModel;
  /** Generation/design/composition prompt knobs (per-field defaults applied). */
  guidelines?: A2UIGuidelines;
  /** Surface id used when the subagent omits `surfaceId`. */
  defaultSurfaceId?: string;
  /** Catalog id assigned to every new surface this factory creates — the
   *  subagent never picks the catalog. Falls back to the basic v0.9 catalog. */
  defaultCatalogId?: string;
  /** Name advertised to the main agent's planner. */
  toolName?: string;
  /** Description shown to the main agent's planner. */
  toolDescription?: string;
  /** Inline catalog enabling catalog-aware recovery. Pass the SAME catalog the
   *  host gives the middleware so retry decision + paint gate agree. */
  catalog?: A2UIValidationCatalog;
  /** Recovery loop config: attempt cap, retry-UI threshold, debug exposure. */
  recovery?: A2UIRecoveryConfig;
  /** Per-attempt hook for recovery status / dev logs (non-disruptive). */
  onA2UIAttempt?: (record: A2UIAttemptRecord) => void;
}
/** `A2UIToolParams` with every optional field resolved to its effective value.
 *  Returned by `resolveA2UIToolParams` so adapters never re-implement defaults. */
interface ResolvedA2UIToolParams<TModel = unknown> {
  model: TModel;
  guidelines?: A2UIGuidelines;
  defaultSurfaceId: string;
  defaultCatalogId: string;
  toolName: string;
  toolDescription: string;
  catalog?: A2UIValidationCatalog;
  recovery?: A2UIRecoveryConfig;
  onA2UIAttempt?: (record: A2UIAttemptRecord) => void;
}
/**
 * Normalize an `A2UIToolParams` into a `ResolvedA2UIToolParams`, filling the
 * canonical defaults so each framework adapter stops re-implementing
 * `toolName || DEFAULT` / `catalogId || BASIC` lines.
 *
 * Uses `||` (not `??`) so an accidental empty-string override from a caller
 * falls back to the canonical default rather than advertising a nameless /
 * empty-description tool or emitting a blank surface/catalog id.
 */
declare function resolveA2UIToolParams<TModel>(params: A2UIToolParams<TModel>): ResolvedA2UIToolParams<TModel>;
interface PrepareA2UIRequestInput {
  /** Raw ``intent`` arg from the planner (defaults to ``"create"``). */
  intent?: string;
  /** Raw ``target_surface_id`` arg from the planner. */
  targetSurfaceId?: string;
  /** Raw ``changes`` arg from the planner. */
  changes?: string;
  /** Conversation history with the current (unbalanced) tool call stripped. */
  messages: Array<any>;
  /** The agent's run state (read for context + catalog via buildContextPrompt). */
  state: Record<string, unknown>;
  /**
   * Generation/design/composition prompt knobs, forwarded verbatim to
   * ``buildSubagentPrompt``. The toolkit owns the shape so adapters never need
   * editing when a knob is added.
   */
  guidelines?: A2UIGuidelines;
}
interface PreparedA2UIRequest {
  /** System prompt to feed the subagent. Empty string when ``error`` is set. */
  prompt: string;
  /** Whether this is an in-place edit of a prior surface. */
  isUpdate: boolean;
  /** The reconstructed prior surface, when editing. */
  prior?: PriorSurface;
  /** Set when the request is invalid (e.g. update with no matching surface). */
  error?: string;
}
/**
 * Resolve the create/update decision, locate any prior surface, and build the
 * subagent system prompt. Returns ``error`` instead of a prompt when the
 * request is invalid (update referencing a surface not in history).
 */
declare function prepareA2UIRequest(input: PrepareA2UIRequestInput): PreparedA2UIRequest;
interface BuildA2UIEnvelopeInput {
  /** The subagent's ``render_a2ui`` structured-output args. */
  args: Record<string, unknown>;
  /** From ``prepareA2UIRequest``. */
  isUpdate: boolean;
  /** The planner's ``target_surface_id`` (used as the surface id on update). */
  targetSurfaceId?: string;
  /** The prior surface from ``prepareA2UIRequest`` (supplies the catalog id on update). */
  prior?: PriorSurface;
  /** Surface id used when the subagent omits one on create. */
  defaultSurfaceId?: string;
  /** Catalog id used when there's no prior surface to inherit one from. */
  defaultCatalogId?: string;
}
/**
 * Turn the subagent's structured output into the final operations envelope.
 *
 * Catalog ownership stays with the host: the subagent never picks a catalog,
 * so the id comes from the prior surface (update) or the configured default
 * (create) — never from the model's args.
 */
declare function buildA2UIEnvelope(input: BuildA2UIEnvelopeInput): string;
//#endregion
export { A2UIAttemptRecord, A2UIGuidelines, A2UIOperation, A2UIRecoveryConfig, A2UIToolParams, A2UIValidationCatalog, A2UIValidationError, A2UI_OPERATIONS_KEY, A2UI_RECOVERY_ACTIVITY_TYPE, A2UI_SCHEMA_CONTEXT_DESCRIPTION, AssembleOpsInput, BASIC_CATALOG_ID, BuildA2UIEnvelopeInput, BuildSubagentPromptInput, DEFAULT_DESIGN_GUIDELINES, DEFAULT_GENERATION_GUIDELINES, DEFAULT_SURFACE_ID, EditContext, GENERATE_A2UI_ARG_DESCRIPTIONS, GENERATE_A2UI_TOOL_DESCRIPTION, GENERATE_A2UI_TOOL_NAME, MAX_A2UI_ATTEMPTS, PrepareA2UIRequestInput, PreparedA2UIRequest, PriorSurface, RENDER_A2UI_TOOL_DEF, ResolvedA2UIToolParams, RunA2UIRecoveryInput, RunA2UIRecoveryResult, ValidateA2UIInput, ValidateA2UIResult, assembleOps, augmentPromptWithValidationErrors, buildA2UIEnvelope, buildContextPrompt, buildSubagentPrompt, createSurface, findPriorSurface, formatValidationErrors, prepareA2UIRequest, resolveA2UICatalog, resolveA2UIToolParams, runA2UIGenerationWithRecovery, splitA2UISchemaContext, updateComponents, updateDataModel, validateA2UIComponents, wrapAsOperationsEnvelope, wrapErrorEnvelope };
//# sourceMappingURL=index.d.mts.map