@voltro/ai 0.84.0 → 0.86.0

package/dist/index.d.ts

@@ -21,7 +21,6 @@ import { PluginMediaPersistCapability } from '@voltro/protocol';
 import { PluginMediaPersistMetadata } from '@voltro/protocol';
 import { QueryDescriptor } from '@voltro/database';
 import { QueryProcedureDescriptor } from '@voltro/protocol';
-import { Runtime } from 'effect';
 import { Schema } from 'effect';
 import { SchemaTable } from '@voltro/database';
 import { SemanticCacheShape } from '@voltro/cache';
@@ -81,7 +80,7 @@ export declare const agentActor: (subjectId: string | null) => {
     readonly via: "agent";
 };
 
-export declare interface AgentDescriptor<S extends Schema.Schema.Any = DefaultAgentInputSchema> {
+export declare interface AgentDescriptor<S extends Schema.Top = DefaultAgentInputSchema> {
     readonly _brand: typeof AGENT_DESCRIPTOR_BRAND;
     /** Wire id → rpc tags `<name>.send` / `<name>.messages`. */
     readonly name: string;
@@ -94,69 +93,71 @@ export declare interface AgentDescriptor<S extends Schema.Schema.Any = DefaultAg
 }
 
 /** Error taxonomy. `retryable` on the event drives client/agent retry. */
-export declare const AgentErrorCode: Schema.Literal<["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
+export declare const AgentErrorCode: Schema.Literals<readonly ["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
 
 export declare type AgentErrorCode = typeof AgentErrorCode.Type;
 
-export declare const AgentEvent: Schema.Union<[Schema.Struct<{
-    _tag: Schema.Literal<["token"]>;
-    text: typeof Schema.String;
+export declare const AgentEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"token">;
+    readonly text: Schema.String;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["reasoning"]>;
-    text: typeof Schema.String;
+    readonly _tag: Schema.Literal<"reasoning">;
+    readonly text: Schema.String;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["toolCall"]>;
-    id: typeof Schema.String;
-    name: typeof Schema.String;
-    input: typeof Schema.Unknown;
+    readonly _tag: Schema.Literal<"toolCall">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+    /** Present when the caller must execute this pending call. */
+    readonly execution: Schema.optional<Schema.Literal<"client">>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["toolResult"]>;
-    id: typeof Schema.String;
-    name: typeof Schema.String;
-    output: Schema.optional<typeof Schema.Unknown>;
-    error: Schema.optional<typeof Schema.String>;
+    readonly _tag: Schema.Literal<"toolResult">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly output: Schema.optional<Schema.Unknown>;
+    readonly error: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["source"]>;
-    sourceType: Schema.Literal<["url", "document"]>;
-    id: typeof Schema.String;
-    url: Schema.optional<typeof Schema.String>;
-    title: Schema.optional<typeof Schema.String>;
-    mediaType: Schema.optional<typeof Schema.String>;
-    filename: Schema.optional<typeof Schema.String>;
+    readonly _tag: Schema.Literal<"source">;
+    readonly sourceType: Schema.Literals<readonly ["url", "document"]>;
+    readonly id: Schema.String;
+    readonly url: Schema.optional<Schema.String>;
+    readonly title: Schema.optional<Schema.String>;
+    readonly mediaType: Schema.optional<Schema.String>;
+    readonly filename: Schema.optional<Schema.String>;
     /** Provider-owned citation attribution; not normalized or interpreted. */
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["file"]>;
-    mediaType: typeof Schema.String;
-    data: typeof Schema.String;
+    readonly _tag: Schema.Literal<"file">;
+    readonly mediaType: Schema.String;
+    readonly data: Schema.String;
     /** Metadata for this file, not the whole model step. */
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["stepMetadata"]>;
-    step: Schema.filter<typeof Schema.Int>;
-    providerMetadata: typeof Schema.Unknown;
+    readonly _tag: Schema.Literal<"stepMetadata">;
+    readonly step: Schema.Int;
+    readonly providerMetadata: Schema.Unknown;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["message"]>;
-    role: typeof Schema.String;
-    content: typeof Schema.String;
+    readonly _tag: Schema.Literal<"message">;
+    readonly role: Schema.String;
+    readonly content: Schema.String;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["error"]>;
-    code: Schema.Literal<["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
-    message: typeof Schema.String;
-    retryable: typeof Schema.Boolean;
+    readonly _tag: Schema.Literal<"error">;
+    readonly code: Schema.Literals<readonly ["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["done"]>;
-    finishReason: typeof Schema.String;
-    usage: Schema.Struct<{
-        inputTokens: Schema.optional<typeof Schema.Number>;
-        outputTokens: Schema.optional<typeof Schema.Number>;
-        totalTokens: Schema.optional<typeof Schema.Number>;
+    readonly _tag: Schema.Literal<"done">;
+    readonly finishReason: Schema.String;
+    readonly usage: Schema.Struct<{
+        readonly inputTokens: Schema.optional<Schema.Number>;
+        readonly outputTokens: Schema.optional<Schema.Number>;
+        readonly totalTokens: Schema.optional<Schema.Number>;
     }>;
 }>]>;
 
 export declare type AgentEvent = typeof AgentEvent.Type;
 
-export declare interface AgentExecutor<S extends Schema.Schema.Any = DefaultAgentInputSchema> {
+export declare interface AgentExecutor<S extends Schema.Top = DefaultAgentInputSchema> {
     readonly _brand: typeof EXECUTOR_BRAND;
     readonly descriptor: AgentDescriptor<S>;
     readonly config: AgentExecutorConfig<AgentInput<S>>;
@@ -202,10 +203,10 @@ export declare interface AgentExecutorConfig<Input = {
 }
 
 /** The decoded input an agent's executor sees, derived from its schema. */
-export declare type AgentInput<S extends Schema.Schema.Any> = Schema.Schema.Type<S>;
+export declare type AgentInput<S extends Schema.Top> = Schema.Schema.Type<S>;
 
 /** The agent's input schema (default `{ prompt: string }`). */
-export declare const agentInputSchema: (desc: AnyAgentDescriptor) => Schema.Schema.Any;
+export declare const agentInputSchema: (desc: AnyAgentDescriptor) => Schema.Top;
 
 export declare interface AgentMessage {
     readonly id: string;
@@ -223,19 +224,16 @@ export declare interface AgentMessage {
 export declare type AgentMessageRole = 'user' | 'assistant' | 'system' | 'tool';
 
 export declare const agentMessageSchema: Schema.Struct<{
-    id: typeof Schema.String;
-    threadId: typeof Schema.String;
-    role: typeof Schema.String;
-    content: typeof Schema.String;
-    streaming: typeof Schema.Boolean;
-    order: typeof Schema.Number;
-    stepOrder: typeof Schema.Number;
-    parts: Schema.Array$<Schema.TypeLiteral<{
-        type: typeof Schema.String;
-    }, readonly [{
-        readonly key: typeof Schema.String;
-        readonly value: typeof Schema.Unknown;
-    }]>>;
+    readonly id: Schema.String;
+    readonly threadId: Schema.String;
+    readonly role: Schema.String;
+    readonly content: Schema.String;
+    readonly streaming: Schema.Boolean;
+    readonly order: Schema.Number;
+    readonly stepOrder: Schema.Number;
+    readonly parts: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+        readonly type: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
 }>;
 
 export declare const agentMessagesTable: Table<typeof AGENT_MESSAGES_TABLE, Record<string, ColumnDefinition<unknown>>, true>;
@@ -246,25 +244,22 @@ export declare const agentMessagesTable: Table<typeof AGENT_MESSAGES_TABLE, Reco
  * so "what the server serves" and "what the client is typed for" can't drift.
  */
 export declare const agentRouteDescriptors: (desc: AnyAgentDescriptor) => {
-    send: ActionProcedureDescriptor<`${string}.send`, Schema.Schema.Any, Schema.Struct<{
-        text: typeof Schema.String;
+    send: ActionProcedureDescriptor<`${string}.send`, Schema.Top, Schema.Struct<{
+        readonly text: Schema.String;
     }>, typeof AgentThreadAccessDenied>;
     messages: QueryProcedureDescriptor<`${string}.messages`, Schema.Struct<{
-        threadId: typeof Schema.String;
-    }>, Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        threadId: typeof Schema.String;
-        role: typeof Schema.String;
-        content: typeof Schema.String;
-        streaming: typeof Schema.Boolean;
-        order: typeof Schema.Number;
-        stepOrder: typeof Schema.Number;
-        parts: Schema.Array$<Schema.TypeLiteral<{
-            type: typeof Schema.String;
-        }, readonly [{
-            readonly key: typeof Schema.String;
-            readonly value: typeof Schema.Unknown;
-        }]>>;
+        readonly threadId: Schema.String;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly threadId: Schema.String;
+        readonly role: Schema.String;
+        readonly content: Schema.String;
+        readonly streaming: Schema.Boolean;
+        readonly order: Schema.Number;
+        readonly stepOrder: Schema.Number;
+        readonly parts: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.String;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
     }>>, typeof AgentThreadAccessDenied>;
 };
 
@@ -293,11 +288,9 @@ export declare class AgentThreadAccessDenied extends AgentThreadAccessDenied_bas
     get message(): string;
 }
 
-declare const AgentThreadAccessDenied_base: Schema.TaggedErrorClass<AgentThreadAccessDenied, "AgentThreadAccessDenied", {
-    readonly _tag: Schema.tag<"AgentThreadAccessDenied">;
-} & {
-    threadId: typeof Schema.String;
-}>;
+declare const AgentThreadAccessDenied_base: Schema.Class<AgentThreadAccessDenied, Schema.TaggedStruct<"AgentThreadAccessDenied", {
+    readonly threadId: Schema.String;
+}>, YieldableError>;
 
 export declare const agentThreadsTable: Table<typeof AGENT_THREADS_TABLE, Record<string, ColumnDefinition<unknown>>, true>;
 
@@ -315,25 +308,21 @@ export declare type AiBudgetError = AiBudgetExceeded | AiBudgetInvalidInput | Ai
 export declare class AiBudgetExceeded extends AiBudgetExceeded_base {
 }
 
-declare const AiBudgetExceeded_base: Schema.TaggedErrorClass<AiBudgetExceeded, "AiBudgetExceeded", {
-    readonly _tag: Schema.tag<"AiBudgetExceeded">;
-} & {
-    tenantId: Schema.NullOr<typeof Schema.String>;
-    limitUsd: typeof Schema.Number;
-    spentUsd: typeof Schema.Number;
-    attemptedUsd: typeof Schema.Number;
-}>;
+declare const AiBudgetExceeded_base: Schema.Class<AiBudgetExceeded, Schema.TaggedStruct<"AiBudgetExceeded", {
+    readonly tenantId: Schema.NullOr<Schema.String>;
+    readonly limitUsd: Schema.Number;
+    readonly spentUsd: Schema.Number;
+    readonly attemptedUsd: Schema.Number;
+}>, YieldableError>;
 
 /** Invalid caller configuration, without echoing the supplied value. */
 export declare class AiBudgetInvalidInput extends AiBudgetInvalidInput_base {
 }
 
-declare const AiBudgetInvalidInput_base: Schema.TaggedErrorClass<AiBudgetInvalidInput, "AiBudgetInvalidInput", {
-    readonly _tag: Schema.tag<"AiBudgetInvalidInput">;
-} & {
-    field: Schema.Literal<["limitUsd", "addUsd", "since", "reservationId", "tenantId"]>;
-    message: typeof Schema.String;
-}>;
+declare const AiBudgetInvalidInput_base: Schema.Class<AiBudgetInvalidInput, Schema.TaggedStruct<"AiBudgetInvalidInput", {
+    readonly field: Schema.Literals<readonly ["limitUsd", "addUsd", "since", "reservationId", "tenantId"]>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 export declare interface AiBudgetReservation {
     readonly reservationId: string;
@@ -346,12 +335,10 @@ export declare interface AiBudgetReservation {
 export declare class AiBudgetReservationConflict extends AiBudgetReservationConflict_base {
 }
 
-declare const AiBudgetReservationConflict_base: Schema.TaggedErrorClass<AiBudgetReservationConflict, "AiBudgetReservationConflict", {
-    readonly _tag: Schema.tag<"AiBudgetReservationConflict">;
-} & {
-    reason: Schema.Literal<["identity-bound", "already-released"]>;
-    message: typeof Schema.String;
-}>;
+declare const AiBudgetReservationConflict_base: Schema.Class<AiBudgetReservationConflict, Schema.TaggedStruct<"AiBudgetReservationConflict", {
+    readonly reason: Schema.Literals<readonly ["identity-bound", "already-released"]>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** Receipt and release tombstone. A receipt and its counter change commit together. */
 export declare const aiBudgetReservationsTable: Table<typeof AI_BUDGET_RESERVATIONS_TABLE, Record<string, ColumnDefinition<unknown>>, true>;
@@ -376,21 +363,21 @@ export declare type AiCallEvidence = typeof AiCallEvidenceSchema.Type;
 /** Allowlisted consumption evidence, never a provider response or SDK error.
  * Completeness describes the three token counters, not billing completeness. */
 export declare const AiCallEvidenceSchema: Schema.Struct<{
-    provider: typeof Schema.String;
-    model: typeof Schema.String;
-    usage: Schema.Struct<{
-        inputTokens: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
-        outputTokens: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
-        totalTokens: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
-        completeness: Schema.Literal<["complete", "partial", "unknown"]>;
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    readonly usage: Schema.Struct<{
+        readonly inputTokens: Schema.optional<Schema.Number>;
+        readonly outputTokens: Schema.optional<Schema.Number>;
+        readonly totalTokens: Schema.optional<Schema.Number>;
+        readonly completeness: Schema.Literals<readonly ["complete", "partial", "unknown"]>;
     }>;
-    cost: Schema.Union<[Schema.Struct<{
-        status: Schema.Literal<["actual"]>;
-        source: Schema.Literal<["gateway"]>;
-        usd: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly cost: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"actual">;
+        readonly source: Schema.Literal<"gateway">;
+        readonly usd: Schema.Number;
     }>, Schema.Struct<{
-        status: Schema.Literal<["unknown"]>;
-        source: Schema.Literal<["unreported"]>;
+        readonly status: Schema.Literal<"unknown">;
+        readonly source: Schema.Literal<"unreported">;
     }>]>;
 }>;
 
@@ -411,30 +398,28 @@ export declare interface AiCallLog {
 export declare class AiError extends AiError_base {
 }
 
-declare const AiError_base: Schema.TaggedErrorClass<AiError, "AiError", {
-    readonly _tag: Schema.tag<"AiError">;
-} & {
-    reason: Schema.Literal<["generation", "decode"]>;
-    message: typeof Schema.String;
-    evidence: Schema.optional<Schema.Struct<{
-        provider: typeof Schema.String;
-        model: typeof Schema.String;
-        usage: Schema.Struct<{
-            inputTokens: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
-            outputTokens: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
-            totalTokens: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
-            completeness: Schema.Literal<["complete", "partial", "unknown"]>;
+declare const AiError_base: Schema.Class<AiError, Schema.TaggedStruct<"AiError", {
+    readonly reason: Schema.Literals<readonly ["generation", "decode"]>;
+    readonly message: Schema.String;
+    readonly evidence: Schema.optional<Schema.Struct<{
+        readonly provider: Schema.String;
+        readonly model: Schema.String;
+        readonly usage: Schema.Struct<{
+            readonly inputTokens: Schema.optional<Schema.Number>;
+            readonly outputTokens: Schema.optional<Schema.Number>;
+            readonly totalTokens: Schema.optional<Schema.Number>;
+            readonly completeness: Schema.Literals<readonly ["complete", "partial", "unknown"]>;
         }>;
-        cost: Schema.Union<[Schema.Struct<{
-            status: Schema.Literal<["actual"]>;
-            source: Schema.Literal<["gateway"]>;
-            usd: Schema.filter<Schema.filter<typeof Schema.Number>>;
+        readonly cost: Schema.Union<readonly [Schema.Struct<{
+            readonly status: Schema.Literal<"actual">;
+            readonly source: Schema.Literal<"gateway">;
+            readonly usd: Schema.Number;
         }>, Schema.Struct<{
-            status: Schema.Literal<["unknown"]>;
-            source: Schema.Literal<["unreported"]>;
+            readonly status: Schema.Literal<"unknown">;
+            readonly source: Schema.Literal<"unreported">;
         }>]>;
     }>>;
-}>;
+}>, YieldableError>;
 
 /**
  * The one way a CAUGHT provider failure becomes an `AiError`.
@@ -495,7 +480,7 @@ export declare type AiProviderOptions = Record<string, Record<string, AiJsonValu
 export declare class AiService extends AiService_base {
 }
 
-declare const AiService_base: Context.TagClass<AiService, "@voltro/AiService", AiServiceImpl>;
+declare const AiService_base: Context.ServiceClass<AiService, "@voltro/AiService", AiServiceImpl>;
 
 export declare interface AiServiceImpl {
     readonly generateText: (options: GenerateTextOptions) => Effect.Effect<GenerateTextResult, AiError>;
@@ -618,10 +603,10 @@ export declare const aiUsageTable: Table<typeof AI_USAGE_TABLE, Record<string, C
 export declare type AnthropicModel = 'claude-opus-4-8' | 'claude-sonnet-4-6' | 'claude-haiku-4-5-20251001' | (string & {});
 
 /** A descriptor of any input shape — for the type-erased runtime helpers. */
-export declare type AnyAgentDescriptor = AgentDescriptor<Schema.Schema.Any>;
+export declare type AnyAgentDescriptor = AgentDescriptor<Schema.Top>;
 
 /** An executor of any input shape — for the type-erased runtime helpers. */
-export declare type AnyAgentExecutor = AgentExecutor<Schema.Schema.Any>;
+export declare type AnyAgentExecutor = AgentExecutor<Schema.Top>;
 
 /** A heterogeneous tool — the shape `buildSdkTools` / `runAssistant` consume.
  *  `defineTool` keeps full input typing on its `execute`/`handler` body, then
@@ -631,13 +616,15 @@ export declare type AnyAgentExecutor = AgentExecutor<Schema.Schema.Any>;
 export declare interface AnyTool {
     readonly name: string;
     readonly description: string;
-    readonly input: Schema.Schema.Any;
+    readonly input: Schema.Top;
     /** See `ToolDef.inputJsonSchema` — a foreign parameter schema shown to the
      *  model in place of a rendered `input`. */
     readonly inputJsonSchema?: Record<string, unknown>;
-    readonly output?: Schema.Schema.Any;
+    readonly output?: Schema.Top;
     readonly execute?: (input: never) => Effect.Effect<unknown, never, unknown>;
     readonly handler?: ToolHandler<never, unknown>;
+    /** Client tools return a pending call to the caller; never run on the server. */
+    readonly execution?: 'server' | 'client';
     readonly timeoutMs?: number;
 }
 
@@ -726,8 +713,8 @@ export declare const appToolDecision: (descriptor: AppToolDescriptor, policy: Ap
 export declare interface AppToolDescriptor {
     readonly kind: 'query' | 'mutation' | 'action' | string;
     readonly name: string;
-    readonly input: Schema.Schema.Any;
-    readonly output?: Schema.Schema.Any;
+    readonly input: Schema.Top;
+    readonly output?: Schema.Top;
     readonly exposeAsTool?: ExposeAsToolLike;
     /**
      * Presence of the descriptor's `requiresApproval:` policy — read as a BOOLEAN
@@ -840,6 +827,9 @@ export declare interface ConsumeOptions {
     readonly fromSeq?: number;
     /** Tail poll interval in ms while the producer is still running (default 50). */
     readonly pollMs?: number;
+    /** Maximum idle polling interval. Default 1000ms. Local persisted appends
+     * wake consumers immediately; remote replicas are observed by polling. */
+    readonly maxPollMs?: number;
     /** End the consumer if no new event arrives for this long AND the producer
      *  hasn't finished — a safety valve against a crashed producer that never
      *  marked done. Default: undefined (wait indefinitely). */
@@ -890,21 +880,21 @@ export declare interface CopilotProposal {
  *  `generateObject({ schema: CopilotProposalSchema })`). Mirrors
  *  {@link CopilotProposal}. */
 export declare const CopilotProposalSchema: Schema.Struct<{
-    table: typeof Schema.String;
-    columns: Schema.optional<Schema.Array$<typeof Schema.String>>;
-    filters: Schema.optional<Schema.Array$<Schema.Struct<{
-        column: typeof Schema.String;
-        op: Schema.Literal<["eq", "neq", "gt", "gte", "lt", "lte", "contains", "in"]>;
-        value: typeof Schema.Unknown;
+    readonly table: Schema.String;
+    readonly columns: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly filters: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly column: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq", "gt", "gte", "lt", "lte", "contains", "in"]>;
+        readonly value: Schema.Unknown;
     }>>>;
-    orderBy: Schema.optional<Schema.Struct<{
-        column: typeof Schema.String;
-        direction: Schema.optional<Schema.Literal<["asc", "desc"]>>;
+    readonly orderBy: Schema.optional<Schema.Struct<{
+        readonly column: Schema.String;
+        readonly direction: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
     }>>;
-    limit: Schema.optional<typeof Schema.Number>;
-    aggregate: Schema.optional<Schema.Struct<{
-        fn: Schema.Literal<["count", "sum", "avg", "min", "max"]>;
-        column: Schema.optional<typeof Schema.String>;
+    readonly limit: Schema.optional<Schema.Number>;
+    readonly aggregate: Schema.optional<Schema.Struct<{
+        readonly fn: Schema.Literals<readonly ["count", "sum", "avg", "min", "max"]>;
+        readonly column: Schema.optional<Schema.String>;
     }>>;
 }>;
 
@@ -913,12 +903,10 @@ export declare const CopilotProposalSchema: Schema.Struct<{
 export declare class CopilotRejected extends CopilotRejected_base {
 }
 
-declare const CopilotRejected_base: Schema.TaggedErrorClass<CopilotRejected, "CopilotRejected", {
-    readonly _tag: Schema.tag<"CopilotRejected">;
-} & {
-    reason: Schema.Literal<["unknown-table", "unknown-column", "bad-op", "bad-aggregate", "empty"]>;
-    detail: typeof Schema.String;
-}>;
+declare const CopilotRejected_base: Schema.Class<CopilotRejected, Schema.TaggedStruct<"CopilotRejected", {
+    readonly reason: Schema.Literals<readonly ["unknown-table", "unknown-column", "bad-op", "bad-aggregate", "empty"]>;
+    readonly detail: Schema.String;
+}>, YieldableError>;
 
 export declare interface CopilotSchema {
     readonly tables: ReadonlyArray<CopilotSchemaTable>;
@@ -1054,7 +1042,7 @@ export declare const DEFAULT_INFERENCE_POLL_MS = 250;
 export declare const DEFAULT_INFERENCE_RETENTION_HOURS: number;
 
 declare const DEFAULT_INPUT: Schema.Struct<{
-    prompt: typeof Schema.String;
+    readonly prompt: Schema.String;
 }>;
 
 /** The default judge threshold when a judge is configured without one. */
@@ -1101,7 +1089,7 @@ export { defaultSettingsMiddleware }
  * })
  * ```
  */
-export declare const defineAgent: <S extends Schema.Schema.Any = DefaultAgentInputSchema>(config: {
+export declare const defineAgent: <S extends Schema.Top = DefaultAgentInputSchema>(config: {
     readonly name: string;
     readonly input?: S;
 } & AgentAccessOptions) => AgentDescriptor<S>;
@@ -1123,7 +1111,7 @@ export declare const defineAgent: <S extends Schema.Schema.Any = DefaultAgentInp
  * })
  * ```
  */
-export declare const defineAgentExecutor: <S extends Schema.Schema.Any = DefaultAgentInputSchema>(descriptor: AgentDescriptor<S>, config: AgentExecutorConfig<AgentInput<S>>) => AgentExecutor<S>;
+export declare const defineAgentExecutor: <S extends Schema.Top = DefaultAgentInputSchema>(descriptor: AgentDescriptor<S>, config: AgentExecutorConfig<AgentInput<S>>) => AgentExecutor<S>;
 
 export declare interface DefinedPrompt extends PromptDefinition {
     /** Content digest of `template` + `system`. The version. */
@@ -1185,11 +1173,13 @@ export declare const defineRealtimeSession: (options: RealtimeSessionOptions) =>
 export declare const defineTool: <A, I, O>(def: {
     readonly name: string;
     readonly description: string;
-    readonly input: Schema.Schema<A, I>;
+    readonly input: Schema.Codec<A, I>;
     readonly inputJsonSchema?: Record<string, unknown>;
-    readonly output?: Schema.Schema.Any;
+    readonly output?: Schema.Top;
     readonly execute?: (input: A) => Effect.Effect<O, never, unknown>;
     readonly handler?: ToolHandler<A, O>;
+    /** Client tools return a pending call to the caller; never run on the server. */
+    readonly execution?: "server" | "client";
     readonly timeoutMs?: number;
 }) => AnyTool;
 
@@ -1630,7 +1620,7 @@ export declare interface GenerateObjectOptions<A, I> {
     /** Effect Schema the model output must satisfy. Converted to JSON
      *  Schema for the SDK, then decoded back through this schema so the
      *  result carries branded types + refinements (not just JSON shape). */
-    readonly schema: Schema.Schema<A, I>;
+    readonly schema: Schema.Codec<A, I>;
     readonly prompt: string;
     readonly system?: string;
     readonly provider?: ProviderConfig;
@@ -1683,7 +1673,7 @@ export declare interface GenerateObjectWithToolsOptions<A, I> {
     /** Effect Schema the FINAL object must satisfy. The model runs the tool
      *  loop, then emits one object matching this schema; it is decoded back
      *  through the schema so refinements/brands hold. */
-    readonly schema: Schema.Schema<A, I>;
+    readonly schema: Schema.Codec<A, I>;
     readonly prompt: string;
     readonly system?: string;
     readonly provider?: ProviderConfig;
@@ -2205,14 +2195,12 @@ export declare const mcpCallTool: (transport: McpTransport, server: string, tool
 export declare class McpError extends McpError_base {
 }
 
-declare const McpError_base: Schema.TaggedErrorClass<McpError, "McpError", {
-    readonly _tag: Schema.tag<"McpError">;
-} & {
+declare const McpError_base: Schema.Class<McpError, Schema.TaggedStruct<"McpError", {
     /** The app-chosen namespace of the server, never a server-supplied string. */
-    server: typeof Schema.String;
-    reason: Schema.Literal<["transport", "protocol", "bounds", "policy"]>;
-    message: typeof Schema.String;
-}>;
+    readonly server: Schema.String;
+    readonly reason: Schema.Literals<readonly ["transport", "protocol", "bounds", "policy"]>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** The MCP handshake: `initialize`, then the `notifications/initialized` the
  *  spec requires before any other request. */
@@ -2498,13 +2486,22 @@ export declare interface MediaUsage {
     readonly totalTokens: number | undefined;
 }
 
-/**
- * Single-process resumable-stream store. Holds each stream's log in memory —
- * perfect for dev, tests, and single-node self-host. A multi-node deployment
- * needs `dataStoreResumableStreamStore` (or a Redis backend) so every node
- * shares the log and the producer election.
- */
-export declare const memoryResumableStreamStore: () => ResumableStreamStore;
+export declare interface MemoryResumableStreamOptions {
+    /** Completed payload retention. Default seven days; active readers defer eviction. */
+    readonly retentionMs?: number;
+    /** Clock for retention; defaults to Date.now. */
+    readonly now?: () => number;
+}
+
+export declare interface MemoryResumableStreamStore extends ResumableStreamStore {
+    /** Release payloads and election tombstones at the end of the owner's lifetime.
+     * Stop producers/consumers first. A disposed store cannot be reused. */
+    readonly dispose: Effect.Effect<void>;
+}
+
+/** Single-process store. Completed payloads expire; election tombstones remain
+ * until dispose so an expired replay cannot start a second paid producer. */
+export declare const memoryResumableStreamStore: (opts?: MemoryResumableStreamOptions) => MemoryResumableStreamStore;
 
 export declare type MessagePart = {
     readonly type: 'text';
@@ -2513,6 +2510,7 @@ export declare type MessagePart = {
     readonly type: 'tool';
     readonly toolCallId: string;
     readonly toolName: string;
+    readonly execution?: 'client';
     /** 'input-available' once the model emitted args; 'output-available' once the tool ran. */
     readonly state: 'input-available' | 'output-available' | 'output-error';
     readonly input?: unknown;
@@ -2715,7 +2713,7 @@ export declare type OpenAIModel = 'gpt-5.5' | 'gpt-4o' | 'gpt-4o-mini' | (string
 /** The JSON Schema a `generateObject` output schema renders to. Exported
  *  because an OFFLOADED inference has to store it: a JavaScript Schema object
  *  cannot be journaled, and its JSON rendering can. */
-export declare const outputJsonSchema: (schema: Schema.Schema.Any, fn: string) => Effect.Effect<Record<string, unknown>, AiError>;
+export declare const outputJsonSchema: (schema: Schema.Top, fn: string) => Effect.Effect<Record<string, unknown>, AiError>;
 
 /**
  * Pull the first JSON-RPC message out of a Streamable-HTTP response body.
@@ -2786,13 +2784,11 @@ export declare const promptDigest: (prompt: string) => string;
 export declare class PromptRenderError extends PromptRenderError_base {
 }
 
-declare const PromptRenderError_base: Schema.TaggedErrorClass<PromptRenderError, "PromptRenderError", {
-    readonly _tag: Schema.tag<"PromptRenderError">;
-} & {
-    promptId: typeof Schema.String;
-    missing: Schema.Array$<typeof Schema.String>;
-    message: typeof Schema.String;
-}>;
+declare const PromptRenderError_base: Schema.Class<PromptRenderError, Schema.TaggedStruct<"PromptRenderError", {
+    readonly promptId: Schema.String;
+    readonly missing: Schema.$Array<Schema.String>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 export declare const PROMPTS_TABLE = "_voltro_prompts";
 
@@ -3072,81 +3068,81 @@ export declare interface ReadRecorder<S extends QueryableStore> {
 
 /** Browser-safe input allowlist. Session configuration and provider credentials
  * belong to the server, never to events received from the browser. */
-export declare const RealtimeClientEvent: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["input-audio-append"]>;
-    audio: Schema.filter<typeof Schema.String>;
+export declare const RealtimeClientEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"input-audio-append">;
+    readonly audio: Schema.String;
 }>, Schema.Struct<{
-    type: Schema.Literal<["input-audio-commit", "input-audio-clear", "response-create", "response-cancel"]>;
+    readonly type: Schema.Literals<readonly ["input-audio-commit", "input-audio-clear", "response-create", "response-cancel"]>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["conversation-item-create"]>;
-    item: Schema.Struct<{
-        type: Schema.Literal<["text-message"]>;
-        role: Schema.Literal<["user"]>;
-        text: typeof Schema.String;
+    readonly type: Schema.Literal<"conversation-item-create">;
+    readonly item: Schema.Struct<{
+        readonly type: Schema.Literal<"text-message">;
+        readonly role: Schema.Literal<"user">;
+        readonly text: Schema.String;
     }>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["conversation-item-truncate"]>;
-    itemId: typeof Schema.String;
-    contentIndex: Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>;
-    audioEndMs: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    readonly type: Schema.Literal<"conversation-item-truncate">;
+    readonly itemId: Schema.String;
+    readonly contentIndex: Schema.Number;
+    readonly audioEndMs: Schema.Number;
 }>]>;
 
 export declare type RealtimeClientEvent = typeof RealtimeClientEvent.Type;
 
 /** Safe, normalized server events. No raw provider payload, client secret,
  * arbitrary conversation item or provider error message crosses this surface. */
-export declare const RealtimeServerEvent: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["ready"]>;
+export declare const RealtimeServerEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"ready">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["session-created"]>;
-    sessionId: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literal<"session-created">;
+    readonly sessionId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["session-updated"]>;
+    readonly type: Schema.Literal<"session-updated">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["speech-started", "speech-stopped"]>;
-    itemId: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literals<readonly ["speech-started", "speech-stopped"]>;
+    readonly itemId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["audio-committed"]>;
-    itemId: Schema.optional<typeof Schema.String>;
-    previousItemId: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literal<"audio-committed">;
+    readonly itemId: Schema.optional<Schema.String>;
+    readonly previousItemId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    itemId: typeof Schema.String;
-    type: Schema.Literal<["conversation-item-added"]>;
+    readonly itemId: Schema.String;
+    readonly type: Schema.Literal<"conversation-item-added">;
 }>, Schema.Struct<{
-    transcript: typeof Schema.String;
-    itemId: typeof Schema.String;
-    type: Schema.Literal<["input-transcription-completed"]>;
+    readonly transcript: Schema.String;
+    readonly itemId: Schema.String;
+    readonly type: Schema.Literal<"input-transcription-completed">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["response-created"]>;
-    responseId: typeof Schema.String;
+    readonly type: Schema.Literal<"response-created">;
+    readonly responseId: Schema.String;
 }>, Schema.Struct<{
-    type: Schema.Literal<["response-done"]>;
-    responseId: typeof Schema.String;
-    status: typeof Schema.String;
+    readonly type: Schema.Literal<"response-done">;
+    readonly responseId: Schema.String;
+    readonly status: Schema.String;
 }>, Schema.Struct<{
-    itemId: typeof Schema.String;
-    responseId: typeof Schema.String;
-    type: Schema.Literal<["output-item-added", "output-item-done", "content-part-added", "content-part-done", "audio-done"]>;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literals<readonly ["output-item-added", "output-item-done", "content-part-added", "content-part-done", "audio-done"]>;
 }>, Schema.Struct<{
-    delta: Schema.filter<typeof Schema.String>;
-    itemId: typeof Schema.String;
-    responseId: typeof Schema.String;
-    type: Schema.Literal<["audio-delta"]>;
+    readonly delta: Schema.String;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literal<"audio-delta">;
 }>, Schema.Struct<{
-    delta: typeof Schema.String;
-    itemId: typeof Schema.String;
-    responseId: typeof Schema.String;
-    type: Schema.Literal<["text-delta", "audio-transcript-delta"]>;
+    readonly delta: Schema.String;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literals<readonly ["text-delta", "audio-transcript-delta"]>;
 }>, Schema.Struct<{
-    text: Schema.optional<typeof Schema.String>;
-    itemId: typeof Schema.String;
-    responseId: typeof Schema.String;
-    type: Schema.Literal<["text-done"]>;
+    readonly text: Schema.optional<Schema.String>;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literal<"text-done">;
 }>, Schema.Struct<{
-    transcript: Schema.optional<typeof Schema.String>;
-    itemId: typeof Schema.String;
-    responseId: typeof Schema.String;
-    type: Schema.Literal<["audio-transcript-done"]>;
+    readonly transcript: Schema.optional<Schema.String>;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literal<"audio-transcript-done">;
 }>]>;
 
 export declare type RealtimeServerEvent = typeof RealtimeServerEvent.Type;
@@ -3221,10 +3217,10 @@ export declare const recordReads: <S extends QueryableStore>(store: S) => ReadRe
 /**
  * Redis-backed resumable-stream store — the production "resumable via
  * Redis-Replay" path. The append-only log is a Redis LIST per `streamId`
- * (`RPUSH` to append, `LRANGE afterSeq -1` to read the tail past a cursor — the
- * list index lines up with the 1-based `seq` because exactly ONE producer
- * appends, elected by `claimProducer` = `SET … NX`). Multi-node correct + the
- * fastest backend; TTL (default 1h) evicts finished/abandoned streams without a
+ * (`RPUSH` to append, bounded `LRANGE` pages to read past a verified cursor;
+ * failed writes leaving sequence holes fall back to paged filtering). Exactly
+ * ONE producer appends, elected by `claimProducer` = `SET … NX`. TTL (default
+ * 1h) evicts finished/abandoned streams without a
  * sweep. A drop-in for `dataStoreResumableStreamStore` against the same
  * `ResumableStreamStore` interface.
  */
@@ -3518,6 +3514,7 @@ export declare interface ResumableStreamOptions {
     /** Replay events past this `seq` before tailing (a reconnect cursor). */
     readonly fromSeq?: number;
     readonly pollMs?: number;
+    readonly maxPollMs?: number;
     readonly idleTimeoutMs?: number;
 }
 
@@ -3537,8 +3534,10 @@ export declare interface ResumableStreamStore {
     readonly claimProducer: (streamId: string) => Effect.Effect<boolean>;
     /** Append one event at its `seq`. Producer-only. */
     readonly append: (streamId: string, ev: SeqEvent) => Effect.Effect<void>;
+    /** Persist a source chunk in bounded bulk operations when supported. */
+    readonly appendMany?: (streamId: string, events: ReadonlyArray<SeqEvent>) => Effect.Effect<void>;
     /** Persisted events with `seq > afterSeq`, ascending. */
-    readonly read: (streamId: string, afterSeq: number) => Effect.Effect<ReadonlyArray<SeqEvent>>;
+    readonly read: (streamId: string, afterSeq: number, limit?: number) => Effect.Effect<ReadonlyArray<SeqEvent>>;
     /** Mark the stream complete — the producer reached a terminal event. */
     readonly markDone: (streamId: string) => Effect.Effect<void>;
     /** Whether the producer has finished (all events are persisted). */
@@ -3553,6 +3552,7 @@ export declare const resumableStreamText: (args: {
     readonly options: StreamTextOptions;
     readonly fromSeq?: number;
     readonly pollMs?: number;
+    readonly maxPollMs?: number;
     readonly idleTimeoutMs?: number;
 }) => Stream.Stream<SeqEvent>;
 
@@ -3808,60 +3808,62 @@ export declare interface SemanticUsage {
  * client bundle.
  */
 export declare const SeqEvent: Schema.Struct<{
-    seq: typeof Schema.Number;
-    event: Schema.Union<[Schema.Struct<{
-        _tag: Schema.Literal<["token"]>;
-        text: typeof Schema.String;
+    readonly seq: Schema.Number;
+    readonly event: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"token">;
+        readonly text: Schema.String;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["reasoning"]>;
-        text: typeof Schema.String;
+        readonly _tag: Schema.Literal<"reasoning">;
+        readonly text: Schema.String;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["toolCall"]>;
-        id: typeof Schema.String;
-        name: typeof Schema.String;
-        input: typeof Schema.Unknown;
+        readonly _tag: Schema.Literal<"toolCall">;
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly input: Schema.Unknown;
+        /** Present when the caller must execute this pending call. */
+        readonly execution: Schema.optional<Schema.Literal<"client">>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["toolResult"]>;
-        id: typeof Schema.String;
-        name: typeof Schema.String;
-        output: Schema.optional<typeof Schema.Unknown>;
-        error: Schema.optional<typeof Schema.String>;
+        readonly _tag: Schema.Literal<"toolResult">;
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly output: Schema.optional<Schema.Unknown>;
+        readonly error: Schema.optional<Schema.String>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["source"]>;
-        sourceType: Schema.Literal<["url", "document"]>;
-        id: typeof Schema.String;
-        url: Schema.optional<typeof Schema.String>;
-        title: Schema.optional<typeof Schema.String>;
-        mediaType: Schema.optional<typeof Schema.String>;
-        filename: Schema.optional<typeof Schema.String>;
+        readonly _tag: Schema.Literal<"source">;
+        readonly sourceType: Schema.Literals<readonly ["url", "document"]>;
+        readonly id: Schema.String;
+        readonly url: Schema.optional<Schema.String>;
+        readonly title: Schema.optional<Schema.String>;
+        readonly mediaType: Schema.optional<Schema.String>;
+        readonly filename: Schema.optional<Schema.String>;
         /** Provider-owned citation attribution; not normalized or interpreted. */
-        providerMetadata: Schema.optional<typeof Schema.Unknown>;
+        readonly providerMetadata: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["file"]>;
-        mediaType: typeof Schema.String;
-        data: typeof Schema.String;
+        readonly _tag: Schema.Literal<"file">;
+        readonly mediaType: Schema.String;
+        readonly data: Schema.String;
         /** Metadata for this file, not the whole model step. */
-        providerMetadata: Schema.optional<typeof Schema.Unknown>;
+        readonly providerMetadata: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["stepMetadata"]>;
-        step: Schema.filter<typeof Schema.Int>;
-        providerMetadata: typeof Schema.Unknown;
+        readonly _tag: Schema.Literal<"stepMetadata">;
+        readonly step: Schema.Int;
+        readonly providerMetadata: Schema.Unknown;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["message"]>;
-        role: typeof Schema.String;
-        content: typeof Schema.String;
+        readonly _tag: Schema.Literal<"message">;
+        readonly role: Schema.String;
+        readonly content: Schema.String;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["error"]>;
-        code: Schema.Literal<["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
-        message: typeof Schema.String;
-        retryable: typeof Schema.Boolean;
+        readonly _tag: Schema.Literal<"error">;
+        readonly code: Schema.Literals<readonly ["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
+        readonly message: Schema.String;
+        readonly retryable: Schema.Boolean;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["done"]>;
-        finishReason: typeof Schema.String;
-        usage: Schema.Struct<{
-            inputTokens: Schema.optional<typeof Schema.Number>;
-            outputTokens: Schema.optional<typeof Schema.Number>;
-            totalTokens: Schema.optional<typeof Schema.Number>;
+        readonly _tag: Schema.Literal<"done">;
+        readonly finishReason: Schema.String;
+        readonly usage: Schema.Struct<{
+            readonly inputTokens: Schema.optional<Schema.Number>;
+            readonly outputTokens: Schema.optional<Schema.Number>;
+            readonly totalTokens: Schema.optional<Schema.Number>;
         }>;
     }>]>;
 }>;
@@ -4144,18 +4146,18 @@ export declare const toModelInfo: (e: GatewayLanguageModelEntry) => GatewayModel
  *  CLI discovery path passes the real `AppContext`, which is a superset.
  *
  *  `runtime` is the caller's ambient Effect `Runtime`. When present, tool
- *  bodies are run through it (`Runtime.runPromise(runtime)(eff)`) instead of
+ *  bodies are run through it (`Effect.runPromiseWith(runtime)(eff)`) instead of
  *  bare `Effect.runPromise`, so a body may `yield*` any service the caller's
  *  runtime carries — `JiraService`, the data store layer, `HttpClient`, … —
  *  rather than being limited to `R = never`. The agent loop
- *  (`streamText`/`runAssistant`) captures `yield* Effect.runtime()` and threads
+ *  (`streamText`/`runAssistant`) captures `yield* Effect.context<never>()` and threads
  *  it here; without a runtime, behaviour is unchanged. */
 export declare interface ToolContext {
     readonly store: unknown;
     readonly request?: {
         readonly subject?: unknown;
     };
-    readonly runtime?: Runtime.Runtime<unknown>;
+    readonly runtime?: Context.Context<never>;
     /** SDK tool-call identity for this execution, not a durable application idempotency key. */
     readonly invocationId?: string;
     /** Cancellation from either the caller's turn or SDK invocation; Promise handlers must pass it to their I/O. */
@@ -4165,7 +4167,7 @@ export declare interface ToolContext {
 export declare interface ToolDef<A, I, O> {
     readonly name: string;
     readonly description: string;
-    readonly input: Schema.Schema<A, I>;
+    readonly input: Schema.Codec<A, I>;
     /**
      * A ready-made JSON Schema for the tool's parameters, used INSTEAD of
      * rendering `input`.
@@ -4180,13 +4182,15 @@ export declare interface ToolDef<A, I, O> {
     readonly inputJsonSchema?: Record<string, unknown>;
     /** Optional result schema. When set, `buildSdkTools` decodes the body's
      *  output through it before handing the value back to the model. */
-    readonly output?: Schema.Schema.Any;
+    readonly output?: Schema.Top;
     /** Inline body: returns an Effect. May declare service deps on the R
      *  channel — they are provided by the caller's runtime
      *  (`ctx.runtime`) at execution time. */
     readonly execute?: (input: A) => Effect.Effect<O, never, unknown>;
     /** File-convention body: receives `ctx`, returns Effect or Promise. */
     readonly handler?: ToolHandler<A, O>;
+    /** Client tools return a pending call to the caller; never run on the server. */
+    readonly execution?: 'server' | 'client';
     /** Per-call deadline; the tool fails with a timeout error past it. */
     readonly timeoutMs?: number;
 }
@@ -4299,42 +4303,40 @@ export declare type TranscriptionSource =
 export declare class TranscriptionStreamError extends TranscriptionStreamError_base {
 }
 
-declare const TranscriptionStreamError_base: Schema.TaggedErrorClass<TranscriptionStreamError, "TranscriptionStreamError", {
-    readonly _tag: Schema.tag<"TranscriptionStreamError">;
-} & {
-    reason: Schema.Literal<["input", "unsupported", "provider", "cancelled"]>;
-    message: typeof Schema.String;
-}>;
+declare const TranscriptionStreamError_base: Schema.Class<TranscriptionStreamError, Schema.TaggedStruct<"TranscriptionStreamError", {
+    readonly reason: Schema.Literals<readonly ["input", "unsupported", "provider", "cancelled"]>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** Partial text is replaceable, delta text is append-only, and final text seals a segment. */
-export declare const TranscriptionStreamEvent: Schema.Union<[Schema.Struct<{
-    delta: typeof Schema.String;
-    id: Schema.optional<typeof Schema.String>;
-    type: Schema.Literal<["transcript-delta"]>;
+export declare const TranscriptionStreamEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly delta: Schema.String;
+    readonly id: Schema.optional<Schema.String>;
+    readonly type: Schema.Literal<"transcript-delta">;
 }>, Schema.Struct<{
-    text: typeof Schema.String;
-    startSecond: Schema.optional<typeof Schema.Number>;
-    durationInSeconds: Schema.optional<typeof Schema.Number>;
-    channelIndex: Schema.optional<typeof Schema.Number>;
-    id: Schema.optional<typeof Schema.String>;
-    type: Schema.Literal<["transcript-partial"]>;
+    readonly text: Schema.String;
+    readonly startSecond: Schema.optional<Schema.Number>;
+    readonly durationInSeconds: Schema.optional<Schema.Number>;
+    readonly channelIndex: Schema.optional<Schema.Number>;
+    readonly id: Schema.optional<Schema.String>;
+    readonly type: Schema.Literal<"transcript-partial">;
 }>, Schema.Struct<{
-    text: typeof Schema.String;
-    startSecond: Schema.optional<typeof Schema.Number>;
-    endSecond: Schema.optional<typeof Schema.Number>;
-    channelIndex: Schema.optional<typeof Schema.Number>;
-    id: Schema.optional<typeof Schema.String>;
-    type: Schema.Literal<["transcript-final"]>;
+    readonly text: Schema.String;
+    readonly startSecond: Schema.optional<Schema.Number>;
+    readonly endSecond: Schema.optional<Schema.Number>;
+    readonly channelIndex: Schema.optional<Schema.Number>;
+    readonly id: Schema.optional<Schema.String>;
+    readonly type: Schema.Literal<"transcript-final">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["finish"]>;
-    text: typeof Schema.String;
-    segments: Schema.Array$<Schema.Struct<{
-        text: typeof Schema.String;
-        start: typeof Schema.Number;
-        end: typeof Schema.Number;
+    readonly type: Schema.Literal<"finish">;
+    readonly text: Schema.String;
+    readonly segments: Schema.$Array<Schema.Struct<{
+        readonly text: Schema.String;
+        readonly start: Schema.Number;
+        readonly end: Schema.Number;
     }>>;
-    language: Schema.optional<typeof Schema.String>;
-    durationSec: Schema.optional<typeof Schema.Number>;
+    readonly language: Schema.optional<Schema.String>;
+    readonly durationSec: Schema.optional<Schema.Number>;
 }>]>;
 
 export declare type TranscriptionStreamEvent = typeof TranscriptionStreamEvent.Type;