/** * MCP Tool Zod Schemas — Single Source of Truth * * These schemas define the validation rules for MCP tool inputs. * TypeScript types in types/mcp.ts are derived from these via z.infer. * * Two consumption patterns, both anchored here: * * - **Wired raw shapes** (`*InputShape`): handlers in * `@ggui-ai/mcp-server-handlers` (and a hosted deployment's discover * tool) import the SHAPE directly as their `inputSchema` and * validate with `z.object(shape)` — unknown keys are STRIPPED. * The shape is the one authored copy of the validation rules AND * the agent-facing `.describe()` strings that ship via * `tools/list`. * * - **Lifecycle triad** (`ggui_handshake` / `ggui_update`): the * handlers carry deliberate input divergences (handshake's * blueprintDraft contract is loose ON PURPOSE so the negotiator can * repair malformations; update's sessionId is optional for * in-process dispatch), so they author their own raw shapes. The * schemas here remain the canonical strict wire contract + the * `z.infer` source for the published types. `ggui_render` is wired: * its handler imports {@link renderInputShape}. */ import { z } from 'zod'; /** * `ggui_consume` input. The long-poll bound is SPEC §7.3: integer * seconds in `[0, 25]` — the cap dodges infrastructure kill windows * (API-gateway 30s HTTP limits, host MCP clients that abort long tool * calls). Longer waits are the agent's loop, not a server knob. */ export declare const consumeInputShape: { readonly sessionId: z.ZodString; readonly timeout: z.ZodOptional; }; export declare const consumeInputSchema: z.ZodObject<{ sessionId: z.ZodString; timeout: z.ZodOptional; }, z.core.$strip>; /** * `ggui_emit` input — emit a stamped delivery on a declared * `streamSpec[channel]`. */ export declare const emitInputShape: { readonly sessionId: z.ZodString; readonly channel: z.ZodString; readonly payload: z.ZodUnknown; readonly complete: z.ZodOptional; }; export declare const emitInputSchema: z.ZodObject<{ sessionId: z.ZodString; channel: z.ZodString; payload: z.ZodUnknown; complete: z.ZodOptional; }, z.core.$strip>; export declare const getSessionInputShape: { readonly sessionId: z.ZodString; }; export declare const getSessionInputSchema: z.ZodObject<{ sessionId: z.ZodString; }, z.core.$strip>; /** * `ggui_get_render_source` input — read the generated source of the * calling app's own render. Same shape as {@link getSessionInputShape} * (both take only a sessionId); kept as its own named export rather * than reused directly so each tool's wire contract is independently * pinned, per this file's one-shape-per-tool convention. */ export declare const getRenderSourceInputShape: { readonly sessionId: z.ZodString; }; export declare const getRenderSourceInputSchema: z.ZodObject<{ sessionId: z.ZodString; }, z.core.$strip>; /** * `ggui_list_featured_blueprints` input — intentionally EMPTY. The * pre-launch No-Backcompat scrub deleted the level/category/tags/limit * filters (delete-until-wired); filters re-enter here when a real * consumer passes them. */ export declare const listFeaturedBlueprintsInputShape: {}; export declare const listFeaturedBlueprintsInputSchema: z.ZodObject<{}, z.core.$strip>; export declare const searchBlueprintsInputShape: { readonly query: z.ZodString; readonly limit: z.ZodOptional; readonly tool: z.ZodOptional; readonly server: z.ZodOptional; }; export declare const searchBlueprintsInputSchema: z.ZodObject<{ query: z.ZodString; limit: z.ZodOptional; tool: z.ZodOptional; server: z.ZodOptional; }, z.core.$strip>; export declare const renderBlueprintInputShape: { readonly blueprintId: z.ZodString; }; export declare const renderBlueprintInputSchema: z.ZodObject<{ blueprintId: z.ZodString; }, z.core.$strip>; export declare const discoverInputShape: {}; export declare const discoverInputSchema: z.ZodObject<{}, z.core.$strip>; /** * `ggui_handshake` — three-step suggestion protocol. * * Step 1 (this input): the agent posts a draft — its idea: contract + * optional variance + optional generator hint. * * Step 2 (server-side, see `handshakeOutputSchema`): the server runs * `BlueprintSearch` and contract-validation in parallel and returns a * `HandshakeSuggestion` routed by `origin: cache | agent | synth`. * * Step 3 (paired `ggui_render`): the agent accepts (reuses the * provisional `blueprintId` minted in step-2) OR overrides (mints a * fresh `blueprintId` against a NEW draft). * * Locked decisions: * * - `blueprintDraft` is the single-field input wrapping contract + * variance + generator hint. * - The agent is the contract authority; synth amends only when * validation fails. * - Post-Phase-B the handshake input carries NO `sessionId`. The * server mints `sessionId` on the paired `ggui_render`; host * conversation grouping flows via the host-supplied * `_meta["ai.ggui/host-session"]` envelope captured at render * creation (see {@link GguiSessionBase.hostSession}). */ export declare const handshakeInputSchema: z.ZodObject<{ intent: z.ZodString; blueprintDraft: z.ZodType>; forceCreate: z.ZodOptional; }, z.core.$strict>; /** * Three-step handshake output. Single `suggestion` carries * `origin: cache | agent | synth`, `blueprintMeta` (always present), * and optional `amendments` (synth-only) / `validationFindings` * (soft on cache). * * The agent reads `suggestion.origin` to branch the paired render call: * * - `cache` → render `{handshakeId, props}` (omit `override`) for cache delivery. * - `agent` → render `{handshakeId, props}` (omit `override`) to gen against the draft. * - `synth` → render `{handshakeId, props}` (omit `override`) to gen against the amended contract. * * Any origin → render `{handshakeId, props, override: {contract?, variance?}}` * to re-aim the suggestion — `override.contract` re-aims to a fresh * contract (resolved at its own key); `override.variance` re-aims the * variant axis. * * Wire-output is intentionally lean. The handler carries `target`, * `alternatives`, `contractHash`, `serverCapabilities` on its internal * `HandshakeOutput` TS shape for telemetry / post-classify tracing — * zod strips them before structuredContent serialization. `reason` IS * a wire field (optional, ≤280 chars — see below). * * `serverCapabilities` reaches the iframe via the `ai.ggui/render` * slice meta (see `slice-meta-derivation.ts`), not via this response. * * Post-Phase-B the `'compose'` action enum value is gone — there is no * stack of N renders to compose against. Three create/update branches + * `'declined'` cover every legal outcome. */ export declare const handshakeOutputSchema: z.ZodObject<{ handshakeId: z.ZodString; action: z.ZodEnum<{ replace: "replace"; create: "create"; reuse: "reuse"; update: "update"; declined: "declined"; }>; suggestion: z.ZodType>; reason: z.ZodOptional; nextStep: z.ZodOptional; description: z.ZodString; example: z.ZodString; }, z.core.$strip>>; }, z.core.$strip>; /** * `ggui_render` — materialises a UI emission. Step 3 of the three-step * handshake protocol. * * The agent commits relative to the prior handshake's suggestion by * PRESENCE of `override` (no discriminated union): omit `override` to * ACCEPT the proposal as-is, or provide `override: {contract?, variance?}` * to re-aim the contract and/or the variant axis (PATCH semantics). * * Locked decisions: * * - ACCEPT (omit `override`) reuses the agreed contract + the proposed * variance, resolving the proposed `(contractKey, variantKey)`. * - `override.contract` re-drafts the contract (STRICT — must already * conform; the server does not repair it) and re-resolves the * effective `(blueprintKey(newContract), variantKey)` — reuse if a * blueprint exists there, else cold-gen registered under that key. * An override is a RE-AIM, never a request for a fresh generation * (ggui#1131); `forceCreate` on the handshake is the only lever * that forces one. * - `override.variance` re-aims the variant axis while keeping the * agreed contract, re-resolving the effective * `(contractKey, variantKey(newVariance))`. * - `props` is REQUIRED (pass `{}` when the effective contract declares * no propsSpec). * * There is no separate `ggui_commit` — render absorbs that responsibility. * * Post-Phase-B rename from `ggui_push` — the tool materialises a single * render (no stack of N to push onto); the new name reflects what the * tool does at the protocol surface. * * WIRED shape — `@ggui-ai/mcp-server-handlers`'s `ggui_render` registers * {@link renderInputShape} as its `inputSchema` and validates with * `z.object(shape)` (unknown top-level keys strip; `infra` / `override` * sub-objects stay `.strict()` so typos inside them surface as clear zod * paths). */ export declare const renderInputShape: { readonly handshakeId: z.ZodString; /** * Runtime prop values for THIS render. Validated against the * effective contract's `propsSpec` — required-field checks + type * checks per spec entry. Validation failures fail the render with a * recoverable `ContractViolationError`. * * REQUIRED — pass `{}` when the effective contract declares no * propsSpec (the field is required, the value may be empty). */ readonly props: z.ZodRecord; /** * Per-render theme override. When set, lands on the committed * render and takes priority over `App.defaultThemeId` at * bootstrap-projection time. Use sparingly — most renders should * inherit the app default. */ readonly themeId: z.ZodOptional; /** * Typed `infra` envelope. Today carries one field (`model`); future * expansion (temperature, max_tokens, provider hints) lands here * additively. `model` MUST parse as a model route in either wire form — * canonical `provider:model` or LiteLLM `provider/model` (aliases resolve * in both). The mechanism is `renderInputEnvelopeSchema` * (`schemas/render-input-envelope.ts`), which the render handler parses * BEFORE its pre-generation gate; this registered shape stays * parser-free by design so a browser bundle never carries the route * tables (ggui#818). A bound generator may also accept generator-specific * prefixes for alternate transports. * * Strict — extra keys at `infra.*` are not silently dropped, so a * typo (`infra.modelId`) surfaces as a clear zod path instead of a * silent default-model fallback. */ readonly infra: z.ZodOptional; }, z.core.$strict>>; /** * Re-aim the handshake proposal (PATCH semantics). Omit to ACCEPT the * proposal as-is; provide to re-draft the contract and/or re-aim the * variant axis. At least one of `contract` / `variance` MUST be set — * an empty `override: {}` is rejected. * * - `contract` — STRICT full re-draft of the contract. The server * does NOT repair it; it must already conform. * - `variance` — re-aim the variant axis (persona / aesthetic / * context / seedPrompt) while keeping the agreed contract. A * different variance resolves a distinct cached component. */ readonly override: z.ZodOptional>>; variance: z.ZodOptional>>; }, z.core.$strict>>; }; export declare const renderInputSchema: z.ZodObject<{ handshakeId: z.ZodString; props: z.ZodRecord; themeId: z.ZodOptional; infra: z.ZodOptional; }, z.core.$strict>>; override: z.ZodOptional>>; variance: z.ZodOptional>>; }, z.core.$strict>>; }, z.core.$strip>; /** * Reuse outcome for a single `ggui_render` — surfaced on the wire so an * agent or operator can tell whether a stored component was served or a * new one was generated. Counts generation calls only; it carries no * cost or tier semantics. */ export declare const renderCacheMarkerSchema: z.ZodObject<{ hit: z.ZodBoolean; similarity: z.ZodOptional; cachedBlueprintId: z.ZodOptional; llmCallsAvoided: z.ZodNumber; kind: z.ZodOptional>; reason: z.ZodOptional; }, z.core.$strip>; /** * Canonical failure codes for the in-result `ggui_render` failure * envelope (SPEC §7.9 Plane 3). Closed enum — a failed render's * `error.code` is always one of these five; finer-grained diagnostics * ride on `error.message`. * * - `PRODUCTION_FAILED` — generation ran but did not produce a * component (LLM/compile/commit failure). * - `VALIDATION_ERROR` — a server-side precondition rejected the * render before generation could run (misconfigured generation * route, unusable stored config). * - `NO_PLATFORM_KEY` — the server's managed provider-key * configuration has no key for the resolved route. * - `NO_CREDENTIALS` — no generation credentials are configured on * the server at all. * - `GENERATION_QUEUE_OVERLOADED` — the deployment's generation * admission gate rejected this request before any generation * attempt started (concurrent-request queue full, or wait for a * free slot exceeded the configured timeout). Distinct from * `PRODUCTION_FAILED` by design: generation never ran, so callers * MUST NOT bill or count it as a failed attempt. See * {@link GenerationError} in `types/ui-generator.ts` for the full * contract. */ export declare const renderErrorCodeSchema: z.ZodEnum<{ PRODUCTION_FAILED: "PRODUCTION_FAILED"; VALIDATION_ERROR: "VALIDATION_ERROR"; NO_PLATFORM_KEY: "NO_PLATFORM_KEY"; NO_CREDENTIALS: "NO_CREDENTIALS"; GENERATION_QUEUE_OVERLOADED: "GENERATION_QUEUE_OVERLOADED"; }>; /** * Canonical inferred type for {@link renderErrorCodeSchema}. Lives * beside the schema (rather than in `types/mcp.ts`, which re-exports * it) so `types/render.ts` can reference it without a type-only * import cycle through `types/mcp.ts`. */ export type RenderErrorCode = z.infer; /** * In-result failure marker for `ggui_render`. Present on the wire * output iff the tool result is `isError: true` — the structuredContent * stays schema-conformant on failures, and this field carries the * canonical failure classification. */ export declare const renderErrorSchema: z.ZodObject<{ code: z.ZodEnum<{ PRODUCTION_FAILED: "PRODUCTION_FAILED"; VALIDATION_ERROR: "VALIDATION_ERROR"; NO_PLATFORM_KEY: "NO_PLATFORM_KEY"; NO_CREDENTIALS: "NO_CREDENTIALS"; GENERATION_QUEUE_OVERLOADED: "GENERATION_QUEUE_OVERLOADED"; }>; message: z.ZodString; }, z.core.$strip>; /** * The three outcomes a `ggui_render` result can report (SPEC §7.1, * ggui#786). A reader branches on this rather than guessing from which * fields happen to be present: * * - `rendered` — the render ran and produced an interface. The * identity fields (`sessionId`, `action`, `contractHash`, * `blueprintId`, `variantKey`, `cache`) are all present. * - `failed` — generation RAN and did not produce a component. The * error session IS committed, so the identity fields are present * and `error` carries the classification. The handshake is * consumed. * - `refused` — the deployment declined the call BEFORE it did any * work: no state read, nothing committed, no spend. (The SDK has * already checked the call against the declared `inputSchema` — * the claim is nothing READ, not nothing validated.) The identity * fields are structurally ABSENT and `refusal` carries the whole * story; the handshake is INTACT, so the same id is valid on a * retry. * * Declared HERE rather than in `types/mcp.ts` (which re-exports the * inferred type) so `types/render.ts` can reference it without a * type-only import cycle through `types/mcp.ts` — same convention as * {@link renderErrorCodeSchema}. */ export declare const renderOutcomeSchema: z.ZodEnum<{ rendered: "rendered"; failed: "failed"; refused: "refused"; }>; /** Canonical inferred type for {@link renderOutcomeSchema}. */ export type RenderOutcome = z.infer; export declare const renderRefusalSchema: z.ZodObject<{ handshake: z.ZodLiteral<"intact">; balanceCentsAtCheck: z.ZodOptional; message: z.ZodString; fix: z.ZodString; retry: z.ZodEnum<{ never: "never"; "after-fix": "after-fix"; "next-period": "next-period"; later: "later"; }>; code: z.ZodEnum<{ unsupported_provider: "unsupported_provider"; insufficient_credit: "insufficient_credit"; hard_cap_exceeded: "hard_cap_exceeded"; model_not_allowed: "model_not_allowed"; managed_default_cap_exceeded: "managed_default_cap_exceeded"; app_policy_missing: "app_policy_missing"; billing_mode_anomaly: "billing_mode_anomaly"; issuer_rate_limited: "issuer_rate_limited"; app_rate_limited: "app_rate_limited"; app_deprovisioned: "app_deprovisioned"; billing_path_missing: "billing_path_missing"; }>; }, z.core.$strip>; /** The refusal marker, derived from {@link renderRefusalSchema}. */ export type PreGenerationRefusal = z.infer; /** * A refusal typed on the per-app MCP endpoint's authorization * (ggui#825) — the registry projection WITHOUT the render-only fields: * no `handshake` (nothing was handed), no `balanceCentsAtCheck`. Strict: * a render-only field here is a bug, never a wire state. `code` draws * from {@link MCP_ENDPOINT_REFUSAL_CODES} — today exactly * `app_deprovisioned`, the one refusal with a tenant-side fix and * therefore the one that MUST be legible where a deleted app and a bad * credential would otherwise look alike. `appId` (ggui#870) is the app * the refused endpoint serves, as DATA — equal to the path's `{appId}` * — so a tenant's repair loop keys on it and never parses prose; it is * the ggui id the bound caller already holds, never the tenant's own * `ownerRef`. The typed refusal answers a correctly bound federated * identity only (identity first): an anonymous request is refused by the * auth adapter before this arm, and learns nothing about the app. */ export declare const transportRefusalSchema: z.ZodObject<{ appId: z.ZodString; message: z.ZodString; fix: z.ZodString; retry: z.ZodEnum<{ never: "never"; "after-fix": "after-fix"; "next-period": "next-period"; later: "later"; }>; code: z.ZodEnum<{ app_deprovisioned: "app_deprovisioned"; }>; }, z.core.$strict>; /** A refusal on the per-app MCP endpoint, derived from {@link transportRefusalSchema}. */ export type TransportRefusal = z.infer; /** * The JSON-RPC error object a per-app MCP endpoint answers with when it * refuses a request for a typed reason (ggui#825, codes ruled in * ggui#836): HTTP 403, `code` `-32003` (`APP_NOT_FOUND` — the endpoint * no longer serves this app, the same reading ggui's embed host gives a * proxy 403) and `message` `App not found`, plus `data.refusal`, which * makes it legible. `data` is strict: it carries the refusal and nothing * else. An authorization failure that is not a registry state answers * HTTP 403 with `-32007` (`UNAUTHORIZED`) and NO `data` — the three * untyped arms stay indistinguishable among themselves by contract: * naming any of them would say which is true. A first-party server * never chooses `-32000`: it is the SDK client's `ConnectionClosed`, so * a bare 403 and a dropped socket would share a number. */ export declare const transportRefusalErrorSchema: z.ZodObject<{ code: z.ZodLiteral<-32003>; message: z.ZodLiteral<"App not found">; data: z.ZodObject<{ refusal: z.ZodObject<{ appId: z.ZodString; message: z.ZodString; fix: z.ZodString; retry: z.ZodEnum<{ never: "never"; "after-fix": "after-fix"; "next-period": "next-period"; later: "later"; }>; code: z.ZodEnum<{ app_deprovisioned: "app_deprovisioned"; }>; }, z.core.$strict>; }, z.core.$strict>; }, z.core.$strict>; /** The typed-refusal JSON-RPC error object, derived from {@link transportRefusalErrorSchema}. */ export type TransportRefusalError = z.infer; /** * The COMPLETE structuredContent of a refused tool result — the whole * payload, not a slice of it. Strict on purpose: a refusal commits * nothing, so ANY other key (a `sessionId`, a `resourceUri`, an * `error`) means the projection leaked state that does not exist. * * Today `ggui_render` is the only tool that carries a refusing gate; * {@link renderOutputSchema} delegates its refused arm here rather than * restating the rules, so there is exactly ONE declaration of them. * * NOT reusable verbatim by a second refusing tool, despite the strict * shape reading as generic: {@link renderRefusalSchema} REQUIRES * `handshake: 'intact'`, and that field is render-only by * construction — a mutation consumes no handshake, so it has nothing * to report intact. A mutation arm therefore lands WITH its first * emitter, sharing the facts this envelope carries (`code`, `message`, * `fix`, `retry`, one closed registry) and carrying no `handshake` * field at all (ggui#798). */ export declare const refusedOutputSchema: z.ZodObject<{ outcome: z.ZodLiteral<"refused">; refusal: z.ZodObject<{ handshake: z.ZodLiteral<"intact">; balanceCentsAtCheck: z.ZodOptional; message: z.ZodString; fix: z.ZodString; retry: z.ZodEnum<{ never: "never"; "after-fix": "after-fix"; "next-period": "next-period"; later: "later"; }>; code: z.ZodEnum<{ unsupported_provider: "unsupported_provider"; insufficient_credit: "insufficient_credit"; hard_cap_exceeded: "hard_cap_exceeded"; model_not_allowed: "model_not_allowed"; managed_default_cap_exceeded: "managed_default_cap_exceeded"; app_policy_missing: "app_policy_missing"; billing_mode_anomaly: "billing_mode_anomaly"; issuer_rate_limited: "issuer_rate_limited"; app_rate_limited: "app_rate_limited"; app_deprovisioned: "app_deprovisioned"; billing_path_missing: "billing_path_missing"; }>; }, z.core.$strip>; }, z.core.$strict>; /** * Canonical failure codes for a `resources/read` on a render locator * (`ui://ggui/render/{sessionId}/{blueprintKey}`). Closed enum. * * This is a DIFFERENT surface from {@link renderErrorCodeSchema}: that * one classifies a `ggui_render` tool call that ran and failed, and * rides in the tool result. This one classifies a resource read that * cannot return a mount, and rides on a JSON-RPC error — a read either * yields a live mount or fails, never a successful result wrapping a * dead shell. That is what makes the contract host-checkable. * * - `NOT_FOUND` — no live render and no restorable record. The * locator never existed, aged out, was erased, or the caller may * not read it. Denial is deliberately reported as absence: a * distinguishable "denied" would turn the read into an oracle for * the existence of other callers' renders. * - `BLUEPRINT_UNRESOLVABLE` — a record exists, but the component * behind it cannot be resolved: removed, taken down, or the record * carries no component reference at all. * - `NOT_SUPPORTED` — this deployment keeps no durable record, so an * evicted locator can never be restored. A property of the server, * identical for every caller and every locator. * - `NOT_MOUNTABLE` — the render resolved, but no delivery channel is * available to mount it. */ export declare const resourceReadErrorCodeSchema: z.ZodEnum<{ NOT_FOUND: "NOT_FOUND"; BLUEPRINT_UNRESOLVABLE: "BLUEPRINT_UNRESOLVABLE"; NOT_SUPPORTED: "NOT_SUPPORTED"; NOT_MOUNTABLE: "NOT_MOUNTABLE"; }>; /** * Failure shape for a `resources/read` that cannot return a mount. * Projected onto a JSON-RPC error by `resourceReadErrorToJsonRpc` — * `code` lands on `error.data.code`, so hosts can branch on the * classification without parsing prose. * * `message` is caller-facing and `detail` is operator-facing. NEITHER * is preserved on `NOT_FOUND`: the mapper substitutes a constant there * so a denied read and a genuine miss are byte-identical on the wire. * Put diagnostics for that case in the server's own logs. */ export declare const resourceReadErrorSchema: z.ZodObject<{ code: z.ZodEnum<{ NOT_FOUND: "NOT_FOUND"; BLUEPRINT_UNRESOLVABLE: "BLUEPRINT_UNRESOLVABLE"; NOT_SUPPORTED: "NOT_SUPPORTED"; NOT_MOUNTABLE: "NOT_MOUNTABLE"; }>; message: z.ZodString; detail: z.ZodOptional; }, z.core.$strip>; /** * Wire-output shape. `outcome` is the discriminant and the only * unconditionally required field; which of the others exist follows * from it, per the THREE OUTCOMES section below — that section is the * single summary of this shape, so do not restate it here. * The handler carries `shortCode`, `codeReady`, `handshakeId`, * `decision`, `contract`, `codeUrl`, `codeHash` * on its internal `RenderOutput` TS shape for telemetry / post-classify * tracing — zod strips them before structuredContent serialization. * * The iframe receives bootstrap credentials (`wsUrl`, `wsToken`, * `expiresAt`) via the single `ai.ggui/render` slice meta, not via this * response. There is no clickable `url` field — post-R5 the `/r/` * shortCode route was deleted (every host either resolves the * `_meta.ui.resourceUri` iframe or reads `{sessionId}` via * `render-resource/...`). Leaving a dead URL on the wire had the model * hallucinating links that resolve nowhere. * * THREE OUTCOMES (SPEC §7.1, ggui#786). Every result carries * {@link renderOutcomeSchema} on `outcome`, and the identity fields are * present IFF something was committed — which is why they are optional * at the schema level and pinned by the presence refinement below: * * - `rendered` — identity fields present; `resourceUri` present iff * mountable; no `error`, no `refusal`. * - `failed` — generation ran and produced nothing. Identity fields * present (the error GguiSession IS committed, so `sessionId` * remains a live handle into the session channel), `error` * present, `resourceUri` absent, no `_meta` on the result. The * handshake is consumed. * - `refused` — the deployment declined before doing any work. * Identity fields ABSENT, `refusal` present, no `error`, no * `nextStep`, no `_meta`. Nothing was committed and the handshake * is intact. The refused arm's whole envelope is * {@link refusedOutputSchema}. * * The root stays ONE object with a discriminant field rather than a * discriminated union: the MCP spec's `Tool.outputSchema` root MUST be * a JSON Schema of type `object`, and the SDK registers zod raw shapes. * TypeScript narrowing is via the guards at the bottom of this file * ({@link isRenderedOutput} / {@link isFailedRenderOutput} / * {@link isRefusedRenderOutput}), never a parallel union type. * * Post-Phase-B the `'compose'` action enum value is gone — there is no * stack of N renders to compose against. */ export declare const renderOutputSchema: z.ZodObject<{ outcome: z.ZodEnum<{ rendered: "rendered"; failed: "failed"; refused: "refused"; }>; sessionId: z.ZodOptional; resourceUri: z.ZodOptional; action: z.ZodOptional>; contractHash: z.ZodOptional; blueprintId: z.ZodOptional; variantKey: z.ZodOptional; cache: z.ZodOptional; cachedBlueprintId: z.ZodOptional; llmCallsAvoided: z.ZodNumber; kind: z.ZodOptional>; reason: z.ZodOptional; }, z.core.$strip>>; error: z.ZodOptional; message: z.ZodString; }, z.core.$strip>>; refusal: z.ZodOptional; balanceCentsAtCheck: z.ZodOptional; message: z.ZodString; fix: z.ZodString; retry: z.ZodEnum<{ never: "never"; "after-fix": "after-fix"; "next-period": "next-period"; later: "later"; }>; code: z.ZodEnum<{ unsupported_provider: "unsupported_provider"; insufficient_credit: "insufficient_credit"; hard_cap_exceeded: "hard_cap_exceeded"; model_not_allowed: "model_not_allowed"; managed_default_cap_exceeded: "managed_default_cap_exceeded"; app_policy_missing: "app_policy_missing"; billing_mode_anomaly: "billing_mode_anomaly"; issuer_rate_limited: "issuer_rate_limited"; app_rate_limited: "app_rate_limited"; app_deprovisioned: "app_deprovisioned"; billing_path_missing: "billing_path_missing"; }>; }, z.core.$strip>>; nextStep: z.ZodOptional; description: z.ZodString; example: z.ZodString; args: z.ZodObject<{ sessionId: z.ZodString; timeout: z.ZodNumber; }, z.core.$strip>; }, z.core.$strip>>; }, z.core.$strip>; /** * `ggui_update` — refresh the rendered UI with new state. * * Discriminated on `kind`: * * - `kind: 'replace'` + `props` — full props replacement. The new * map IS the new state. Use when most props change OR when you * want deterministic state restoration (no merge ambiguity). * * - `kind: 'merge'` + `patch` — RFC 7396 JSON Merge Patch semantics. * Top-level keys merge shallow; nested objects merge recursively; * a `null` value DELETES the key; arrays fully replace (NOT element- * wise). Use when most props stay the same and the agent only * needs to send a small delta — common after a single domain-tool * mutation. RFC 7396 chosen because it has a published spec and * wide library support (GitHub API's merge semantics, strategic-merge-patch). * * Anti-patterns (the discriminated union rejects these structurally, * but they're a common author mistake when copy-pasting): * * - Do NOT send `props` on `kind: 'merge'` — use `patch`. * - Do NOT send `patch` on `kind: 'replace'` — use `props`. * * Both modes validate the FINAL props state (post-merge for `merge`) * against the render's `propsSpec` and reject on violation — * partial patches that would break required fields, type-mismatch * values, etc. all reject pre-persist. * * `sessionId` is globally unique; the server checks the app scope via * `ctx.appId`. */ export declare const updateInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{ sessionId: z.ZodString; kind: z.ZodLiteral<"replace">; props: z.ZodRecord; }, z.core.$strict>, z.ZodObject<{ sessionId: z.ZodString; kind: z.ZodLiteral<"merge">; patch: z.ZodRecord; }, z.core.$strict>], "kind">; /** * `ggui_amend` wire input (#483) — same replace/merge mutation * grammar as `ggui_update`, different mount identity: amend targets * the ALREADY-MOUNTED card. No new card, no history entry, the * history number does not advance. Git reading: `ggui_update` = * commit; `ggui_amend` = commit --amend. */ export declare const amendInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{ sessionId: z.ZodString; kind: z.ZodLiteral<"replace">; props: z.ZodRecord; }, z.core.$strict>, z.ZodObject<{ sessionId: z.ZodString; kind: z.ZodLiteral<"merge">; patch: z.ZodRecord; }, z.core.$strict>], "kind">; /** * Wire-output shape — minimal acknowledgement. This schema IS the * handler's declared output: `ggui_update` registers `.shape` and its * return type is `GguiUpdateOutput` (`z.infer` of this schema), so * there is no second declaration to keep in step (ggui#798). * * Every REAL update (`updated: true`) mints a new history record and * its result carries the `ai.ggui/render` slice as a FULL bootable * mount package (#483 — hosts mint a per-result view for the new * card); a no-op (`updated: false`) carries NO result `_meta`. * Already-mounted frames are not repainted by update — they freeze as * history when its higher-epoch `props_update` frame lands; the * in-place repaint over the live-channel ladder (WS / SSE / polling / * bridge-pull) is `ggui_amend`'s job. * * NO refusal arm (ggui#786): the pre-generation refusal envelope rides * `ggui_render` only. There is no pre-state POLICY gate on the * mutation tools today — nothing on this path can decline a call for * deployment-policy reasons (a contract error still rejects a * malformed mutation before any store read; that is a parse result, * not a refusal) — and `handshake: 'intact'` would assert something * meaningless on a tool that consumes no handshake. The arm lands with its first * emitter (ggui#798), not as a mechanical port of the render one. */ export declare const updateOutputSchema: z.ZodObject<{ sessionId: z.ZodString; updated: z.ZodBoolean; resourceUri: z.ZodString; epoch: z.ZodNumber; warning: z.ZodOptional; propsSchemaHash: z.ZodOptional; propsSchemaProfile: z.ZodOptional; }, z.core.$strip>; /** * `ggui_amend` wire output (#483) — acknowledgement only. `resourceUri` * is the BARE live-head URI (amend targets the mounted card; it never * mints a record, so there is no pinned URI to return and no epoch * field — the history number is untouched by construction). The * mounted card receives the new props over the live channels. * * As with {@link updateOutputSchema}, this schema IS the handler's * declared output — `ggui_amend` registers `.shape` and returns * `GguiAmendOutput` (ggui#798). */ export declare const amendOutputSchema: z.ZodObject<{ sessionId: z.ZodString; updated: z.ZodBoolean; resourceUri: z.ZodString; warning: z.ZodOptional; propsSchemaHash: z.ZodOptional; propsSchemaProfile: z.ZodOptional; }, z.core.$strip>; /** * `ggui_runtime_declare_tool_catalog` — the host runtime declares its * per-app canonical tool-identity catalog (one row per app). * * The map is `bare tool name → the canonical serverInfo` that the tool's * MCP server announced in its `initialize` reply. ggui folds this into * the handshake step (`canonicalizeToolIdentity`) so a reused blueprint's * `agentCapabilities.tools[*].serverInfo` is rewritten to the canonical * value regardless of whether the inbound contract authored a config-key * name, fabricated one, or omitted it. That makes blueprint reuse * identity-stable across runtimes. * * Keyed by the BARE tool name — the same key the canonicalization step * matches on. `version` is OPTIONAL: it rides along as metadata; tool * identity is `(name)` matched by bare name, never `(name, version)`. * * `appId` is NOT on the input — the handler reads it off `ctx.appId` * resolved by the upstream auth adapter, so a declaration can only ever * write its own app's row. The output echoes the resolved `appId` so the * caller can confirm which app row it wrote. * * REPLACE semantics: each declaration overwrites the app's prior catalog * wholesale (the host re-declares its full current toolset on connect). */ export declare const declareToolCatalogInputSchema: z.ZodObject<{ toolCatalog: z.ZodRecord; }, z.core.$strict>>; }, z.core.$strict>; export declare const declareToolCatalogOutputSchema: z.ZodObject<{ saved: z.ZodBoolean; appId: z.ZodString; }, z.core.$strict>; /** * Server-side page cap for `ggui_runtime_pull`. A `limit` above this is * CLAMPED (not rejected) — the tool mirrors the cursor-walk posture of * the `/events` HTTP route, where a too-eager page size is a tuning * knob, not a caller bug. Shared so the pulling client and the serving * handler agree on the effective page ceiling from one constant. */ export declare const RUNTIME_PULL_MAX_LIMIT = 100; /** * Server-side ceiling on `ggui_runtime_pull`'s `wait` hold, in seconds — * the LONGEST hold the server will honour, never a promise that every * host tolerates it (ggui#1030). * * The contract has two sides. SERVER: honour `wait` up to this ceiling, * return the empty page as a normal result when the hold elapses, and * end the hold when the caller's transport closes. CALLER (the pulling * runtime): choose a `wait` that does not exceed the `tools/call` * timeout of the host relaying the call, minus a margin; a host that * relays a pull clamps the forwarded `wait` to its own timeout minus one * second. A host timeout below the hold is a caller-side failure — the * server's `success` after the socket closed is not a server fault, and * a caller that keeps pulling through such failures must demote to * sparse un-held pulls exactly as it does after consecutive empties. */ export declare const RUNTIME_PULL_MAX_WAIT_SECONDS = 20; /** * One `GguiSessionEvent` ledger row on the `ggui_runtime_pull` wire — * the zod mirror of the canonical `GguiSessionEvent` interface in * `types/ggui-session-event.ts` (which stays the type-level source of * truth; `mcp.test.ts` pins the two together in both directions). */ export declare const gguiSessionEventSchema: z.ZodObject<{ seq: z.ZodNumber; type: z.ZodString; timestamp: z.ZodString; data: z.ZodUnknown; }, z.core.$strip>; /** * `ggui_runtime_pull` input — the terminal bridge-pull rung of the * live-channel failover ladder (WS → SSE → HTTP polling → bridge-pull). * * Two named parties: * * - **Puller** — the `@ggui-ai/iframe-runtime` bridge rung. In a * CSP-jailed MCP Apps host the iframe can reach no network origin * at all, so it pulls the event ledger by issuing `tools/call` * postMessages that the host's MCP client relays (the tool * registers `_meta.ui.visibility: ['app']` per MCP Apps spec §401 * — hosts MUST route view-issued calls to it and MUST reject * view-issued calls to tools without it). * - **Server** — the MCP server hosting the render. It serves the * SAME `GguiSessionEvent` ledger `GET * /api/sessions/:sessionId/events` serves, through the same * `listEventsSince` read, and MUST answer with the same shapes * (see {@link runtimePullOutputSchema}) so one client parse core * handles both carriers. * * Divergences from the HTTP route, both deliberate: `sinceSequence` is * OPTIONAL here (the bridge rung owns its cursor and seeds from 0; the * route requires it because a bare browser GET has no cursor owner), * and `limit` is clamped to {@link RUNTIME_PULL_MAX_LIMIT} instead of * rejecting above it. Cross-app access and unknown sessionIds * surface uniformly as the `session_not_found` error — existence of * other apps' renders is never leaked. */ export declare const runtimePullInputShape: { readonly sessionId: z.ZodString; readonly sinceSequence: z.ZodOptional; readonly limit: z.ZodOptional; readonly wait: z.ZodOptional; }; export declare const runtimePullInputSchema: z.ZodObject<{ sessionId: z.ZodString; sinceSequence: z.ZodOptional; limit: z.ZodOptional; wait: z.ZodOptional; }, z.core.$strip>; /** * Normal-page arm — EXACT `EventsResponse` parity with * `GET /api/sessions/:sessionId/events` (same keys, same semantics): * `events` strictly ascending by seq, `lastSequence` = the render's * current high-water mark (NOT the page's last seq — advances the * cursor on empty pages), `hasMore` = the page was truncated by * `limit`. */ export declare const runtimePullEventsPageSchema: z.ZodObject<{ events: z.ZodArray>; lastSequence: z.ZodNumber; hasMore: z.ZodBoolean; }, z.core.$strip>; /** * Replay-horizon arm — parity with the route's 410 body, but on this * carrier it is a NORMAL result arm, not an error: the bridge rung is * terminal and treats it as a re-sync instruction. Returned when the * cursor fell out of the replayable window on EITHER side * (`sinceSequence` above the server's `lastSequence` — a cursor from a * different deployment/reset render — or below the retention horizon). * Client recovery: re-mount state from a fresh snapshot and reset the * cursor to `currentSequence`. */ export declare const runtimePullHorizonSchema: z.ZodObject<{ reason: z.ZodLiteral<"REPLAY_HORIZON_PASSED">; currentSequence: z.ZodNumber; }, z.core.$strip>; /** * `ggui_runtime_pull` output — the canonical strict wire contract, a * two-arm union: {@link runtimePullEventsPageSchema} (normal page) | * {@link runtimePullHorizonSchema} (cursor out of window). The handler * registers a flat raw shape (MCP tool registration takes a * `ZodRawShape`, which cannot express a top-level union) and its * alignment test pins that shape to this union — same posture as * `updateInputSchema`. */ export declare const runtimePullOutputSchema: z.ZodUnion>; lastSequence: z.ZodNumber; hasMore: z.ZodBoolean; }, z.core.$strip>, z.ZodObject<{ reason: z.ZodLiteral<"REPLAY_HORIZON_PASSED">; currentSequence: z.ZodNumber; }, z.core.$strip>]>; /** * `ggui_runtime_telemetry` input — the iframe runtime's transport * self-report (`_meta.ui.visibility: ['app']`, view-callable only). * * Contract (both parties named): the IFRAME RUNTIME batches short * `{at, kind, detail?}` events describing its delivery-ladder journey * (boot-path decision, per-rung status transitions and failures — * `channel_failover_swap`, `channel_polling_budget_exhausted`, … — * and outbound doorbell rings) and flushes them over the host's * `tools/call` postMessage bridge; the SERVER logs one structured * line per batch for operator forensics and stores NOTHING. Sandboxed * hosts (claude.ai's `claudemcpcontent.com` frames) expose no * readable console and no network — this tool is the ONLY way the * ladder's behavior on such hosts reaches an operator. `sessionId` is * client-claimed (log-tagged, never trusted for reads); events are * bounded (≤ {@link RUNTIME_TELEMETRY_MAX_EVENTS} per batch, `kind` ≤ * 64 chars, `detail` ≤ 512) so a hostile view cannot use the channel * for bulk exfiltration or log flooding. */ export declare const runtimeTelemetryInputShape: { readonly sessionId: z.ZodString; readonly events: z.ZodArray; }, z.core.$strip>>; }; export declare const runtimeTelemetryInputSchema: z.ZodObject<{ sessionId: z.ZodString; events: z.ZodArray; }, z.core.$strip>>; }, z.core.$strip>; /** `ggui_runtime_telemetry` output — bare acknowledgement. */ export declare const runtimeTelemetryOutputSchema: z.ZodObject<{ ok: z.ZodLiteral; }, z.core.$strip>; type RenderOutputValue = z.infer; /** Identity fields a committed render reports. */ type CommittedRenderIdentity = Required>; /** A render that produced an interface — identity fields present. */ export declare function isRenderedOutput(output: RenderOutputValue): output is RenderOutputValue & { outcome: 'rendered'; } & CommittedRenderIdentity; /** * A generation that RAN and produced nothing. The error session is * committed, so `sessionId` is a live handle and `error` classifies it. */ export declare function isFailedRenderOutput(output: RenderOutputValue): output is RenderOutputValue & { outcome: 'failed'; error: z.infer; } & CommittedRenderIdentity; /** * A PRE-GENERATION refusal — nothing read and nothing committed, so * every identity field is absent and `refusal` carries the state. (Not * "nothing parsed": the SDK has already checked the call against the * tool's declared `inputSchema` by the time a gate can refuse it.) */ export declare function isRefusedRenderOutput(output: RenderOutputValue): output is { outcome: 'refused'; refusal: PreGenerationRefusal; }; /** Display modes an MCP Apps host can render a view in (ext-apps vocabulary). */ export declare const mcpUiDisplayModeSchema: z.ZodEnum<{ inline: "inline"; fullscreen: "fullscreen"; pip: "pip"; }>; /** * The host-context projection the iframe-runtime observes and `ggui_consume` * echoes (`client.hostContext`). Every field optional: a host that never * reports one leaves it absent — absent ⇒ the documented default. */ export declare const hostContextProjectionSchema: z.ZodObject<{ availableDisplayModes: z.ZodOptional>>; currentDisplayMode: z.ZodOptional>; containerDimensions: z.ZodOptional; maxWidth: z.ZodOptional; height: z.ZodOptional; maxHeight: z.ZodOptional; }, z.core.$strip>>; platform: z.ZodOptional>; deviceCapabilities: z.ZodOptional; hover: z.ZodOptional; }, z.core.$strip>>; locale: z.ZodOptional; timeZone: z.ZodOptional; }, z.core.$strip>; /** `ggui_consume`'s `client` slice — what the runtime observed about its host. */ export declare const clientObservationsSchema: z.ZodObject<{ hostContext: z.ZodOptional>>; currentDisplayMode: z.ZodOptional>; containerDimensions: z.ZodOptional; maxWidth: z.ZodOptional; height: z.ZodOptional; maxHeight: z.ZodOptional; }, z.core.$strip>>; platform: z.ZodOptional>; deviceCapabilities: z.ZodOptional; hover: z.ZodOptional; }, z.core.$strip>>; locale: z.ZodOptional; timeZone: z.ZodOptional; }, z.core.$strip>>; }, z.core.$strip>; /** One row of `ggui_list_sessions` — eight closed keys; nothing passes through. */ export declare const gguiSessionSummaryWireSchema: z.ZodObject<{ sessionId: z.ZodString; hostName: z.ZodOptional; hostSessionId: z.ZodOptional; createdAt: z.ZodString; lastActivityAt: z.ZodString; status: z.ZodString; wsToken: z.ZodOptional; wsTokenExpiresAt: z.ZodOptional; }, z.core.$strip>; /** * The two states a GguiSession is in on the wire — the pair the consume * loop exits on (`expired`). Owned here (ggui#817 part C2); the type is * derived, never a second list. */ export declare const gguiSessionStatusSchema: z.ZodEnum<{ active: "active"; expired: "expired"; }>; /** * One drained row of `ggui_consume` — a user action that reached the * pipe (ggui#817 part C2). Closed on the wire: an unknown key is * stripped at the transport, a missing key refuses the row at the store * boundary (`pendingEventSchema`, ggui#839), so a malformed pipe entry * never ships to an agent typed as a good one. */ export declare const consumeEventEntrySchema: z.ZodObject<{ type: z.ZodLiteral<"action">; sessionId: z.ZodString; intent: z.ZodString; actionData: z.ZodNullable>>; uiContext: z.ZodType>; actionId: z.ZodString; firedAt: z.ZodString; }, z.core.$strip>; /** * One stored row of the consume pipe — what a producer appends and * `consumeAndClear` drains, the same shape on every store (ggui#839; a * store-boundary contract, never wire — `ggui_consume` returns the * entries, never the wrapper). `id` is the drain_ack key and the * idempotency key per `(sessionId, id)`; `envelope` is the * {@link consumeEventEntrySchema} entry, always the object (every writer * passes one; a store that serializes the row serializes the whole row); * `createdAt` is when the row was appended — a string, never `.datetime()`: * the relay copies the client's `firedAt`, which the ingress accepts as a * diagnostic. `PendingEventConsumer` adapters validate every row through * this schema on append and, when rows come back from a serialization, on * drain — a malformed row never reaches an agent typed as a good entry. */ export declare const pendingEventSchema: z.ZodObject<{ id: z.ZodString; envelope: z.ZodObject<{ type: z.ZodLiteral<"action">; sessionId: z.ZodString; intent: z.ZodString; actionData: z.ZodNullable>>; uiContext: z.ZodType>; actionId: z.ZodString; firedAt: z.ZodString; }, z.core.$strip>; createdAt: z.ZodString; }, z.core.$strip>; /** * `ggui_consume`'s output — the drained rows, the session's state, and the * client's observations when the host sent any (ggui#817 part C2). The * handler registers `.shape`; `tools/list` therefore advertises the entry * vocabulary and the status enum instead of a free-form record and a free * string. */ export declare const gguiConsumeOutputSchema: z.ZodObject<{ events: z.ZodArray; sessionId: z.ZodString; intent: z.ZodString; actionData: z.ZodNullable>>; uiContext: z.ZodType>; actionId: z.ZodString; firedAt: z.ZodString; }, z.core.$strip>>; status: z.ZodEnum<{ active: "active"; expired: "expired"; }>; client: z.ZodOptional>>; currentDisplayMode: z.ZodOptional>; containerDimensions: z.ZodOptional; maxWidth: z.ZodOptional; height: z.ZodOptional; maxHeight: z.ZodOptional; }, z.core.$strip>>; platform: z.ZodOptional>; deviceCapabilities: z.ZodOptional; hover: z.ZodOptional; }, z.core.$strip>>; locale: z.ZodOptional; timeZone: z.ZodOptional; }, z.core.$strip>>; }, z.core.$strip>>; }, z.core.$strip>; /** `ggui_list_sessions`' output — the closed summary rows (ggui#817 part C2). */ export declare const gguiListSessionsOutputSchema: z.ZodObject<{ sessions: z.ZodArray; hostSessionId: z.ZodOptional; createdAt: z.ZodString; lastActivityAt: z.ZodString; status: z.ZodString; wsToken: z.ZodOptional; wsTokenExpiresAt: z.ZodOptional; }, z.core.$strip>>; }, z.core.$strip>; /** * `ggui_emit`'s output (ggui#817 part C2): `accepted` at the boundary, and * `seq` when the server keeps a stream buffer — seq-aware implementations * stamp and return it so replay cursors can be built from the ack. */ export declare const gguiEmitOutputSchema: z.ZodObject<{ accepted: z.ZodBoolean; seq: z.ZodOptional; }, z.core.$strip>; /** * `ggui_get_session`'s wire: the store row's six base fields plus the mount * variant — for EVERY session. An MCP-Apps mount is locator-only on the * render object, but its store row carries the base fields, so the * projection reads them from the row and the wire never fails on that * variant. The locator itself is not on this wire (MCP-Apps resources have * their own paths). * `contextSnapshot` rides when a component (`render`) mount's row has one — * never on an mcpApps mount. */ export declare const gguiGetSessionOutputSchema: z.ZodObject<{ variant: z.ZodEnum<{ render: "render"; mcpApps: "mcpApps"; }>; id: z.ZodString; appId: z.ZodString; eventSequence: z.ZodNumber; createdAt: z.ZodNumber; lastActivityAt: z.ZodNumber; expiresAt: z.ZodNumber; contextSnapshot: z.ZodOptional>>; }, z.core.$strip>; /** The three sequential gates of `ggui_protocol_validate_blueprint`. */ export declare const blueprintValidationTierSchema: z.ZodEnum<{ compile: "compile"; selfCheck: "selfCheck"; runtime: "runtime"; }>; export declare const blueprintValidationIssueSchema: z.ZodObject<{ tier: z.ZodEnum<{ compile: "compile"; selfCheck: "selfCheck"; runtime: "runtime"; }>; code: z.ZodString; message: z.ZodString; fix: z.ZodOptional; }, z.core.$strip>; /** `ggui_protocol_validate_blueprint`'s result envelope: `failedAt` names the tier that stopped, or null. */ export declare const blueprintValidationResultSchema: z.ZodObject<{ valid: z.ZodBoolean; failedAt: z.ZodNullable>; errors: z.ZodArray; code: z.ZodString; message: z.ZodString; fix: z.ZodOptional; }, z.core.$strip>>; warnings: z.ZodArray; code: z.ZodString; message: z.ZodString; fix: z.ZodOptional; }, z.core.$strip>>; }, z.core.$strip>; /** A provider row — what `ggui_list_featured_blueprints` returns per blueprint. */ export declare const blueprintEntryWireSchema: z.ZodObject<{ id: z.ZodString; name: z.ZodString; description: z.ZodOptional; source: z.ZodType>; updatedAt: z.ZodString; tags: z.ZodOptional>; }, z.core.$strip>; export declare const gguiListFeaturedBlueprintsOutputSchema: z.ZodObject<{ blueprints: z.ZodArray; source: z.ZodType>; updatedAt: z.ZodString; tags: z.ZodOptional>; }, z.core.$strip>>; total: z.ZodNumber; }, z.core.$strip>; /** One `ggui_search_blueprints` hit — a scored row plus the registry-only keys. */ export declare const gguiSearchBlueprintsResultSchema: z.ZodObject<{ id: z.ZodString; name: z.ZodString; description: z.ZodString; category: z.ZodString; props: z.ZodArray>; callbacks: z.ZodArray; featured: z.ZodBoolean; relevance: z.ZodLiteral<"match">; score: z.ZodNumber; origin: z.ZodOptional>; artifactId: z.ZodOptional; version: z.ZodOptional; mcpTools: z.ZodOptional; tool: z.ZodString; }, z.core.$strip>>>; scopeVerification: z.ZodOptional>; }, z.core.$strip>; export declare const gguiSearchBlueprintsOutputSchema: z.ZodObject<{ results: z.ZodArray>; callbacks: z.ZodArray; featured: z.ZodBoolean; relevance: z.ZodLiteral<"match">; score: z.ZodNumber; origin: z.ZodOptional>; artifactId: z.ZodOptional; version: z.ZodOptional; mcpTools: z.ZodOptional; tool: z.ZodString; }, z.core.$strip>>>; scopeVerification: z.ZodOptional>; }, z.core.$strip>>; total: z.ZodNumber; query: z.ZodString; degradedSources: z.ZodOptional; reason: z.ZodEnum<{ timeout: "timeout"; unreachable: "unreachable"; invalid_response: "invalid_response"; }>; }, z.core.$strip>>>; }, z.core.$strip>; export {}; //# sourceMappingURL=mcp.d.ts.map