apps 0.0.1-beta.7 → 0.0.1-beta.70

package/types/app-cache/src/contracts/cache.d.ts

@@ -2,6 +2,8 @@
 import { Schema, type Effect } from "effect";
 declare const CacheError_base: Schema.Class<CacheError, Schema.TaggedStruct<"CacheError", {
     readonly reason: Schema.Literals<readonly ["unavailable", "storage", "invalid", "capacity", "timeout"]>;
+    /** Which of `cacheLimits` the request exceeded, when one did. */
+    readonly limit: Schema.optionalKey<Schema.Literals<readonly ["keyBytes", "entryBytes", "batchBytes", "batchEntries", "totalBytes", "totalEntries"]>>;
 }>, import("effect/Cause").YieldableError>;
 /** Expected cache failures never include keys, values or upstream exception text. */
 export declare class CacheError extends CacheError_base {

package/types/app-cache/src/index.d.ts

@@ -10,6 +10,12 @@ export interface CacheGet<A> {
     readonly schema: Schema.Decoder<A>;
     readonly freshFor: Duration.Input;
     readonly staleFor?: Duration.Input;
+    /**
+     * What a read does with a value past `freshFor` and within `staleFor`. `serve`, the default,
+     * returns it while one background load replaces it. `revalidate` awaits that load first, like a
+     * miss; the value stays readable to the load, which can confirm it instead of rebuilding it.
+     */
+    readonly stale?: "serve" | "revalidate";
     readonly load: Effect.Effect<A, unknown>;
 }
 /** Create a scoped cache client; a background runner must retain all task resources until completion. */
@@ -30,7 +36,10 @@ deadline?: number) => {
     }[], retention: Duration.Input) => Effect.Effect<void, CacheError, never>;
     /** Revoke retained data and any loader's right to publish its in-flight result. */
     invalidate: (key: Schema.Json) => Effect.Effect<void, CacheError, never>;
-    /** Read fresh data, refresh stale data in the background, or wait for the lease owner. */
+    /**
+     * Read fresh data, refresh stale data in the background (or first, with `stale: "revalidate"`),
+     * or wait for the lease owner.
+     */
     get: <A>(options: CacheGet<A>) => Effect.Effect<A, unknown, never>;
     /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
     revalidate: <A>(options: CacheGet<A>) => Effect.Effect<A, unknown, never>;

package/types/apps/src/contracts/api-response-error.d.ts

@@ -1,4 +1,6 @@
 import { Schema } from "effect";
+/** 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;
@@ -6,6 +8,8 @@ export declare const ApiErrorRecovery: Schema.Struct<{
 }>;
 /** 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;

package/types/apps/src/contracts/app.d.ts

@@ -1,5 +1,4 @@
 import type { AppSkillSource, SkillFile } from "./skills.js";
-import type { DatabaseDefinition } from "./storage.js";
 /** Native app contracts; factories and handlers compose in the host's Effect runtime. */
 import { type Effect, Schema } from "effect";
 import type { OperationSchedule } from "./schedules.js";
@@ -43,7 +42,11 @@ export interface BoundContext<Slots extends AccountSlots> {
     readonly workflows: WorkflowReads;
     /** Ask for user input during this tool call. Unavailable during discovery and after the invocation closes. */
     readonly elicit: Elicit;
-    /** Invocation-owned HTTP requests with trace propagation and host cancellation. */
+    /**
+     * Invocation-owned HTTP requests with trace propagation and host cancellation. It lasts until the
+     * invocation and every app cache refresh it started in the background have ended, so a catalog
+     * loader given this fetch can refresh after the reply.
+     */
     readonly fetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
     /** Host cancellation for this invocation. Pass it to fetch and other interruptible APIs. */
     readonly signal: AbortSignal;
@@ -54,7 +57,8 @@ export interface BoundContext<Slots extends AccountSlots> {
 /** The host evaluates this factory fresh with the configured app's selected accounts. */
 export interface App<Slots extends AccountSlots, Def extends AppDefinition<never>> {
     readonly accounts: Slots;
-    readonly database?: DatabaseDefinition;
+    /** Declared beside the accounts, so a host lists them without evaluating the app. */
+    readonly events?: Readonly<Record<string, import("./events.js").AppEvent>>;
     readonly evaluate: (context: BoundContext<Slots>) => Effect.Effect<Def, unknown>;
 }
 declare const NotImplemented_base: Schema.Class<NotImplemented, Schema.TaggedStruct<"NotImplemented", {

package/types/apps/src/contracts/cache.d.ts

@@ -15,6 +15,12 @@ export interface CacheGetOptions<A> {
     readonly schema: Schema<A, boolean>;
     readonly freshFor: Duration.Input;
     readonly staleFor?: Duration.Input;
+    /**
+     * Past `freshFor`, `serve` (the default) returns the kept value while `load` replaces it in the
+     * background. `revalidate` awaits `load` first; the kept value stays readable with `read`, so
+     * the loader can confirm it with the source instead of rebuilding it.
+     */
+    readonly stale?: "serve" | "revalidate";
     readonly load: (context: CacheLoadContext) => Promise<A>;
 }
 /** Cache keys describe every input that affects the value; the host adds app/build isolation. */
@@ -37,6 +43,20 @@ export interface AppCache {
         readonly id: string;
     }) => AppCache;
 }
+/**
+ * A credential a remote read sends, and the account it belongs to. A public source takes neither.
+ * A credential comes only with its account, so the read is cached in that account's scope.
+ */
+export type AccountCredential<Credential extends object> = ({
+    readonly account?: undefined;
+} & {
+    readonly [Field in keyof Credential]?: undefined;
+}) | ({
+    /** The selected account, as `accounts.<slot>` provides it. */
+    readonly account: {
+        readonly id: string;
+    };
+} & Credential);
 /** Trusted storage and background ownership; never accepted from request JSON. */
 export interface HostCache {
     readonly transport: CacheTransport;

package/types/apps/src/contracts/context.d.ts

@@ -1,25 +1,33 @@
 /** Public handler contexts derive capabilities from one shared requirements declaration. */
 import type { WorkflowControls } from "./workflows.js";
 import type { AccountSlots, BoundContext } from "./app.js";
-import type { Database, DatabaseDefinition, DatabaseReader, Tables } from "./storage.js";
-/** Requirements are pure values; selected accounts and database sessions belong to invocations. */
+import type { Sql, SqlReader } from "./sql.js";
+import type { AnyEventDeclaration, EventEmitter } from "../implementation/events.js";
+/** Requirements are pure values; selected accounts and SQL access belong to invocations. */
 export interface AppRequirements {
     readonly accounts: AccountSlots;
-    readonly database?: DatabaseDefinition;
+    /** Events this app emits, by name, such as `issue.opened`. */
+    readonly events?: Readonly<Record<string, AnyEventDeclaration>>;
 }
-type StorageContext<Requirements, Writable extends boolean> = Requirements extends {
-    readonly database: DatabaseDefinition<infer T extends Tables>;
-} ? {
-    readonly db: Writable extends true ? Database<T> : DatabaseReader<T>;
-} : {};
+/** The emitter for an app's declared events. */
+type EventsContext<Requirements extends AppRequirements> = {
+    readonly events: EventEmitter<NonNullable<Requirements["events"]>>;
+};
+/**
+ * Every handler has `ctx.sql`. The app's database exists once the build has SQL files in
+ * `migrations/`; before that, any statement fails and says so.
+ */
+type StorageContext<Writable extends boolean> = {
+    readonly sql: Writable extends true ? Sql : SqlReader;
+};
 /** Context available during dynamic app evaluation; storage opens only for handlers. */
 export type AppContext<Requirements extends AppRequirements = AppRequirements> = BoundContext<Requirements["accounts"]>;
 /** Interactive query context; declared storage exposes only read methods. */
-export type QueryContext<Requirements extends AppRequirements = AppRequirements> = AppContext<Requirements> & StorageContext<Requirements, false>;
-/** Interactive mutation context; declared storage belongs to the invocation transaction. */
+export type QueryContext<Requirements extends AppRequirements = AppRequirements> = AppContext<Requirements> & StorageContext<false>;
+/** Interactive mutation context; outside calls happen between SQL transactions, never inside one. */
 export type MutationContext<Requirements extends AppRequirements = AppRequirements> = Omit<AppContext<Requirements>, "workflows"> & {
     readonly workflows: WorkflowControls;
-} & StorageContext<Requirements, true>;
+} & StorageContext<true> & EventsContext<Requirements>;
 /** Background webhook context has account and storage access without interactive input. */
 export type WebhookContext<Requirements extends AppRequirements = AppRequirements> = Omit<MutationContext<Requirements>, "elicit">;
 export {};

package/types/apps/src/contracts/elicitation.d.ts

@@ -1,6 +1,6 @@
 /** Shared MCP elicitation data. Delivery belongs to the host, independently of its transport. */
 import { Schema, type Effect } from "effect";
-import * as McpSchema from "effect/unstable/ai/McpSchema";
+import * as McpSchema from "effect/ai/McpSchema";
 import { type JsonValue } from "./schema.js";
 /** Maximum human-input wait, separate from active provider execution time. */
 export declare const ElicitationLimits: Schema.Struct<{
@@ -15,10 +15,10 @@ export declare const defaultElicitationLimits: {
 export declare const FormElicitation: Schema.Struct<{
     readonly mode: Schema.Literal<"form">;
     readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
-        readonly $schema: Schema.decodeTo<Schema.optional<Schema.String>, Schema.optionalKey<Schema.String>, never, never>;
+        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.optional<Schema.$Array<Schema.String>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        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;
@@ -28,7 +28,7 @@ export type FormElicitation = typeof FormElicitation.Type;
 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.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>;
+    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"]>;
@@ -50,7 +50,7 @@ export declare const ElicitationReply: Schema.Union<readonly [Schema.Struct<{
     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.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>;
+        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"]>;
@@ -75,7 +75,7 @@ export type ApprovalElicitation = typeof ApprovalElicitation.Type;
 export declare const ApprovalResponse: 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.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>;
+    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"]>;

package/types/apps/src/contracts/events.d.ts

@@ -0,0 +1,93 @@
+/**
+ * App events. An app declares the events it emits beside its account requirements, so a host
+ * reads them without evaluating the app. Handlers emit occurrences; the host keeps them only
+ * when the invocation that emitted them succeeds, then delivers them to its subscribers.
+ */
+import { Schema } from "effect";
+/** Dotted lower-case words, such as `issue.opened`. Hosts prefix them with the app's slug. */
+export declare const EventName: Schema.String;
+export type EventName = typeof EventName.Type;
+/** A filter value: subscribers match an occurrence by equal scalars. */
+export declare const EventFilterValue: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>;
+export type EventFilterValue = typeof EventFilterValue.Type;
+/** Size and count limits for events; bytes are UTF-8 bytes of the JSON text. */
+export declare const EventLimits: Schema.Struct<{
+    /** An occurrence's `data`, leaving room under a 256 KiB delivery for its envelope. */
+    readonly maxDataBytes: Schema.Int;
+    readonly maxEventsPerInvocation: Schema.Int;
+    readonly maxDescriptionLength: Schema.Int;
+    readonly maxIdLength: Schema.Int;
+}>;
+export type EventLimits = typeof EventLimits.Type;
+export declare const defaultEventLimits: {
+    readonly maxDataBytes: number;
+    readonly maxEventsPerInvocation: number;
+    readonly maxDescriptionLength: number;
+    readonly maxIdLength: number;
+};
+/** One event as the host reads it from an app's requirements. Both schemas are JSON Schema. */
+export declare const DeclaredEvent: Schema.Struct<{
+    readonly description: Schema.String;
+    /** An object of scalar fields. Subscribers may name any of them to narrow an event. */
+    readonly filters: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    /** The shape of each occurrence's `data`. */
+    readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type DeclaredEvent = typeof DeclaredEvent.Type;
+/** An app's declared events, by name. */
+export declare const DeclaredEvents: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly description: Schema.String;
+    /** An object of scalar fields. Subscribers may name any of them to narrow an event. */
+    readonly filters: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    /** The shape of each occurrence's `data`. */
+    readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>>;
+export type DeclaredEvents = typeof DeclaredEvents.Type;
+/**
+ * One occurrence an invocation emitted. `id` is the stable identifier subscribers deduplicate on,
+ * such as the provider's delivery ID. `account` is the account the event came from, or null for
+ * an app without accounts.
+ */
+export declare const EmittedEvent: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly id: Schema.String;
+    /** Milliseconds since the epoch when the event happened. */
+    readonly occurredAt: Schema.Int;
+    readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly filters: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+    readonly account: Schema.NullOr<Schema.brand<Schema.String, "acc">>;
+}>;
+export type EmittedEvent = typeof EmittedEvent.Type;
+/** What a successful invocation emitted, in order. */
+export declare const EmittedEvents: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly id: Schema.String;
+    /** Milliseconds since the epoch when the event happened. */
+    readonly occurredAt: Schema.Int;
+    readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly filters: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+    readonly account: Schema.NullOr<Schema.brand<Schema.String, "acc">>;
+}>>;
+/** Native event declaration. Filters are named scalar fields; the payload is any JSON schema. */
+export interface AppEvent {
+    readonly description: string;
+    readonly filters: Readonly<Record<string, Schema.Decoder<unknown>>>;
+    readonly payload: Schema.Decoder<unknown>;
+}
+/** Options for one emitted occurrence. */
+export interface EmitOptions<Filters> {
+    /** Values subscribers filter on. Required when the event declares filters. */
+    readonly filters?: Filters;
+    /**
+     * A stable identifier, such as the provider's delivery or record ID, so a repeated delivery of
+     * the same upstream event is not delivered twice. Defaults to a random ID.
+     */
+    readonly id?: string | undefined;
+    /** When the event happened. Defaults to now. */
+    readonly occurredAt?: Date | number | undefined;
+    /**
+     * The ID of the account the event came from. A webhook handler defaults to its source account,
+     * and an invocation with exactly one account to that account. Name it when there are several.
+     */
+    readonly account?: string | undefined;
+}

package/types/apps/src/contracts/failure.d.ts

@@ -9,10 +9,24 @@ export declare const maxFailureMessageLength = 2048;
 export declare const FailureSource: Schema.Literals<readonly ["app", "storage", "service"]>;
 /** The thrown error's name, such as `TypeError`, or the host error's tag. */
 export declare const FailureName: Schema.String;
-/** A stable host failure code, such as an app data reason. */
+/** A stable host failure code, such as an app data reason, or the thrown error's own `code`. */
 export declare const FailureCode: Schema.String;
 /** Bounded, with the invocation's account secrets replaced. */
 export declare const FailureMessage: Schema.String;
+/** Most fields of one thrown error carried across the runtime boundary. */
+export declare const maxFailureFields = 8;
+/** Longest text field value carried across the runtime boundary. */
+export declare const maxFailureFieldLength = 256;
+/** A field name as the error's code spells it, such as `reason` or `pointer`. */
+export declare const FailureFieldName: Schema.String;
+/** Bounded text with account secrets replaced, a finite number, or a boolean. */
+export declare const FailureFieldValue: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>;
+/**
+ * The thrown error's own scalar fields beside its name, code and message, such as the `reason`
+ * and `pointer` a spec compiler sets. Nested values, stacks and causes are never carried.
+ */
+export declare const FailureFields: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+export type FailureFields = typeof FailureFields.Type;
 /**
  * The error an app's own code raised, or the specific host failure it hit. Stacks and cause
  * values stay private. Builds from before these fields existed send none.
@@ -22,4 +36,19 @@ export declare const FailureDetail: {
     errorName: Schema.optionalKey<Schema.String>;
     code: Schema.optionalKey<Schema.String>;
     message: Schema.optionalKey<Schema.String>;
+    fields: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>>;
 };
+/** Longest error message a service stated, as carried across the runtime boundary. */
+export declare const maxUpstreamMessageLength = 1024;
+/**
+ * The error a service stated in its own response: a JSON-RPC error's code and message, or an
+ * OAuth Bearer error code and description. Bounded, with the invocation's account secrets replaced.
+ */
+export declare const UpstreamError: Schema.Struct<{
+    readonly code: Schema.Union<readonly [Schema.Int, Schema.String]>;
+    readonly message: Schema.optionalKey<Schema.String>;
+}>;
+export type UpstreamError = typeof UpstreamError.Type;
+/** Where a service failed: setting up a session, listing tools, or running one. */
+export declare const FailurePhase: Schema.Literals<readonly ["connect", "discover", "call"]>;
+export type FailurePhase = typeof FailurePhase.Type;

package/types/apps/src/contracts/graphql.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderError } from "./provider-error.js";
+import type { NetworkRefused } from "./network.js";
 /** GraphQL discovery contracts. Catalogs are evaluated with the selected account. */
 import { Schema, type Effect } from "effect";
 import { type JsonValue } from "./schema.js";
@@ -97,7 +98,7 @@ export interface GraphqlTool {
     readonly description: string;
     readonly readOnly: boolean;
     readonly input: Schema.Decoder<JsonValue>;
-    readonly run: (context: unknown, input: JsonValue) => Effect.Effect<JsonValue, GraphqlError | ProviderError>;
+    readonly run: (context: unknown, input: JsonValue) => Effect.Effect<JsonValue, GraphqlError | ProviderError | NetworkRefused>;
 }
 /** One tool per root field; subscriptions require a separate long-lived host. */
 export type GraphqlTools = Readonly<Record<string, GraphqlTool>>;