apps 0.0.1-beta.1 → 0.0.1-beta.100

package/types/apps/src/contracts/protocols/1.d.ts

@@ -0,0 +1,2241 @@
+/**
+ * Host protocol 1: the messages that cross between a host and a retained app bundle.
+ *
+ * This protocol is released and frozen. Retained builds and published `apps` versions speak it,
+ * and every later host must keep running and rebuilding them unchanged. `bun run check` compares
+ * `protocol1` with `packages/apps/protocols/1.json` and fails on any difference. The module imports
+ * only `effect` and the frozen OAuth sibling `./oauth.ts`, so no change elsewhere in the repository
+ * can alter it. Do not edit it to change the wire format: define the next protocol instead and
+ * give the host an adapter for this one. See notes/apps-publishing.md.
+ */
+import { Schema } from "effect";
+import * as McpSchema from "effect/ai/McpSchema";
+/** JSON values carried by remote protocols such as MCP. */
+export declare const JsonValue: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+export type JsonValue = Schema.Json;
+/** A JSON object, distinct from an authored value schema. */
+export declare const JsonObject: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export type JsonObject = typeof JsonObject.Type;
+/** Stable saved account identity supplied by a host, unchanged across refreshes. */
+export declare const AccountId: Schema.brand<Schema.String, "acc">;
+/** Parsed saved account identity. */
+export type AccountId = typeof AccountId.Type;
+declare const CacheError_base: Schema.Class<CacheError, Schema.TaggedStruct<"CacheError", {
+    readonly reason: Schema.Literals<readonly ["unavailable", "storage", "invalid", "capacity", "timeout"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Expected cache failures never include keys, values or upstream exception text. */
+export declare class CacheError extends CacheError_base {
+}
+/** Stored values carry a version independent of their freshness clock. */
+export declare const CacheEntry: Schema.Struct<{
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly version: Schema.String;
+    readonly freshUntil: Schema.Finite;
+    readonly staleUntil: Schema.Finite;
+}>;
+/** Decoded cache value envelope. */
+export type CacheEntry = typeof CacheEntry.Type;
+/**
+ * Publication requires the lease acquired against the previously observed version.
+ * `acquire` reads one entry and claims its load in the same transaction, so a cache
+ * miss costs one round trip. `read` and `claim` remain for builds retained before it.
+ */
+export declare const CacheCommand: Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"read">;
+    readonly keys: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"acquire">;
+    readonly key: Schema.String;
+    /** Claim even a fresh entry, as an explicit refresh does. */
+    readonly refresh: Schema.Boolean;
+    /** Claim only while the entry still has this version. Absent accepts the current one. */
+    readonly version: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"claim">;
+    readonly key: Schema.String;
+    readonly version: Schema.NullOr<Schema.String>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"publish">;
+    readonly key: Schema.String;
+    readonly lease: Schema.String;
+    readonly entry: Schema.Struct<{
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly version: Schema.String;
+        readonly freshUntil: Schema.Finite;
+        readonly staleUntil: Schema.Finite;
+    }>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"release">;
+    readonly key: Schema.String;
+    readonly lease: Schema.String;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"renew">;
+    readonly key: Schema.String;
+    readonly lease: Schema.String;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"write">;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly entry: Schema.Struct<{
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly version: Schema.String;
+            readonly freshUntil: Schema.Finite;
+            readonly staleUntil: Schema.Finite;
+        }>;
+    }>>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"invalidate">;
+    readonly key: Schema.String;
+}>]>;
+/** Parsed host command; namespaces cannot be selected by app code. */
+export type CacheCommand = typeof CacheCommand.Type;
+/** Safe protocol envelope used at process boundaries. */
+export declare const CacheReply: Schema.Union<readonly [Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: typeof CacheError;
+}>]>;
+/** Names have Lakebed's identifier shape and are always bound SQL values, never raw SQL. */
+export declare const DataName: Schema.String;
+/** Stored fields and index terms use finite scalar values; absent optional fields are represented by null in transport. */
+export declare const Scalar: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>;
+export type Scalar = typeof Scalar.Type;
+export declare const Field: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["string", "number", "boolean", "id", "userId"]>;
+    readonly optional: Schema.optional<Schema.Boolean>;
+    readonly default: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+    readonly references: Schema.optional<Schema.String>;
+}>;
+export type Field = typeof Field.Type;
+export declare const Index: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly fields: Schema.NonEmptyArray<Schema.String>;
+}>;
+export declare const Table: Schema.Struct<{
+    readonly fields: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["string", "number", "boolean", "id", "userId"]>;
+        readonly optional: Schema.optional<Schema.Boolean>;
+        readonly default: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+        readonly references: Schema.optional<Schema.String>;
+    }>>;
+    readonly indexes: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly fields: Schema.NonEmptyArray<Schema.String>;
+    }>>;
+}>;
+export type Table = typeof Table.Type;
+export declare const DatabaseSchema: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly fields: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["string", "number", "boolean", "id", "userId"]>;
+        readonly optional: Schema.optional<Schema.Boolean>;
+        readonly default: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+        readonly references: Schema.optional<Schema.String>;
+    }>>;
+    readonly indexes: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly fields: Schema.NonEmptyArray<Schema.String>;
+    }>>;
+}>>;
+export type DatabaseSchema = typeof DatabaseSchema.Type;
+/** Longest agent guidance an API error's recovery carries. */
+export declare const maxApiErrorInstructionsLength = 4096;
+/** Bounded recovery a declared API error published for its caller: a short next step and agent guidance. */
+export declare const ApiErrorRecovery: Schema.Struct<{
+    readonly action: Schema.NonEmptyString;
+    readonly instructions: Schema.NonEmptyString;
+}>;
+/** Recovery copied from an error response body; extra keys are dropped on decode. */
+export type ApiErrorRecovery = typeof ApiErrorRecovery.Type;
+/** Longest message an API error response carries. */
+export declare const maxApiErrorMessageLength = 4096;
+/** Bounded public fields from a response matching its declared API error schema. */
+export declare const ApiErrorResponse: Schema.Struct<{
+    readonly code: Schema.NonEmptyString;
+    readonly status: Schema.Int;
+    readonly message: Schema.NonEmptyString;
+    readonly recovery: Schema.optionalKey<Schema.Struct<{
+        readonly action: Schema.NonEmptyString;
+        readonly instructions: Schema.NonEmptyString;
+    }>>;
+}>;
+/** Safe projection of a response matching a declared API error schema. */
+export type ApiErrorResponse = typeof ApiErrorResponse.Type;
+declare const OpenapiResponseError_base: Schema.Class<OpenapiResponseError, Schema.TaggedStruct<"OpenapiResponseError", {
+    readonly code: Schema.NonEmptyString;
+    readonly status: Schema.Int;
+    readonly message: Schema.NonEmptyString;
+    readonly recovery: Schema.optionalKey<Schema.Struct<{
+        readonly action: Schema.NonEmptyString;
+        readonly instructions: Schema.NonEmptyString;
+    }>>;
+}>, import("effect/Cause").YieldableError>;
+/** A validated OpenAPI failure with its declared message or static schema explanation. */
+export declare class OpenapiResponseError extends OpenapiResponseError_base {
+}
+/** Plain-data form request derived from the pinned MCP protocol schema. */
+export declare const FormElicitation: Schema.Struct<{
+    readonly mode: Schema.Literal<"form">;
+    readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
+        readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly type: Schema.tag<"object">;
+        readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof McpSchema.LegacyTitledEnum, Schema.Union<readonly [typeof McpSchema.UntitledSingleSelectEnum, typeof McpSchema.TitledSingleSelectEnum]>, Schema.Union<readonly [typeof McpSchema.UntitledMultiSelectEnum, typeof McpSchema.TitledMultiSelectEnum]>]>, typeof McpSchema.ElicitationString, typeof McpSchema.ElicitationNumber, typeof McpSchema.ElicitationBoolean]>>;
+        readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>>;
+    readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly message: Schema.String;
+}>;
+export type FormElicitation = typeof FormElicitation.Type;
+/** MCP accept/decline/cancel response, without imposing a client or transport on app code. */
+export declare const ElicitationResponse: Schema.Union<readonly [Schema.Struct<{
+    readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly action: Schema.Literal<"accept">;
+    readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+}>, Schema.Struct<{
+    readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly action: Schema.Literals<readonly ["cancel", "decline"]>;
+}>]>;
+export type ElicitationResponse = typeof ElicitationResponse.Type;
+declare const ElicitationFailed_base: Schema.Class<ElicitationFailed, Schema.TaggedStruct<"ElicitationFailed", {
+    readonly reason: Schema.Literals<readonly ["unavailable", "transaction", "invalid-request", "invalid-response", "transport", "expired", "forbidden"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A tool interaction could not be delivered or its request/response was invalid. No private payload is retained. */
+export declare class ElicitationFailed extends ElicitationFailed_base {
+}
+/** Safe reply for a runtime that crosses an RPC boundary. */
+export declare const ElicitationReply: Schema.Union<readonly [Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly response: Schema.Union<readonly [Schema.Struct<{
+        readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly action: Schema.Literal<"accept">;
+        readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly action: Schema.Literals<readonly ["cancel", "decline"]>;
+    }>]>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: typeof ElicitationFailed;
+}>]>;
+export type ElicitationReply = typeof ElicitationReply.Type;
+/** Invocation consent requests no additional fields; arguments are reviewed, never edited in the form. */
+export declare const ApprovalElicitation: Schema.Struct<{
+    readonly requestedSchema: Schema.Struct<{
+        readonly type: Schema.Literal<"object">;
+        readonly properties: Schema.$Record<Schema.String, Schema.Never>;
+    }>;
+    readonly mode: Schema.Literal<"form">;
+    readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly message: Schema.String;
+}>;
+export type ApprovalElicitation = typeof ApprovalElicitation.Type;
+/** Dispatch coalesces overdue ticks, so sub-minute intervals promise a cadence the runner cannot keep. */
+export declare const minimumIntervalMilliseconds = 60000;
+/** Calendar schedules use five cron fields and an explicit IANA time zone. */
+export declare const CalendarSchedule: Schema.Struct<{
+    readonly expression: Schema.NonEmptyString;
+    readonly timezone: Schema.NonEmptyString;
+}>;
+/** Validated timing crosses all runtime and persistence boundaries as data. */
+export declare const ScheduleTiming: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"interval">;
+    readonly milliseconds: Schema.Int;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"cron">;
+    readonly calendar: Schema.Struct<{
+        readonly expression: Schema.NonEmptyString;
+        readonly timezone: Schema.NonEmptyString;
+    }>;
+}>]>;
+export type ScheduleTiming = typeof ScheduleTiming.Type;
+/** A named trigger attached to the mutation it invokes, including schema-validated arguments. */
+export declare const OperationSchedule: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly timing: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"interval">;
+        readonly milliseconds: Schema.Int;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"cron">;
+        readonly calendar: Schema.Struct<{
+            readonly expression: Schema.NonEmptyString;
+            readonly timezone: Schema.NonEmptyString;
+        }>;
+    }>]>;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type OperationSchedule = typeof OperationSchedule.Type;
+/** Canonical resource path within one skill. */
+export declare const SkillFilePath: Schema.NonEmptyString;
+/** UTF-8 text resource. Reading a resource never executes it. */
+export declare const SkillFile: Schema.Struct<{
+    readonly path: Schema.NonEmptyString;
+    readonly content: Schema.String;
+}>;
+export type SkillFile = typeof SkillFile.Type;
+/** Agent Skills format constraints, not Executor execution or storage budgets. */
+export declare const skillFormatLimits: {
+    readonly nameCharacters: 64;
+    readonly descriptionCharacters: 1024;
+    readonly compatibilityCharacters: 500;
+};
+/** A lowercase alphanumeric skill directory name with single separating hyphens. */
+export declare const AppSkillName: Schema.NonEmptyString;
+/** Frontmatter is metadata only. In particular, allowed-tools never grants execution authority. */
+export declare const AppSkillMetadata: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly license: Schema.optionalKey<Schema.String>;
+    readonly compatibility: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+}>;
+export type AppSkillMetadata = typeof AppSkillMetadata.Type;
+/** Files use paths relative to this skill directory; reading one never executes its contents. */
+export declare const AppSkillSource: Schema.Struct<{
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly content: Schema.String;
+    }>>;
+    readonly name: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly license: Schema.optionalKey<Schema.String>;
+    readonly compatibility: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+}>;
+export type AppSkillSource = typeof AppSkillSource.Type;
+/** One evaluated catalog cannot contain ambiguous names. */
+export declare const AppSkills: Schema.$Array<Schema.Struct<{
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly content: Schema.String;
+    }>>;
+    readonly name: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly license: Schema.optionalKey<Schema.String>;
+    readonly compatibility: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+}>>;
+/** Advisory tool hints; neither the framework nor these declarations enforce access. */
+export declare const ToolAnnotations: Schema.Struct<{
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+    readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+    readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+    readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type ToolAnnotations = typeof ToolAnnotations.Type;
+/** Raw-byte ceiling shared by callback HTTP, app execution and the encoded host protocol. */
+export declare const WebhookTransportLimits: Schema.Struct<{
+    readonly maxBodyBytes: Schema.Int;
+}>;
+export type WebhookTransportLimits = typeof WebhookTransportLimits.Type;
+/** Requests and responses use the same existing transport bound. */
+export declare const defaultWebhookTransportLimits: {
+    readonly maxBodyBytes: number;
+};
+/** Bounded callback transport. Headers and base64 bytes preserve the provider signature input. */
+export declare const WebhookRequestData: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly body: Schema.String;
+}>;
+/** Each command runs with a fresh factory and the subscription's saved account selections. */
+export declare const WebhookCommand: Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"webhooks">;
+}>, Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-validate">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-complete">;
+}>, Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-register">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-unregister">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly request: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+        readonly headers: Schema.$Record<Schema.String, Schema.String>;
+        readonly body: Schema.String;
+    }>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-handle">;
+}>]>;
+/** Parsed framework command; contains private host inputs and must not be logged. */
+export type WebhookCommand = typeof WebhookCommand.Type;
+/** Run identity is opaque and shared by author and SDK interfaces. */
+export declare const WorkflowRunId: Schema.brand<Schema.NonEmptyString, "wfr">;
+export type WorkflowRunId = typeof WorkflowRunId.Type;
+/** Stable names identify declarations and replay steps. */
+export declare const WorkflowName: Schema.NonEmptyString;
+/** Convert portable duration syntax to milliseconds; invalid or overflowing values are rejected. */
+export declare const workflowDurationMillis: (value: number | string) => number | undefined;
+/** Numbers are milliseconds; strings use a quantity and full unit, such as "5 minutes". */
+export declare const WorkflowDuration: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+export type WorkflowDuration = typeof WorkflowDuration.Type;
+/** Author retry and timeout options are passed to the durable engine. */
+export declare const WorkflowStepOptions: Schema.Struct<{
+    readonly retries: Schema.optionalKey<Schema.Struct<{
+        readonly limit: Schema.Int;
+        readonly delay: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+        readonly backoff: Schema.optionalKey<Schema.Literals<readonly ["constant", "linear", "exponential"]>>;
+    }>>;
+    readonly timeout: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>>;
+}>;
+export type WorkflowStepOptions = typeof WorkflowStepOptions.Type;
+/** Step outputs must fit the engine's persisted JSON result limit. */
+export declare const WorkflowValue: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+/** Private replay metadata is attached by the host, never accepted in author input. */
+export declare const WorkflowReplay: Schema.Struct<{
+    readonly key: Schema.NonEmptyString;
+    readonly fingerprint: Schema.NonEmptyString;
+}>;
+export type WorkflowReplay = typeof WorkflowReplay.Type;
+/** Portable discovery, input validation and execution commands. */
+export declare const WorkflowCommand: Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"workflows">;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"workflow-validate">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"workflow-run">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>;
+export type WorkflowCommand = typeof WorkflowCommand.Type;
+/** Private invocation RPC protocol shared by the host and isolated app bundle. */
+export declare const WorkflowRpcCommand: Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"do">;
+    readonly name: Schema.NonEmptyString;
+    readonly options: Schema.Struct<{
+        readonly retries: Schema.optionalKey<Schema.Struct<{
+            readonly limit: Schema.Int;
+            readonly delay: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+            readonly backoff: Schema.optionalKey<Schema.Literals<readonly ["constant", "linear", "exponential"]>>;
+        }>>;
+        readonly timeout: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>>;
+    }>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"sleep">;
+    readonly name: Schema.NonEmptyString;
+    readonly duration: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"until">;
+    readonly name: Schema.NonEmptyString;
+    readonly timestamp: Schema.Finite;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"context">;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"invoke">;
+    readonly kind: Schema.Literals<readonly ["query", "mutation"]>;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly stepId: Schema.NonEmptyString;
+    readonly timeout: Schema.Finite;
+}>]>;
+/** Serializable requests do not contain an app ID; authority is captured in the supplied capability. */
+export declare const WorkflowControlCommand: Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"start">;
+    readonly workflow: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly key: Schema.optionalKey<Schema.NonEmptyString>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"get">;
+    readonly run: Schema.brand<Schema.NonEmptyString, "wfr">;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"list">;
+    readonly workflow: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly cursor: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "wfr">>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"terminate">;
+    readonly run: Schema.brand<Schema.NonEmptyString, "wfr">;
+}>]>;
+declare const ProviderError_base: Schema.Class<ProviderError, Schema.TaggedStruct<"ProviderError", {
+    readonly reason: Schema.Literals<readonly ["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]>;
+    readonly status: Schema.optional<Schema.Int>;
+    readonly accountId: Schema.optional<Schema.brand<Schema.String, "acc">>;
+}>, import("effect/Cause").YieldableError>;
+/** Protocol 1's provider failure, as released: a reason, an HTTP status and the account used. */
+export declare class ProviderError extends ProviderError_base {
+}
+declare const McpError_base: Schema.Class<McpError, Schema.TaggedStruct<"McpError", {
+    readonly phase: Schema.Literals<readonly ["connect", "discover", "call", "schema", "transport"]>;
+    readonly reason: Schema.Literals<readonly ["request", "unauthorized", "invalid_response", "timeout", "invalid_input"]>;
+    readonly status: Schema.optional<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/** Protocol 1's MCP failure, as released: a phase, a reason and an HTTP status. */
+export declare class McpError extends McpError_base {
+}
+declare const SkillLoadFailed_base: Schema.Class<SkillLoadFailed, Schema.TaggedStruct<"SkillLoadFailed", {
+    readonly reason: Schema.Literals<readonly ["source", "request", "rate_limited", "document", "limit", "changed", "encoding"]>;
+    readonly message: Schema.optional<Schema.String>;
+    readonly status: Schema.optional<Schema.Int>;
+}>, import("effect/Cause").YieldableError>;
+/** Protocols 1 to 8's skill loader failure, as released: a reason, a message and an HTTP status. */
+export declare class SkillLoadFailed extends SkillLoadFailed_base {
+}
+declare const WorkflowFailure_base: Schema.Class<WorkflowFailure, Schema.TaggedStruct<"WorkflowFailure", {
+    readonly reason: Schema.Literals<readonly ["unavailable", "not_found", "input", "output", "operation", "approval", "credentials", "terminated", "execution", "conflict", "engine"]>;
+    readonly retryable: Schema.Boolean;
+}>, import("effect/Cause").YieldableError>;
+/** Protocol 1's workflow failure: a reason code only, as released. */
+export declare class WorkflowFailure extends WorkflowFailure_base {
+}
+/** Protocol 1's workflow step reply, carrying its own failure. */
+export declare const WorkflowRpcResult: Schema.Union<readonly [Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: typeof WorkflowFailure;
+}>]>;
+/** Serializable auth methods shared with SDK hosts; protocol configuration has one schema. */
+export declare const DeclaredAuthMethod: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"secrets">;
+    readonly label: Schema.String;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly discover: Schema.String;
+    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+        readonly path: Schema.String;
+    }>>;
+    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly type: Schema.Literal<"oauth2">;
+}>, Schema.Struct<{
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly authorizationUrl: Schema.String;
+    readonly tokenUrl: Schema.String;
+    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+    readonly scopes: Schema.$Array<Schema.String>;
+    readonly issuer: Schema.optionalKey<Schema.String>;
+    readonly discover: Schema.optionalKey<Schema.Never>;
+    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+        readonly path: Schema.String;
+    }>>;
+    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly type: Schema.Literal<"oauth2">;
+}>, Schema.Struct<{
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly grant: Schema.Literal<"client_credentials">;
+    readonly discover: Schema.String;
+    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly type: Schema.Literal<"oauth2">;
+}>, Schema.Struct<{
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+    readonly discover: Schema.optionalKey<Schema.Never>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly grant: Schema.Literal<"client_credentials">;
+    readonly tokenUrl: Schema.String;
+    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+    readonly scopes: Schema.$Array<Schema.String>;
+    readonly type: Schema.Literal<"oauth2">;
+}>]>;
+/** Serializable declaration of a provider's named authentication methods. */
+export declare const DeclaredProvider: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"secrets">;
+        readonly label: Schema.String;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly discover: Schema.String;
+        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+            readonly path: Schema.String;
+        }>>;
+        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly authorizationUrl: Schema.String;
+        readonly tokenUrl: Schema.String;
+        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Array<Schema.String>;
+        readonly issuer: Schema.optionalKey<Schema.String>;
+        readonly discover: Schema.optionalKey<Schema.Never>;
+        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+            readonly path: Schema.String;
+        }>>;
+        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly grant: Schema.Literal<"client_credentials">;
+        readonly discover: Schema.String;
+        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+        readonly discover: Schema.optionalKey<Schema.Never>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly grant: Schema.Literal<"client_credentials">;
+        readonly tokenUrl: Schema.String;
+        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Array<Schema.String>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>]>>;
+}>;
+/** Credential-free provider declaration; content matching remains host policy. */
+export type DeclaredProvider = typeof DeclaredProvider.Type;
+/** Account slots available without binding accounts or evaluating the app factory. */
+export declare const DeclaredRequirements: Schema.Struct<{
+    /** Protocol support of this retained framework build, not an author-declared requirement. */
+    readonly capabilities: Schema.optionalKey<Schema.Struct<{
+        readonly skills: Schema.Literal<true>;
+        /** Accepts inspect detail and tools. Earlier builds reject both as excess fields. */
+        readonly toolIndex: Schema.optionalKey<Schema.Literal<true>>;
+        /** Accepts skills sources and reports whether the catalog includes a live loader. */
+        readonly skillSources: Schema.optionalKey<Schema.Literal<true>>;
+        /** Accepts scheduled inspection. Earlier builds reject it as an excess field. */
+        readonly scheduledTools: Schema.optionalKey<Schema.Literal<true>>;
+    }>>;
+    readonly database: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly fields: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["string", "number", "boolean", "id", "userId"]>;
+            readonly optional: Schema.optional<Schema.Boolean>;
+            readonly default: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+            readonly references: Schema.optional<Schema.String>;
+        }>>;
+        readonly indexes: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly fields: Schema.NonEmptyArray<Schema.String>;
+        }>>;
+    }>>>;
+    readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Struct<{
+        readonly definition: Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"secrets">;
+                readonly label: Schema.String;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly discover: Schema.String;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly authorizationUrl: Schema.String;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly issuer: Schema.optionalKey<Schema.String>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly discover: Schema.String;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>]>>;
+        }>;
+        readonly cardinality: Schema.Literals<readonly ["one", "many"]>;
+    }>>;
+}>;
+/** Parsed declared account requirements. */
+export type DeclaredRequirements = typeof DeclaredRequirements.Type;
+/** Host-resolved credentials for one stable saved account. Never a request DTO. */
+export declare const ResolvedAccount: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "acc">;
+    readonly provider: Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"secrets">;
+            readonly label: Schema.String;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly discover: Schema.String;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly authorizationUrl: Schema.String;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly issuer: Schema.optionalKey<Schema.String>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly discover: Schema.String;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>]>>;
+    }>;
+    readonly method: Schema.NonEmptyString;
+    /**
+     * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+     * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+     */
+    readonly generation: Schema.optionalKey<Schema.Int>;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+/** Parsed host account binding. */
+export type ResolvedAccount = typeof ResolvedAccount.Type;
+/** Full saved selection resolved by the trusted caller; [] differs from a missing slot. */
+export declare const ResolvedAccounts: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "acc">;
+    readonly provider: Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"secrets">;
+            readonly label: Schema.String;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly discover: Schema.String;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly authorizationUrl: Schema.String;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly issuer: Schema.optionalKey<Schema.String>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly discover: Schema.String;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>]>>;
+    }>;
+    readonly method: Schema.NonEmptyString;
+    /**
+     * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+     * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+     */
+    readonly generation: Schema.optionalKey<Schema.Int>;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "acc">;
+    readonly provider: Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"secrets">;
+            readonly label: Schema.String;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly discover: Schema.String;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly authorizationUrl: Schema.String;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly issuer: Schema.optionalKey<Schema.String>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly discover: Schema.String;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>]>>;
+    }>;
+    readonly method: Schema.NonEmptyString;
+    /**
+     * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+     * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+     */
+    readonly generation: Schema.optionalKey<Schema.Int>;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>>]>>;
+/** Parsed host selections, kept redacted until native account binding. */
+export type ResolvedAccounts = typeof ResolvedAccounts.Type;
+/** Trusted approval for one decoded call. Never accepted in public command JSON. */
+export declare const TrustedToolApproval: Schema.Struct<{
+    readonly tool: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type TrustedToolApproval = typeof TrustedToolApproval.Type;
+/** Absolute Unix time in milliseconds; remote hosts enforce it inside the operation transaction. */
+export declare const InvocationDeadline: Schema.Finite;
+/** Serializable live tool metadata; executable callbacks never cross this boundary. */
+export declare const HostedTool: Schema.Struct<{
+    readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly timing: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"interval">;
+            readonly milliseconds: Schema.Int;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"cron">;
+            readonly calendar: Schema.Struct<{
+                readonly expression: Schema.NonEmptyString;
+                readonly timezone: Schema.NonEmptyString;
+            }>;
+        }>]>;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>>;
+    readonly name: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly inputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly outputSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly annotations: Schema.optionalKey<Schema.Struct<{
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+        readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+        readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+        readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly _meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+/** Parsed live tool description. */
+export type HostedTool = typeof HostedTool.Type;
+/** Catalog entry without schemas. Browsing lists these and reads one full tool on selection. */
+export declare const HostedToolSummary: Schema.Struct<{
+    readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly timing: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"interval">;
+            readonly milliseconds: Schema.Int;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"cron">;
+            readonly calendar: Schema.Struct<{
+                readonly expression: Schema.NonEmptyString;
+                readonly timezone: Schema.NonEmptyString;
+            }>;
+        }>]>;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>>;
+    readonly name: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly annotations: Schema.optionalKey<Schema.Struct<{
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+        readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+        readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+        readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+}>;
+export type HostedToolSummary = typeof HostedToolSummary.Type;
+/**
+ * A skill catalog and whether any of it came from `dynamicSkills`. Without a live loader the
+ * catalog is determined by the build and its evaluation inputs; with one it reflects a publisher.
+ */
+export declare const SkillSources: Schema.Struct<{
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.NonEmptyString;
+            readonly content: Schema.String;
+        }>>;
+        readonly name: Schema.NonEmptyString;
+        readonly description: Schema.String;
+        readonly license: Schema.optionalKey<Schema.String>;
+        readonly compatibility: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly dynamic: Schema.Boolean;
+}>;
+export type SkillSources = typeof SkillSources.Type;
+/** Either response shape; `dynamic` is unknown for builds that predate skillSources. */
+export declare const SkillCatalogResponse: Schema.Union<readonly [Schema.Struct<{
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.NonEmptyString;
+            readonly content: Schema.String;
+        }>>;
+        readonly name: Schema.NonEmptyString;
+        readonly description: Schema.String;
+        readonly license: Schema.optionalKey<Schema.String>;
+        readonly compatibility: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly dynamic: Schema.Boolean;
+}>, Schema.$Array<Schema.Struct<{
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly content: Schema.String;
+    }>>;
+    readonly name: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly license: Schema.optionalKey<Schema.String>;
+    readonly compatibility: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+}>>]>;
+/** Framework-owned dispatch, independent of app-authored HTTP routing. */
+export declare const HostRequest: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"workflows">;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"workflow-validate">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"workflow-run">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>, Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"webhooks">;
+}>, Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-validate">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-complete">;
+}>, Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-register">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-unregister">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly request: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+        readonly headers: Schema.$Record<Schema.String, Schema.String>;
+        readonly body: Schema.String;
+    }>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-handle">;
+}>]>, Schema.Struct<{
+    readonly operation: Schema.Literal<"requirements">;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"inspect">;
+    /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+    readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+    /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+    readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    /**
+     * Describe only declared operations that have schedules, without dynamic tool discovery.
+     * Only builds that declare the scheduledTools capability accept this.
+     */
+    readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"skills">;
+    /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+    readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"query">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"mutate">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"call">;
+    readonly tool: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>;
+/** Parsed portable dispatch request. */
+export type HostRequest = typeof HostRequest.Type;
+declare const HostRequestInvalid_base: Schema.Class<HostRequestInvalid, Schema.TaggedStruct<"HostRequestInvalid", {}>, import("effect/Cause").YieldableError>;
+/** The dispatch request did not match the protocol. */
+export declare class HostRequestInvalid extends HostRequestInvalid_base {
+}
+declare const HostAccountsInvalid_base: Schema.Class<HostAccountsInvalid, Schema.TaggedStruct<"HostAccountsInvalid", {}>, import("effect/Cause").YieldableError>;
+/** Host-supplied accounts did not satisfy the declared slots or native method schemas. */
+export declare class HostAccountsInvalid extends HostAccountsInvalid_base {
+}
+declare const HostDeclarationInvalid_base: Schema.Class<HostDeclarationInvalid, Schema.TaggedStruct<"HostDeclarationInvalid", {}>, import("effect/Cause").YieldableError>;
+/** The module or declared capability shape could not be hosted. */
+export declare class HostDeclarationInvalid extends HostDeclarationInvalid_base {
+}
+declare const HostEvaluationFailed_base: Schema.Class<HostEvaluationFailed, Schema.TaggedStruct<"HostEvaluationFailed", {}>, import("effect/Cause").YieldableError>;
+/** Fresh app evaluation failed before calling a tool. */
+export declare class HostEvaluationFailed extends HostEvaluationFailed_base {
+}
+declare const HostOperationNotFound_base: Schema.Class<HostOperationNotFound, Schema.TaggedStruct<"HostOperationNotFound", {}>, import("effect/Cause").YieldableError>;
+/** No query or mutation matched the requested name. */
+export declare class HostOperationNotFound extends HostOperationNotFound_base {
+}
+declare const HostOperationFailed_base: Schema.Class<HostOperationFailed, Schema.TaggedStruct<"HostOperationFailed", {}>, import("effect/Cause").YieldableError>;
+/** An app operation failed. Raw author failures remain private. */
+export declare class HostOperationFailed extends HostOperationFailed_base {
+}
+declare const HostToolNotFound_base: Schema.Class<HostToolNotFound, Schema.TaggedStruct<"HostToolNotFound", {}>, import("effect/Cause").YieldableError>;
+/** The freshly evaluated catalog did not contain the requested tool. */
+export declare class HostToolNotFound extends HostToolNotFound_base {
+}
+/** One failing input location and its expected shape; never the supplied value. */
+export declare const InputProblem: Schema.String;
+/** Input decoding reports at most this many problems. */
+export declare const maxInputProblems = 10;
+declare const HostInputInvalid_base: Schema.Class<HostInputInvalid, Schema.TaggedStruct<"HostInputInvalid", {
+    readonly problems: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+/** Native input decoding failed; supplied values are omitted. Builds before problems were reported send none. */
+export declare class HostInputInvalid extends HostInputInvalid_base {
+}
+declare const HostToolBlocked_base: Schema.Class<HostToolBlocked, Schema.TaggedStruct<"HostToolBlocked", {}>, import("effect/Cause").YieldableError>;
+/** The tool's approval policy blocked this call before its tool body ran. */
+export declare class HostToolBlocked extends HostToolBlocked_base {
+}
+declare const HostToolApprovalRequired_base: Schema.Class<HostToolApprovalRequired, Schema.TaggedStruct<"HostToolApprovalRequired", {
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly elicitation: Schema.Struct<{
+        readonly requestedSchema: Schema.Struct<{
+            readonly type: Schema.Literal<"object">;
+            readonly properties: Schema.$Record<Schema.String, Schema.Never>;
+        }>;
+        readonly mode: Schema.Literal<"form">;
+        readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly message: Schema.String;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+/** Policy elicitation plus decoded input. No tool body ran; the host owns delivery and resumption. */
+export declare class HostToolApprovalRequired extends HostToolApprovalRequired_base {
+}
+declare const HostToolPolicyFailed_base: Schema.Class<HostToolPolicyFailed, Schema.TaggedStruct<"HostToolPolicyFailed", {}>, import("effect/Cause").YieldableError>;
+/** The tool's approval policy failed or returned an invalid decision. Author failures remain private. */
+export declare class HostToolPolicyFailed extends HostToolPolicyFailed_base {
+}
+declare const HostOutputInvalid_base: Schema.Class<HostOutputInvalid, Schema.TaggedStruct<"HostOutputInvalid", {}>, import("effect/Cause").YieldableError>;
+/** A tool result was not JSON; the result is never included in the error. */
+export declare class HostOutputInvalid extends HostOutputInvalid_base {
+}
+/** Safe error envelope; no author exception, source, account fields or stack is serialized. */
+export declare const HostError: Schema.Union<readonly [typeof OpenapiResponseError, typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof WorkflowFailure, typeof HostRequestInvalid, typeof HostAccountsInvalid, typeof HostDeclarationInvalid, typeof HostEvaluationFailed, typeof HostOperationNotFound, typeof HostOperationFailed, typeof HostToolNotFound, typeof HostInputInvalid, typeof HostOutputInvalid, typeof HostToolBlocked, typeof HostToolApprovalRequired, typeof HostToolPolicyFailed, typeof ElicitationFailed]>;
+/** Expected host failures. */
+export type HostError = typeof HostError.Type;
+/** Portable response envelope; callers parse the success value for their operation. */
+export declare const HostResponse: Schema.Union<readonly [Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly toolError: Schema.optionalKey<Schema.Literal<true>>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: Schema.Union<readonly [typeof OpenapiResponseError, typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof WorkflowFailure, typeof HostRequestInvalid, typeof HostAccountsInvalid, typeof HostDeclarationInvalid, typeof HostEvaluationFailed, typeof HostOperationNotFound, typeof HostOperationFailed, typeof HostToolNotFound, typeof HostInputInvalid, typeof HostOutputInvalid, typeof HostToolBlocked, typeof HostToolApprovalRequired, typeof HostToolPolicyFailed, typeof ElicitationFailed]>;
+}>]>;
+/** Parsed response envelope. */
+export type HostResponse = typeof HostResponse.Type;
+/**
+ * The JSON body the host sends to a bundle's generated server entry. The entry is compiled into
+ * the retained build, so this shape is frozen with the protocol too.
+ */
+export declare const HostInvocation: Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly operation: Schema.Literal<"workflows">;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"workflow-validate">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"workflow-run">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>, Schema.Union<readonly [Schema.Struct<{
+        readonly operation: Schema.Literal<"webhooks">;
+    }>, Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-validate">;
+    }>, Schema.Struct<{
+        readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-complete">;
+    }>, Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-register">;
+    }>, Schema.Struct<{
+        readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-unregister">;
+    }>, Schema.Struct<{
+        readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly request: Schema.Struct<{
+            readonly url: Schema.String;
+            readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+            readonly headers: Schema.$Record<Schema.String, Schema.String>;
+            readonly body: Schema.String;
+        }>;
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-handle">;
+    }>]>, Schema.Struct<{
+        readonly operation: Schema.Literal<"requirements">;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"inspect">;
+        /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+        readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+        /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+        readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        /**
+         * Describe only declared operations that have schedules, without dynamic tool discovery.
+         * Only builds that declare the scheduledTools capability accept this.
+         */
+        readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"skills">;
+        /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+        readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"query">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"mutate">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"call">;
+        readonly tool: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>;
+    readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "acc">;
+        readonly provider: Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"secrets">;
+                readonly label: Schema.String;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly discover: Schema.String;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly authorizationUrl: Schema.String;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly issuer: Schema.optionalKey<Schema.String>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly discover: Schema.String;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>]>>;
+        }>;
+        readonly method: Schema.NonEmptyString;
+        /**
+         * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+         * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+         */
+        readonly generation: Schema.optionalKey<Schema.Int>;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "acc">;
+        readonly provider: Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"secrets">;
+                readonly label: Schema.String;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly discover: Schema.String;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly authorizationUrl: Schema.String;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly issuer: Schema.optionalKey<Schema.String>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly discover: Schema.String;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>]>>;
+        }>;
+        readonly method: Schema.NonEmptyString;
+        /**
+         * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+         * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+         */
+        readonly generation: Schema.optionalKey<Schema.Int>;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>]>>;
+    readonly approval: Schema.optionalKey<Schema.Struct<{
+        readonly tool: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>;
+    readonly replay: Schema.optionalKey<Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly fingerprint: Schema.NonEmptyString;
+    }>>;
+    readonly deadline: Schema.optionalKey<Schema.Finite>;
+    readonly workflowRun: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "wfr">>;
+}>;
+export type HostInvocation = typeof HostInvocation.Type;
+/** Every message of protocol 1, in the order its snapshot records them. */
+export declare const protocol1: {
+    readonly version: 1;
+    readonly schemas: {
+        readonly invocation: Schema.Struct<{
+            readonly command: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly operation: Schema.Literal<"workflows">;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"workflow-validate">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"workflow-run">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>]>, Schema.Union<readonly [Schema.Struct<{
+                readonly operation: Schema.Literal<"webhooks">;
+            }>, Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-validate">;
+            }>, Schema.Struct<{
+                readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-complete">;
+            }>, Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-register">;
+            }>, Schema.Struct<{
+                readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-unregister">;
+            }>, Schema.Struct<{
+                readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly request: Schema.Struct<{
+                    readonly url: Schema.String;
+                    readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+                    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+                    readonly body: Schema.String;
+                }>;
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-handle">;
+            }>]>, Schema.Struct<{
+                readonly operation: Schema.Literal<"requirements">;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"inspect">;
+                /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+                readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+                /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+                readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                /**
+                 * Describe only declared operations that have schedules, without dynamic tool discovery.
+                 * Only builds that declare the scheduledTools capability accept this.
+                 */
+                readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"skills">;
+                /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+                readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"mutate">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"call">;
+                readonly tool: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>]>;
+            readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "acc">;
+                readonly provider: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"secrets">;
+                        readonly label: Schema.String;
+                        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly discover: Schema.String;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly authorizationUrl: Schema.String;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly issuer: Schema.optionalKey<Schema.String>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly discover: Schema.String;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>]>>;
+                }>;
+                readonly method: Schema.NonEmptyString;
+                /**
+                 * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+                 * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+                 */
+                readonly generation: Schema.optionalKey<Schema.Int>;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "acc">;
+                readonly provider: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"secrets">;
+                        readonly label: Schema.String;
+                        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly discover: Schema.String;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly authorizationUrl: Schema.String;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly issuer: Schema.optionalKey<Schema.String>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly discover: Schema.String;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>]>>;
+                }>;
+                readonly method: Schema.NonEmptyString;
+                /**
+                 * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+                 * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+                 */
+                readonly generation: Schema.optionalKey<Schema.Int>;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>]>>;
+            readonly approval: Schema.optionalKey<Schema.Struct<{
+                readonly tool: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>>;
+            readonly replay: Schema.optionalKey<Schema.Struct<{
+                readonly key: Schema.NonEmptyString;
+                readonly fingerprint: Schema.NonEmptyString;
+            }>>;
+            readonly deadline: Schema.optionalKey<Schema.Finite>;
+            readonly workflowRun: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "wfr">>;
+        }>;
+        readonly request: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"workflows">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"workflow-validate">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"workflow-run">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>]>, Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"webhooks">;
+        }>, Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-validate">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-complete">;
+        }>, Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-register">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-unregister">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly request: Schema.Struct<{
+                readonly url: Schema.String;
+                readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+                readonly headers: Schema.$Record<Schema.String, Schema.String>;
+                readonly body: Schema.String;
+            }>;
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-handle">;
+        }>]>, Schema.Struct<{
+            readonly operation: Schema.Literal<"requirements">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"inspect">;
+            /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+            readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+            /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+            readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            /**
+             * Describe only declared operations that have schedules, without dynamic tool discovery.
+             * Only builds that declare the scheduledTools capability accept this.
+             */
+            readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"skills">;
+            /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+            readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"query">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"mutate">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"call">;
+            readonly tool: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>]>;
+        readonly response: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly toolError: Schema.optionalKey<Schema.Literal<true>>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: Schema.Union<readonly [typeof OpenapiResponseError, typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof WorkflowFailure, typeof HostRequestInvalid, typeof HostAccountsInvalid, typeof HostDeclarationInvalid, typeof HostEvaluationFailed, typeof HostOperationNotFound, typeof HostOperationFailed, typeof HostToolNotFound, typeof HostInputInvalid, typeof HostOutputInvalid, typeof HostToolBlocked, typeof HostToolApprovalRequired, typeof HostToolPolicyFailed, typeof ElicitationFailed]>;
+        }>]>;
+        readonly requirements: Schema.Struct<{
+            /** Protocol support of this retained framework build, not an author-declared requirement. */
+            readonly capabilities: Schema.optionalKey<Schema.Struct<{
+                readonly skills: Schema.Literal<true>;
+                /** Accepts inspect detail and tools. Earlier builds reject both as excess fields. */
+                readonly toolIndex: Schema.optionalKey<Schema.Literal<true>>;
+                /** Accepts skills sources and reports whether the catalog includes a live loader. */
+                readonly skillSources: Schema.optionalKey<Schema.Literal<true>>;
+                /** Accepts scheduled inspection. Earlier builds reject it as an excess field. */
+                readonly scheduledTools: Schema.optionalKey<Schema.Literal<true>>;
+            }>>;
+            readonly database: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly fields: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["string", "number", "boolean", "id", "userId"]>;
+                    readonly optional: Schema.optional<Schema.Boolean>;
+                    readonly default: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+                    readonly references: Schema.optional<Schema.String>;
+                }>>;
+                readonly indexes: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly fields: Schema.NonEmptyArray<Schema.String>;
+                }>>;
+            }>>>;
+            readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"secrets">;
+                        readonly label: Schema.String;
+                        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly discover: Schema.String;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly authorizationUrl: Schema.String;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly issuer: Schema.optionalKey<Schema.String>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly discover: Schema.String;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>]>>;
+                }>;
+                readonly cardinality: Schema.Literals<readonly ["one", "many"]>;
+            }>>;
+        }>;
+        readonly tools: Schema.$Array<Schema.Struct<{
+            readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly timing: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"interval">;
+                    readonly milliseconds: Schema.Int;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"cron">;
+                    readonly calendar: Schema.Struct<{
+                        readonly expression: Schema.NonEmptyString;
+                        readonly timezone: Schema.NonEmptyString;
+                    }>;
+                }>]>;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>>>;
+            readonly name: Schema.NonEmptyString;
+            readonly description: Schema.String;
+            readonly inputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+            readonly title: Schema.optionalKey<Schema.String>;
+            readonly outputSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly annotations: Schema.optionalKey<Schema.Struct<{
+                readonly title: Schema.optionalKey<Schema.String>;
+                readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+                readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+                readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+                readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+            }>>;
+            readonly _meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly toolSummaries: Schema.$Array<Schema.Struct<{
+            readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly timing: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"interval">;
+                    readonly milliseconds: Schema.Int;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"cron">;
+                    readonly calendar: Schema.Struct<{
+                        readonly expression: Schema.NonEmptyString;
+                        readonly timezone: Schema.NonEmptyString;
+                    }>;
+                }>]>;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>>>;
+            readonly name: Schema.NonEmptyString;
+            readonly description: Schema.String;
+            readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+            readonly title: Schema.optionalKey<Schema.String>;
+            readonly annotations: Schema.optionalKey<Schema.Struct<{
+                readonly title: Schema.optionalKey<Schema.String>;
+                readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+                readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+                readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+                readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+            }>>;
+        }>>;
+        readonly skills: Schema.Union<readonly [Schema.Struct<{
+            readonly skills: Schema.$Array<Schema.Struct<{
+                readonly files: Schema.$Array<Schema.Struct<{
+                    readonly path: Schema.NonEmptyString;
+                    readonly content: Schema.String;
+                }>>;
+                readonly name: Schema.NonEmptyString;
+                readonly description: Schema.String;
+                readonly license: Schema.optionalKey<Schema.String>;
+                readonly compatibility: Schema.optionalKey<Schema.String>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly dynamic: Schema.Boolean;
+        }>, Schema.$Array<Schema.Struct<{
+            readonly files: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.NonEmptyString;
+                readonly content: Schema.String;
+            }>>;
+            readonly name: Schema.NonEmptyString;
+            readonly description: Schema.String;
+            readonly license: Schema.optionalKey<Schema.String>;
+            readonly compatibility: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+        }>>]>;
+        readonly elicitationRequest: Schema.Struct<{
+            readonly mode: Schema.Literal<"form">;
+            readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly type: Schema.tag<"object">;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof McpSchema.LegacyTitledEnum, Schema.Union<readonly [typeof McpSchema.UntitledSingleSelectEnum, typeof McpSchema.TitledSingleSelectEnum]>, Schema.Union<readonly [typeof McpSchema.UntitledMultiSelectEnum, typeof McpSchema.TitledMultiSelectEnum]>]>, typeof McpSchema.ElicitationString, typeof McpSchema.ElicitationNumber, typeof McpSchema.ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            }>>;
+            readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly message: Schema.String;
+        }>;
+        readonly elicitationReply: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly response: Schema.Union<readonly [Schema.Struct<{
+                readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly action: Schema.Literal<"accept">;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+            }>, Schema.Struct<{
+                readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly action: Schema.Literals<readonly ["cancel", "decline"]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: typeof ElicitationFailed;
+        }>]>;
+        readonly workflowStep: Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"do">;
+            readonly name: Schema.NonEmptyString;
+            readonly options: Schema.Struct<{
+                readonly retries: Schema.optionalKey<Schema.Struct<{
+                    readonly limit: Schema.Int;
+                    readonly delay: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+                    readonly backoff: Schema.optionalKey<Schema.Literals<readonly ["constant", "linear", "exponential"]>>;
+                }>>;
+                readonly timeout: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"sleep">;
+            readonly name: Schema.NonEmptyString;
+            readonly duration: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"until">;
+            readonly name: Schema.NonEmptyString;
+            readonly timestamp: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"context">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"invoke">;
+            readonly kind: Schema.Literals<readonly ["query", "mutation"]>;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly stepId: Schema.NonEmptyString;
+            readonly timeout: Schema.Finite;
+        }>]>;
+        readonly workflowStepReply: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: typeof WorkflowFailure;
+        }>]>;
+        readonly workflowControl: Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"start">;
+            readonly workflow: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly key: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"get">;
+            readonly run: Schema.brand<Schema.NonEmptyString, "wfr">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"list">;
+            readonly workflow: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly cursor: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "wfr">>;
+            readonly limit: Schema.optionalKey<Schema.Int>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"terminate">;
+            readonly run: Schema.brand<Schema.NonEmptyString, "wfr">;
+        }>]>;
+        readonly cacheCommand: Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"read">;
+            readonly keys: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"acquire">;
+            readonly key: Schema.String;
+            /** Claim even a fresh entry, as an explicit refresh does. */
+            readonly refresh: Schema.Boolean;
+            /** Claim only while the entry still has this version. Absent accepts the current one. */
+            readonly version: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"claim">;
+            readonly key: Schema.String;
+            readonly version: Schema.NullOr<Schema.String>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"publish">;
+            readonly key: Schema.String;
+            readonly lease: Schema.String;
+            readonly entry: Schema.Struct<{
+                readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly version: Schema.String;
+                readonly freshUntil: Schema.Finite;
+                readonly staleUntil: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"release">;
+            readonly key: Schema.String;
+            readonly lease: Schema.String;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"renew">;
+            readonly key: Schema.String;
+            readonly lease: Schema.String;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"write">;
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly entry: Schema.Struct<{
+                    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly version: Schema.String;
+                    readonly freshUntil: Schema.Finite;
+                    readonly staleUntil: Schema.Finite;
+                }>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"invalidate">;
+            readonly key: Schema.String;
+        }>]>;
+        readonly cacheReply: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: typeof CacheError;
+        }>]>;
+    };
+};
+export {};