@yielded/agent-platform-cloudflare 0.1.0-beta.166 → 0.1.0-beta.168

package/dist/CloudflareThreadClient-QsVzLGGZ.d.mts

@@ -0,0 +1,2033 @@
+import { ThreadObjectNamespace, ThreadObjectRpc } from "./CloudflareBindings.mjs";
+import { t as AdmissionLimitExceeded } from "./CloudflareConfig-C9MvPbX8.mjs";
+import { DurableAlarmError } from "./Alarm.mjs";
+import { DurableSubmitAgent, DurableSubmitOptions, Receipt } from "@yielded/agent/durable-agent-runtime";
+import { ThreadId } from "@yielded/agent/identifiers";
+import { AbortCommand, AbortIntent, AdmissionConflict, AdmissionPolicyError, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, JoinedToHost, LedgerError, OwnershipLost, Settlement, SettlementConflict, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent } from "@yielded/agent/submission-ledger";
+import { Context, Crypto, Effect, Layer, Schema, Stream } from "effect";
+import { CanonicalRecordEnvelope, CanonicalSequence, DefinitionDigests, SubmissionSettledRecord } from "@yielded/agent/records";
+import { AgentInputError } from "@yielded/agent/agent-error";
+import { DigestError } from "@yielded/agent/digest";
+import { DurableRuntimeFailpointError } from "@yielded/agent/durable-failpoint";
+import { OperationDenied } from "@yielded/agent/operation-authorizer";
+import { SubmissionStatus } from "@yielded/agent/submission-status";
+import { AppendConflict, ThreadNotMaterialized, ThreadStoreError } from "@yielded/agent/thread-store";
+import { Event } from "@yielded/agent/provisional-text";
+//#region src/internal/live-text-protocol.d.ts
+/**
+ * Reset replaces all drafts with a snapshot, streamed as native Text parts before live deltas.
+ * Each snapshot starts a fresh streamId. Its sequences are unrelated to canonical sequences.
+ */
+declare const Frame: Schema.Union<readonly [Schema.TaggedStruct<"Reset", {
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly streamId: Schema.NonEmptyString;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly sequence: Schema.Literal<0>;
+}>, Schema.TaggedStruct<"Event", {
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly streamId: Schema.NonEmptyString;
+  readonly sequence: Schema.Int;
+  readonly event: Schema.Union<readonly [Schema.TaggedStruct<"Text", {
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+    readonly attemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+    readonly generation: Schema.Int;
+    readonly part: Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.tag<"text-start">;
+      readonly id: Schema.String;
+      readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+      readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+    }>, Schema.Struct<{
+      readonly type: Schema.tag<"text-delta">;
+      readonly id: Schema.String;
+      readonly delta: Schema.String;
+      readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+      readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+    }>, Schema.Struct<{
+      readonly type: Schema.tag<"text-end">;
+      readonly id: Schema.String;
+      readonly "~effect/ai/Response/Part": Schema.withDecodingDefaultKey<Schema.tag<"~effect/ai/Response/Part">>;
+      readonly metadata: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.Codec<Schema.Json>>>;
+    }>]>;
+  }>, Schema.TaggedStruct<"Discard", {
+    threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+    attemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+    runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+    generation: Schema.Int;
+  }>, Schema.TaggedStruct<"AttemptEnded", {
+    threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+    attemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+  }>]>;
+}>]>;
+type Frame = typeof Frame.Type;
+declare namespace CloudflareThreadClient_d_exports {
+  export { AbortRecorded, ApprovalRecorded, AwaitProgressRequest, CancelProgressRequest, ClientAbortFailure, ClientApprovalFailure, ClientAwaitFailure, ClientObserveFailure, ClientProgressFailure, ClientSubmitFailure, ClientUnknownFailure, CloudflareThreadClient, HostFailed, HostFailure, HostProtocolError, HostResponse, Frame as LiveTextFrame, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, SettlementReached, SettlementRecordReached, SubmissionStatusResponse, SubmitRequest, SubmitSucceeded, ThreadClientError, UnknownResolutionRecorded, boundHostDiagnostic, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand };
+}
+/** Truncate a diagnostic string to the host protocol's bounded length. */
+declare const boundHostDiagnostic: (value: string) => string;
+declare const HostProtocolError_base: Schema.Class<HostProtocolError, Schema.TaggedStruct<"HostProtocolError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The envelope itself could not be honored: the Object could not decode the request, or a
+ * response could not be encoded/decoded. Never carries operation semantics.
+ */
+declare class HostProtocolError extends HostProtocolError_base {}
+declare const ThreadClientError_base: Schema.Class<ThreadClientError, Schema.TaggedStruct<"ThreadClientError", {
+  readonly threadId: Schema.String;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+  /** Cloudflare's own classification for a failure safe to retry with a fresh stub. */
+  readonly retryable: Schema.optionalKey<Schema.Boolean>;
+  /** Cloudflare overloads are surfaced immediately instead of adding retry pressure. */
+  readonly overloaded: Schema.optionalKey<Schema.Boolean>;
+}>, import("effect/Cause").YieldableError>;
+/** The Worker-side stub call itself failed (RPC rejection, overload, eviction mid-call). */
+declare class ThreadClientError extends ThreadClientError_base {}
+declare const SubmitRequest_base: Schema.Class<SubmitRequest, Schema.Struct<{
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+  readonly idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly admissionGroup: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly admissionFence: Schema.optionalKey<Schema.Struct<{
+    readonly policyId: Schema.NonEmptyString;
+    readonly key: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>>;
+  readonly workerAdmission: Schema.optionalKey<Schema.Struct<{
+    readonly origin: Schema.Struct<{
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"tool">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+        readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+      }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"programmatic">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>]>;
+      readonly continuationOf: Schema.optionalKey<Schema.Struct<{
+        readonly worker: Schema.Struct<{
+          readonly schemaVersion: Schema.Literal<1>;
+          readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+          readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+          readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        }>;
+        readonly receipt: typeof Receipt;
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      }>>;
+      readonly budgetScope: Schema.Literals<readonly ["source-subtree", "worker-run"]>;
+      readonly lifecycle: Schema.optionalKey<Schema.Literal<"assignment">>;
+      readonly targetDigests: typeof DefinitionDigests;
+      readonly policy: Schema.toCodecJson<typeof import("@yielded/agent/agent-policy").AgentPolicy>;
+      readonly budget: Schema.Struct<{
+        readonly caps: typeof import("@yielded/agent/subagent-contract").SubagentDelegationCaps;
+        readonly allocation: typeof import("@yielded/agent/subagent-contract").SubagentReservationAmounts;
+        readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+      }>;
+      readonly grant: typeof import("@yielded/agent/subagent-contract").SubagentGrant;
+      readonly depth: Schema.Int;
+      readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+      readonly firstMessageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      readonly createdAtMillis: Schema.Natural;
+      readonly expiresAtMillis: Schema.Natural;
+      readonly reporting: Schema.optionalKey<Schema.Struct<{
+        readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+        readonly sourceDigests: typeof DefinitionDigests;
+        readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+        readonly returnAddress: Schema.optionalKey<Schema.Struct<{
+          readonly input: Schema.declare<Schema.Json, Schema.Json>;
+          readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+          readonly policy: Schema.toCodecJson<typeof import("@yielded/agent/agent-policy").AgentPolicy>;
+          readonly depth: Schema.Natural;
+          readonly grant: Schema.optionalKey<typeof import("@yielded/agent/subagent-contract").SubagentGrant>;
+          readonly workerAdmission: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+        }>>;
+      }>>;
+    }>;
+    readonly executionRunId: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+    readonly createdAtMillis: Schema.Natural;
+    readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+    readonly deliveryPrincipal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+    readonly reportKind: Schema.optionalKey<Schema.Literal<"update">>;
+  }>>;
+  readonly messageAdmission: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly peerName: Schema.NonEmptyString;
+    readonly sender: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly returnAddress: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>>;
+  }>, Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerCompletion">;
+    readonly budgetExhausted: Schema.Boolean;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly report: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literal<"completed">;
+      readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+      readonly failure: typeof import("@yielded/agent/subagent-contract").SubagentExecutionFailure;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerUpdate">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly update: typeof import("@yielded/agent/agent-updates").Update;
+  }>]>]>>;
+  readonly definitions: typeof DefinitionDigests;
+  readonly inputPayload: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/**
+ * One durable submission, input ALREADY encoded by the caller through the Agent Binding's
+ * input schema (the Worker bundles the same Agent definitions as the Object, so schema
+ * validation happens client-side; the resolved Binding re-validates at claim time). The
+ * Thread identity is deliberately absent — the addressed Object IS the lane.
+ */
+declare class SubmitRequest extends SubmitRequest_base {}
+declare const ObservePageRequest_base: Schema.Class<ObservePageRequest, Schema.Struct<{
+  readonly afterSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+  readonly limit: Schema.Int;
+}>, {}>;
+/** One bounded page of canonical records after an optional sequence. */
+declare class ObservePageRequest extends ObservePageRequest_base {}
+declare const AwaitProgressRequest_base: Schema.Class<AwaitProgressRequest, Schema.Struct<{
+  readonly afterSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly waiterId: Schema.String;
+}>, {}>;
+/** One event-driven wait for canonical progress strictly after this sequence. */
+declare class AwaitProgressRequest extends AwaitProgressRequest_base {}
+declare const CancelProgressRequest_base: Schema.Class<CancelProgressRequest, Schema.Struct<{
+  readonly waiterId: Schema.String;
+}>, {}>;
+/** Best-effort cancellation of one in-flight progress RPC. */
+declare class CancelProgressRequest extends CancelProgressRequest_base {}
+/**
+ * Every typed failure a host entry point can produce, plus the protocol's own errors. Same
+ * closed-union discipline as the WP2 `PortFailure`: members re-decode to the SAME tagged
+ * classes on the Worker side; `cause` chains travel as Schema defects without instance
+ * fidelity (plan §2.8).
+ */
+declare const HostFailure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, typeof AdmissionPolicyError, typeof SettlementConflict, typeof ApprovalConflict, typeof UnknownResolutionConflict, typeof JoinedToHost, typeof LedgerError, typeof OwnershipLost, typeof ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof OperationDenied, typeof HostProtocolError]>;
+type HostFailure = typeof HostFailure.Type;
+declare const SubmitSucceeded_base: Schema.Class<SubmitSucceeded, Schema.TaggedStruct<"SubmitSucceeded", {
+  readonly receipt: typeof Receipt;
+}>, {}>;
+declare class SubmitSucceeded extends SubmitSucceeded_base {}
+declare const SubmissionStatusResponse_base: Schema.Class<SubmissionStatusResponse, Schema.TaggedStruct<"SubmissionStatusResponse", {
+  readonly status: Schema.Union<readonly [typeof import("@yielded/agent/submission-status").PendingSubmission, typeof import("@yielded/agent/submission-status").SettledSubmission]>;
+}>, {}>;
+declare class SubmissionStatusResponse extends SubmissionStatusResponse_base {}
+declare const SettlementReached_base: Schema.Class<SettlementReached, Schema.TaggedStruct<"SettlementReached", {
+  readonly settlement: typeof Settlement;
+}>, {}>;
+declare class SettlementReached extends SettlementReached_base {}
+declare const SettlementRecordReached_base: Schema.Class<SettlementRecordReached, Schema.TaggedStruct<"SettlementRecordReached", {
+  readonly record: Schema.refine<SubmissionSettledRecord, typeof import("@yielded/agent/records").SubmissionSettled>;
+}>, {}>;
+/** The exact canonical record of an operationally finalized Submission. */
+declare class SettlementRecordReached extends SettlementRecordReached_base {}
+declare const ObservedPage_base: Schema.Class<ObservedPage, Schema.TaggedStruct<"ObservedPage", {
+  readonly records: Schema.$Array<typeof CanonicalRecordEnvelope>;
+}>, {}>;
+declare class ObservedPage extends ObservedPage_base {}
+declare const ProgressObserved_base: Schema.Class<ProgressObserved, Schema.TaggedStruct<"ProgressObserved", {}>, {}>;
+/** A record was already committed or an incarnation-local hint says the caller should re-read. */
+declare class ProgressObserved extends ProgressObserved_base {}
+declare const ProgressCancelled_base: Schema.Class<ProgressCancelled, Schema.TaggedStruct<"ProgressCancelled", {}>, {}>;
+declare class ProgressCancelled extends ProgressCancelled_base {}
+declare const AbortRecorded_base: Schema.Class<AbortRecorded, Schema.TaggedStruct<"AbortRecorded", {
+  readonly intent: typeof AbortIntent;
+}>, {}>;
+declare class AbortRecorded extends AbortRecorded_base {}
+declare const ApprovalRecorded_base: Schema.Class<ApprovalRecorded, Schema.TaggedStruct<"ApprovalRecorded", {
+  readonly intent: typeof ApprovalDecisionIntent;
+}>, {}>;
+declare class ApprovalRecorded extends ApprovalRecorded_base {}
+declare const UnknownResolutionRecorded_base: Schema.Class<UnknownResolutionRecorded, Schema.TaggedStruct<"UnknownResolutionRecorded", {
+  readonly intent: typeof UnknownResolutionIntent;
+}>, {}>;
+declare class UnknownResolutionRecorded extends UnknownResolutionRecorded_base {}
+declare const HostFailed_base: Schema.Class<HostFailed, Schema.TaggedStruct<"HostFailed", {
+  readonly failure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, typeof AdmissionPolicyError, typeof SettlementConflict, typeof ApprovalConflict, typeof UnknownResolutionConflict, typeof JoinedToHost, typeof LedgerError, typeof OwnershipLost, typeof ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof OperationDenied, typeof HostProtocolError]>;
+}>, {}>;
+/** The entry point failed TYPED on the Object; the failure re-decodes verbatim. */
+declare class HostFailed extends HostFailed_base {}
+/** The uniform answer of one host entry point. Callers narrow by the tag their call implies. */
+declare const HostResponse: Schema.Union<readonly [typeof SubmitSucceeded, typeof SettlementReached, typeof SettlementRecordReached, typeof SubmissionStatusResponse, typeof ObservedPage, typeof ProgressObserved, typeof ProgressCancelled, typeof AbortRecorded, typeof ApprovalRecorded, typeof UnknownResolutionRecorded, typeof HostFailed]>;
+type HostResponse = typeof HostResponse.Type;
+declare const decodeSubmitRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<SubmitRequest, Schema.SchemaError, never>;
+declare const encodeSubmitRequest: (input: SubmitRequest, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly agentId: string;
+  readonly principal: string;
+  readonly idempotencyKey: string;
+  readonly admissionGroup?: string | undefined;
+  readonly admissionFence?: {
+    readonly policyId: string;
+    readonly key: string;
+    readonly revision: string;
+  } | undefined;
+  readonly workerAdmission?: {
+    readonly origin: {
+      readonly worker: {
+        readonly schemaVersion: 1;
+        readonly delegationId: string;
+        readonly targetAgentId: string;
+        readonly threadId: string;
+      };
+      readonly source: {
+        readonly _tag: "tool";
+        readonly agentId: string;
+        readonly threadId: string;
+        readonly runId: string;
+        readonly toolCallId: string;
+      } | {
+        readonly _tag: "programmatic";
+        readonly agentId: string;
+        readonly threadId: string;
+      };
+      readonly continuationOf?: {
+        readonly worker: {
+          readonly schemaVersion: 1;
+          readonly delegationId: string;
+          readonly targetAgentId: string;
+          readonly threadId: string;
+        };
+        readonly receipt: {
+          readonly receiptId: string;
+          readonly submissionId: string;
+          readonly threadId: string;
+          readonly queueSequence: number;
+        };
+        readonly settlementId: string;
+      } | undefined;
+      readonly budgetScope: "source-subtree" | "worker-run";
+      readonly lifecycle?: "assignment" | undefined;
+      readonly targetDigests: {
+        readonly agent: string;
+        readonly model: string;
+        readonly tools: string;
+        readonly replay?: {
+          readonly agent: string;
+          readonly agentBehavior?: string | undefined;
+          readonly tools: {
+            readonly [x: string]: string;
+          };
+        } | undefined;
+      };
+      readonly policy: Schema.Json;
+      readonly budget: {
+        readonly caps: {
+          readonly maxTotalChildInvocations?: number | undefined;
+          readonly maxConcurrentChildren?: number | undefined;
+          readonly maxTurns?: number | undefined;
+          readonly maxToolCalls?: number | undefined;
+          readonly maxDurationMillis?: number | undefined;
+          readonly maxInputTokens?: number | undefined;
+          readonly maxOutputTokens?: number | undefined;
+          readonly maxCostMicrousd?: number | undefined;
+          readonly maxResultBytes?: number | undefined;
+        };
+        readonly allocation: {
+          readonly turns: number;
+          readonly toolCalls: number;
+          readonly durationMillis: number;
+          readonly inputTokens: number;
+          readonly outputTokens: number;
+          readonly costMicrousd: number;
+          readonly resultBytes: number;
+        };
+        readonly descendantInvocations?: number | undefined;
+      };
+      readonly grant: {
+        readonly allowedToolNames: readonly string[];
+        readonly maxDepth: number;
+        readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+      };
+      readonly depth: number;
+      readonly toolCallAllowance?: number | undefined;
+      readonly firstMessageId: string;
+      readonly createdAtMillis: number;
+      readonly expiresAtMillis: number;
+      readonly reporting?: {
+        readonly mode?: "standard" | undefined;
+        readonly sourceDigests: {
+          readonly agent: string;
+          readonly model: string;
+          readonly tools: string;
+          readonly replay?: {
+            readonly agent: string;
+            readonly agentBehavior?: string | undefined;
+            readonly tools: {
+              readonly [x: string]: string;
+            };
+          } | undefined;
+        };
+        readonly destinationDelegationId?: string | undefined;
+        readonly returnAddress?: {
+          readonly input: Schema.Json;
+          readonly principal: string;
+          readonly policy: Schema.Json;
+          readonly depth: number;
+          readonly grant?: {
+            readonly allowedToolNames: readonly string[];
+            readonly maxDepth: number;
+            readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+          } | undefined;
+          readonly workerAdmission?: Schema.Json | undefined;
+        } | undefined;
+      } | undefined;
+    };
+    readonly executionRunId: string | null;
+    readonly messageId: string;
+    readonly parameters: Schema.Json;
+    readonly createdAtMillis: number;
+    readonly sourceSubmissionId?: string | undefined;
+    readonly deliveryPrincipal?: string | undefined;
+    readonly reportKind?: "update" | undefined;
+  } | undefined;
+  readonly messageAdmission?: {
+    readonly schemaVersion: 1;
+    readonly message: {
+      readonly ownerThreadId: string;
+      readonly messageId: string;
+    };
+    readonly peerName: string;
+    readonly sender: {
+      readonly threadId: string;
+      readonly agentId: string;
+    };
+    readonly returnAddress: {
+      readonly threadId: string;
+      readonly agentId: string;
+    };
+    readonly inReplyTo?: {
+      readonly ownerThreadId: string;
+      readonly messageId: string;
+    } | undefined;
+  } | {
+    readonly _tag: "WorkerCompletion";
+    readonly budgetExhausted: boolean;
+    readonly schemaVersion: 1;
+    readonly report: {
+      readonly _tag: "Settled";
+      readonly worker: {
+        readonly schemaVersion: 1;
+        readonly delegationId: string;
+        readonly targetAgentId: string;
+        readonly threadId: string;
+      };
+      readonly receipt: {
+        readonly receiptId: string;
+        readonly submissionId: string;
+        readonly threadId: string;
+        readonly queueSequence: number;
+      };
+      readonly runId: string;
+      readonly settlementId: string;
+      readonly outcome: "completed";
+      readonly result: Schema.Json;
+    } | {
+      readonly _tag: "Settled";
+      readonly worker: {
+        readonly schemaVersion: 1;
+        readonly delegationId: string;
+        readonly targetAgentId: string;
+        readonly threadId: string;
+      };
+      readonly receipt: {
+        readonly receiptId: string;
+        readonly submissionId: string;
+        readonly threadId: string;
+        readonly queueSequence: number;
+      };
+      readonly runId: string;
+      readonly settlementId: string;
+      readonly outcome: "aborted" | "failed";
+      readonly failure: {
+        readonly _tag: "SubagentExecutionFailure";
+        readonly delegationId: string;
+        readonly targetAgentId: string;
+        readonly classification: "child-aborted" | "child-compatibility" | "child-failed" | "declaration-unavailable" | "establishment-denied";
+        readonly childThreadId?: string | undefined;
+        readonly childSubmissionId?: string | undefined;
+        readonly childRunId?: string | undefined;
+        readonly errorTag: string;
+        readonly message: string;
+      };
+    };
+  } | {
+    readonly _tag: "WorkerUpdate";
+    readonly schemaVersion: 1;
+    readonly worker: {
+      readonly schemaVersion: 1;
+      readonly delegationId: string;
+      readonly targetAgentId: string;
+      readonly threadId: string;
+    };
+    readonly update: {
+      readonly schemaVersion: 1;
+      readonly agentId: string;
+      readonly threadId: string;
+      readonly runId: string;
+      readonly updateId: string;
+      readonly sequence: number;
+      readonly value: Schema.Json;
+    };
+  } | undefined;
+  readonly definitions: {
+    readonly agent: string;
+    readonly model: string;
+    readonly tools: string;
+    readonly replay?: {
+      readonly agent: string;
+      readonly agentBehavior?: string | undefined;
+      readonly tools: {
+        readonly [x: string]: string;
+      };
+    } | undefined;
+  };
+  readonly inputPayload: Schema.Json;
+}, Schema.SchemaError, never>;
+declare const decodeReceipt: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<Receipt, Schema.SchemaError, never>;
+declare const encodeReceipt: (input: Receipt, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly receiptId: string;
+  readonly submissionId: string;
+  readonly threadId: string;
+  readonly queueSequence: number;
+}, Schema.SchemaError, never>;
+declare const decodeObservePageRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<ObservePageRequest, Schema.SchemaError, never>;
+declare const encodeObservePageRequest: (input: ObservePageRequest, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly afterSequence?: number | undefined;
+  readonly limit: number;
+}, Schema.SchemaError, never>;
+declare const decodeAwaitProgressRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AwaitProgressRequest, Schema.SchemaError, never>;
+declare const encodeAwaitProgressRequest: (input: AwaitProgressRequest, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly afterSequence: number;
+  readonly waiterId: string;
+}, Schema.SchemaError, never>;
+declare const decodeCancelProgressRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<CancelProgressRequest, Schema.SchemaError, never>;
+declare const encodeCancelProgressRequest: (input: CancelProgressRequest, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly waiterId: string;
+}, Schema.SchemaError, never>;
+declare const decodeAbortCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortCommand, Schema.SchemaError, never>;
+declare const encodeAbortCommand: (input: AbortCommand, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly submissionId: string;
+  readonly author: string;
+  readonly reason: string;
+}, Schema.SchemaError, never>;
+declare const decodeApprovalDecisionCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<ApprovalDecisionCommand, Schema.SchemaError, never>;
+declare const encodeApprovalDecisionCommand: (input: ApprovalDecisionCommand, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly submissionId: string;
+  readonly toolCallId: string;
+  readonly decision: "approved" | "denied";
+  readonly resolver: string;
+  readonly reason: string;
+}, Schema.SchemaError, never>;
+declare const decodeUnknownResolutionCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<UnknownResolutionCommand, Schema.SchemaError, never>;
+declare const encodeUnknownResolutionCommand: (input: UnknownResolutionCommand, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly submissionId: string;
+  readonly toolCallId: string;
+  readonly author: string;
+  readonly reason: string;
+  readonly resolution: {
+    readonly _tag: "SafeToRetry";
+  } | {
+    readonly _tag: "CompletedWithResult";
+    readonly result: Schema.Json;
+    readonly isFailure: boolean;
+  } | {
+    readonly _tag: "NeverHappened";
+  } | {
+    readonly _tag: "AbortSubmission";
+  };
+}, Schema.SchemaError, never>;
+declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | SettlementRecordReached | SubmissionStatusResponse | SubmitSucceeded | UnknownResolutionRecorded, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly _tag: "SubmitSucceeded";
+  readonly receipt: {
+    readonly receiptId: string;
+    readonly submissionId: string;
+    readonly threadId: string;
+    readonly queueSequence: number;
+  };
+} | {
+  readonly _tag: "SubmissionStatusResponse";
+  readonly status: {
+    readonly _tag: "pending";
+  } | {
+    readonly _tag: "settled";
+    readonly settlement: {
+      readonly submissionId: string;
+      readonly settlementId: string;
+      readonly receiptId: string;
+      readonly outcome: "aborted" | "completed" | "failed";
+      readonly runDisposition?: Schema.Json | undefined;
+      readonly usageSummary?: {
+        readonly modelCalls: number;
+        readonly inputTokens: {
+          readonly total: number;
+          readonly uncached: number;
+          readonly cacheRead: number;
+          readonly cacheWrite: number;
+        };
+        readonly outputTokens: {
+          readonly total: number;
+          readonly text: number;
+          readonly reasoning: number;
+        };
+        readonly webSearchCalls?: number | undefined;
+        readonly costMicrousd: number;
+        readonly byModel: readonly {
+          readonly provider: string;
+          readonly model: string;
+          readonly responseModel?: string | undefined;
+          readonly serviceTier?: string | undefined;
+          readonly pricingVersion?: string | undefined;
+          readonly modelCalls: number;
+          readonly inputTokens: {
+            readonly total: number;
+            readonly uncached: number;
+            readonly cacheRead: number;
+            readonly cacheWrite: number;
+          };
+          readonly outputTokens: {
+            readonly total: number;
+            readonly text: number;
+            readonly reasoning: number;
+          };
+          readonly webSearchCalls?: number | undefined;
+          readonly costMicrousd: number;
+        }[];
+        readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+        readonly pricingStatus?: "complete" | "partial" | "unknown" | undefined;
+        readonly unobservedModelCalls?: number | undefined;
+      } | undefined;
+      readonly failure?: {
+        readonly errorTag: string;
+        readonly message: string;
+        readonly diagnostic?: import("@yielded/agent/failure-diagnostic").Diagnostic | undefined;
+        readonly context?: {
+          readonly agentId?: string | undefined;
+          readonly threadId?: string | undefined;
+          readonly runId?: string | undefined;
+          readonly submissionId?: string | undefined;
+          readonly attemptId?: string | undefined;
+          readonly turnId?: string | undefined;
+          readonly toolCallId?: string | undefined;
+          readonly toolName?: string | undefined;
+          readonly callId?: string | undefined;
+          readonly check?: string | undefined;
+          readonly operation?: string | undefined;
+        } | undefined;
+      } | undefined;
+      readonly settledAt: string;
+    };
+  };
+} | {
+  readonly _tag: "SettlementReached";
+  readonly settlement: {
+    readonly submissionId: string;
+    readonly settlementId: string;
+    readonly receiptId: string;
+    readonly outcome: "aborted" | "completed" | "failed";
+    readonly runDisposition?: Schema.Json | undefined;
+    readonly usageSummary?: {
+      readonly modelCalls: number;
+      readonly inputTokens: {
+        readonly total: number;
+        readonly uncached: number;
+        readonly cacheRead: number;
+        readonly cacheWrite: number;
+      };
+      readonly outputTokens: {
+        readonly total: number;
+        readonly text: number;
+        readonly reasoning: number;
+      };
+      readonly webSearchCalls?: number | undefined;
+      readonly costMicrousd: number;
+      readonly byModel: readonly {
+        readonly provider: string;
+        readonly model: string;
+        readonly responseModel?: string | undefined;
+        readonly serviceTier?: string | undefined;
+        readonly pricingVersion?: string | undefined;
+        readonly modelCalls: number;
+        readonly inputTokens: {
+          readonly total: number;
+          readonly uncached: number;
+          readonly cacheRead: number;
+          readonly cacheWrite: number;
+        };
+        readonly outputTokens: {
+          readonly total: number;
+          readonly text: number;
+          readonly reasoning: number;
+        };
+        readonly webSearchCalls?: number | undefined;
+        readonly costMicrousd: number;
+      }[];
+      readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+      readonly pricingStatus?: "complete" | "partial" | "unknown" | undefined;
+      readonly unobservedModelCalls?: number | undefined;
+    } | undefined;
+    readonly failure?: {
+      readonly errorTag: string;
+      readonly message: string;
+      readonly diagnostic?: import("@yielded/agent/failure-diagnostic").Diagnostic | undefined;
+      readonly context?: {
+        readonly agentId?: string | undefined;
+        readonly threadId?: string | undefined;
+        readonly runId?: string | undefined;
+        readonly submissionId?: string | undefined;
+        readonly attemptId?: string | undefined;
+        readonly turnId?: string | undefined;
+        readonly toolCallId?: string | undefined;
+        readonly toolName?: string | undefined;
+        readonly callId?: string | undefined;
+        readonly check?: string | undefined;
+        readonly operation?: string | undefined;
+      } | undefined;
+    } | undefined;
+    readonly settledAt: string;
+  };
+} | {
+  readonly _tag: "SettlementRecordReached";
+  readonly record: {
+    readonly _tag: "SubmissionSettled";
+    readonly submissionId: string;
+    readonly settlementId: string;
+    readonly receiptId: string;
+    readonly outcome: "aborted" | "completed" | "failed";
+    readonly runId?: string | undefined;
+    readonly historyRecordCount?: number | undefined;
+    readonly result?: Schema.Json | undefined;
+    readonly runDisposition?: Schema.Json | undefined;
+    readonly finishReason?: "budget-exhausted" | undefined;
+    readonly exhausted?: "tokens" | "tool-calls" | "turns" | undefined;
+    readonly policyLimit?: "cost" | "duration" | "repeated-failures" | "tokens" | "tool-calls" | "turns" | "usage" | undefined;
+    readonly usageSummary?: {
+      readonly modelCalls: number;
+      readonly inputTokens: {
+        readonly total: number;
+        readonly uncached: number;
+        readonly cacheRead: number;
+        readonly cacheWrite: number;
+      };
+      readonly outputTokens: {
+        readonly total: number;
+        readonly text: number;
+        readonly reasoning: number;
+      };
+      readonly webSearchCalls?: number | undefined;
+      readonly costMicrousd: number;
+      readonly byModel: readonly {
+        readonly provider: string;
+        readonly model: string;
+        readonly responseModel?: string | undefined;
+        readonly serviceTier?: string | undefined;
+        readonly pricingVersion?: string | undefined;
+        readonly modelCalls: number;
+        readonly inputTokens: {
+          readonly total: number;
+          readonly uncached: number;
+          readonly cacheRead: number;
+          readonly cacheWrite: number;
+        };
+        readonly outputTokens: {
+          readonly total: number;
+          readonly text: number;
+          readonly reasoning: number;
+        };
+        readonly webSearchCalls?: number | undefined;
+        readonly costMicrousd: number;
+      }[];
+      readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+      readonly pricingStatus?: "complete" | "partial" | "unknown" | undefined;
+      readonly unobservedModelCalls?: number | undefined;
+    } | undefined;
+    readonly uncommittedModelUsage?: readonly {
+      readonly provider: string;
+      readonly model: string;
+      readonly serviceTier?: string | undefined;
+      readonly pricingVersion?: string | undefined;
+      readonly response?: {
+        readonly id?: string | undefined;
+        readonly model?: string | undefined;
+      } | undefined;
+      readonly purpose?: "summary" | "turn" | undefined;
+      readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+      readonly pricingStatus?: "estimated" | "unknown" | undefined;
+      readonly inputTokens: {
+        readonly total: number;
+        readonly uncached: number;
+        readonly cacheRead: number;
+        readonly cacheWrite: number;
+      };
+      readonly outputTokens: {
+        readonly total: number;
+        readonly text: number;
+        readonly reasoning: number;
+      };
+      readonly webSearchCalls?: number | undefined;
+      readonly costMicrousd: number;
+    }[] | undefined;
+  };
+} | {
+  readonly _tag: "ObservedPage";
+  readonly records: readonly {
+    readonly threadId: string;
+    readonly batchId: string;
+    readonly sequence: number;
+    readonly offset: string;
+    readonly record: {
+      readonly recordId: string;
+      readonly family: "thread";
+      readonly schemaVersion: 1;
+      readonly createdAt: string;
+      readonly deploymentId: string;
+      readonly payload: {
+        readonly _tag: "UserInputRecorded";
+        readonly submissionId?: string | undefined;
+        readonly kind: "follow-up" | "steering" | "user";
+        readonly runId?: string | undefined;
+        readonly input: Schema.Json;
+        readonly messageAdmission?: {
+          readonly schemaVersion: 1;
+          readonly message: {
+            readonly ownerThreadId: string;
+            readonly messageId: string;
+          };
+          readonly peerName: string;
+          readonly sender: {
+            readonly threadId: string;
+            readonly agentId: string;
+          };
+          readonly returnAddress: {
+            readonly threadId: string;
+            readonly agentId: string;
+          };
+          readonly inReplyTo?: {
+            readonly ownerThreadId: string;
+            readonly messageId: string;
+          } | undefined;
+        } | {
+          readonly _tag: "WorkerCompletion";
+          readonly budgetExhausted: boolean;
+          readonly schemaVersion: 1;
+          readonly report: {
+            readonly _tag: "Settled";
+            readonly worker: {
+              readonly schemaVersion: 1;
+              readonly delegationId: string;
+              readonly targetAgentId: string;
+              readonly threadId: string;
+            };
+            readonly receipt: {
+              readonly receiptId: string;
+              readonly submissionId: string;
+              readonly threadId: string;
+              readonly queueSequence: number;
+            };
+            readonly runId: string;
+            readonly settlementId: string;
+            readonly outcome: "completed";
+            readonly result: Schema.Json;
+          } | {
+            readonly _tag: "Settled";
+            readonly worker: {
+              readonly schemaVersion: 1;
+              readonly delegationId: string;
+              readonly targetAgentId: string;
+              readonly threadId: string;
+            };
+            readonly receipt: {
+              readonly receiptId: string;
+              readonly submissionId: string;
+              readonly threadId: string;
+              readonly queueSequence: number;
+            };
+            readonly runId: string;
+            readonly settlementId: string;
+            readonly outcome: "aborted" | "failed";
+            readonly failure: {
+              readonly _tag: "SubagentExecutionFailure";
+              readonly delegationId: string;
+              readonly targetAgentId: string;
+              readonly classification: "child-aborted" | "child-compatibility" | "child-failed" | "declaration-unavailable" | "establishment-denied";
+              readonly childThreadId?: string | undefined;
+              readonly childSubmissionId?: string | undefined;
+              readonly childRunId?: string | undefined;
+              readonly errorTag: string;
+              readonly message: string;
+            };
+          };
+        } | {
+          readonly _tag: "WorkerUpdate";
+          readonly schemaVersion: 1;
+          readonly worker: {
+            readonly schemaVersion: 1;
+            readonly delegationId: string;
+            readonly targetAgentId: string;
+            readonly threadId: string;
+          };
+          readonly update: {
+            readonly schemaVersion: 1;
+            readonly agentId: string;
+            readonly threadId: string;
+            readonly runId: string;
+            readonly updateId: string;
+            readonly sequence: number;
+            readonly value: Schema.Json;
+          };
+        } | undefined;
+      } | {
+        readonly _tag: "ModelResponseRecorded";
+        readonly toolResultMaxBytes: number;
+        readonly toolSelectionMaxBytes: number;
+        readonly toolOperations: readonly {
+          readonly toolCallId: string;
+          readonly toolName: string;
+          readonly executionClass: "idempotent" | "readonly" | "uncertain";
+          readonly executionKind: "delegation" | "orchestration" | "ordinary";
+          readonly replay: string;
+        }[];
+        readonly toolParameterRejections?: readonly {
+          readonly toolCallId: string;
+          readonly parameters: Schema.Json;
+          readonly error: {
+            readonly _tag: "AiError";
+            readonly module: string;
+            readonly method: string;
+            readonly reason: {
+              readonly _tag: "ToolParameterValidationError";
+              readonly toolName: string;
+              readonly description: string;
+            };
+          };
+        }[] | undefined;
+        readonly toolExposure?: {
+          readonly exposedToolNames: readonly string[];
+          readonly selection?: {
+            readonly toolNames: readonly string[];
+          } | undefined;
+        } | undefined;
+        readonly runId: string;
+        readonly turnId: string;
+        readonly turn: number;
+        readonly messages: Schema.Json;
+        readonly runScopedPrefixLength?: number | undefined;
+        readonly modelUsage?: readonly {
+          readonly provider: string;
+          readonly model: string;
+          readonly serviceTier?: string | undefined;
+          readonly pricingVersion?: string | undefined;
+          readonly response?: {
+            readonly id?: string | undefined;
+            readonly model?: string | undefined;
+          } | undefined;
+          readonly purpose?: "summary" | "turn" | undefined;
+          readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly pricingStatus?: "estimated" | "unknown" | undefined;
+          readonly inputTokens: {
+            readonly total: number;
+            readonly uncached: number;
+            readonly cacheRead: number;
+            readonly cacheWrite: number;
+          };
+          readonly outputTokens: {
+            readonly total: number;
+            readonly text: number;
+            readonly reasoning: number;
+          };
+          readonly webSearchCalls?: number | undefined;
+          readonly costMicrousd: number;
+        }[] | undefined;
+        readonly unobservedModelCalls?: number | undefined;
+        readonly inputTokens?: number | undefined;
+        readonly outputTokens?: number | undefined;
+        readonly costMicrousd?: number | undefined;
+      } | {
+        readonly _tag: "CompactionCreated";
+        readonly runId: string;
+        readonly turn: number;
+        readonly kind: "clear-tool-results" | "rollover" | "summarize";
+        readonly coversThrough: number;
+        readonly summary?: string | undefined;
+        readonly handoff?: string | undefined;
+      } | {
+        readonly _tag: "ThreadCreated";
+        readonly agentId: string;
+        readonly definitions: {
+          readonly agent: string;
+          readonly model: string;
+          readonly tools: string;
+          readonly replay?: {
+            readonly agent: string;
+            readonly agentBehavior?: string | undefined;
+            readonly tools: {
+              readonly [x: string]: string;
+            };
+          } | undefined;
+        };
+      } | {
+        readonly _tag: "RunStarted";
+        readonly runId: string;
+        readonly policyAccountingVersion: 1;
+        readonly maxDurationMillis: number;
+      } | {
+        readonly _tag: "RunDurationExhausted";
+        readonly runId: string;
+      } | {
+        readonly _tag: "RunPolicyUsageReserved";
+        readonly runId: string;
+        readonly programmaticToolCalls: number;
+        readonly finalizationUsed: boolean;
+      } | {
+        readonly _tag: "ModelCompleted";
+        readonly runId: string;
+        readonly output: Schema.Json;
+        readonly messages?: Schema.Json | undefined;
+        readonly history?: Schema.Json | undefined;
+      } | {
+        readonly _tag: "ToolCallSettled";
+        readonly toolSelection?: {
+          readonly toolNames: readonly string[];
+        } | undefined;
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly result: Schema.Json;
+        readonly isFailure: boolean;
+        readonly budgetRejected?: true | undefined;
+      } | {
+        readonly _tag: "ToolCallUnknown";
+        readonly runId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly reason: string;
+      } | {
+        readonly _tag: "ToolCallResolved";
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly resolution: "completed-with-result" | "failed-with-error" | "never-started" | "safe-retry";
+        readonly author: string;
+        readonly reason: string;
+      } | {
+        readonly _tag: "ToolStepSettled";
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly stepName: string;
+        readonly output: Schema.Json;
+        readonly outputDigest: string;
+      } | {
+        readonly _tag: "ToolApprovalRequested";
+        readonly runId: string;
+        readonly turnId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly parametersDigest: string;
+        readonly blocksInitialDispatch: boolean;
+      } | {
+        readonly _tag: "ToolApprovalDecided";
+        readonly runId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly decision: "approved" | "denied";
+        readonly resolver: string;
+        readonly reason: string;
+      } | {
+        readonly _tag: "ModelResponseInterrupted";
+        readonly runId: string;
+      } | {
+        readonly _tag: "ModelCallAborted";
+        readonly runId: string;
+        readonly turnId: string;
+        readonly turn: number;
+        readonly restart: number;
+        readonly reason: "joined-input";
+        readonly modelUsage: readonly {
+          readonly provider: string;
+          readonly model: string;
+          readonly serviceTier?: string | undefined;
+          readonly pricingVersion?: string | undefined;
+          readonly response?: {
+            readonly id?: string | undefined;
+            readonly model?: string | undefined;
+          } | undefined;
+          readonly purpose?: "summary" | "turn" | undefined;
+          readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly pricingStatus?: "estimated" | "unknown" | undefined;
+          readonly inputTokens: {
+            readonly total: number;
+            readonly uncached: number;
+            readonly cacheRead: number;
+            readonly cacheWrite: number;
+          };
+          readonly outputTokens: {
+            readonly total: number;
+            readonly text: number;
+            readonly reasoning: number;
+          };
+          readonly webSearchCalls?: number | undefined;
+          readonly costMicrousd: number;
+        }[];
+        readonly unobservedModelCalls: number;
+      } | {
+        readonly _tag: "RunFailed";
+        readonly runId: string;
+        readonly failure: Schema.Json;
+      } | {
+        readonly _tag: "RunCompleted";
+        readonly runId: string;
+        readonly output: Schema.Json;
+        readonly runDisposition?: Schema.Json | undefined;
+        readonly finishReason?: "budget-exhausted" | undefined;
+        readonly exhausted?: "tokens" | "tool-calls" | "turns" | undefined;
+      } | {
+        readonly _tag: "AbortRequested";
+        readonly submissionId: string;
+        readonly author: string;
+        readonly reason: string;
+      } | {
+        readonly _tag: "SubmissionSettled";
+        readonly submissionId: string;
+        readonly settlementId: string;
+        readonly receiptId: string;
+        readonly outcome: "aborted" | "completed" | "failed";
+        readonly runId?: string | undefined;
+        readonly historyRecordCount?: number | undefined;
+        readonly result?: Schema.Json | undefined;
+        readonly runDisposition?: Schema.Json | undefined;
+        readonly finishReason?: "budget-exhausted" | undefined;
+        readonly exhausted?: "tokens" | "tool-calls" | "turns" | undefined;
+        readonly policyLimit?: "cost" | "duration" | "repeated-failures" | "tokens" | "tool-calls" | "turns" | "usage" | undefined;
+        readonly usageSummary?: {
+          readonly modelCalls: number;
+          readonly inputTokens: {
+            readonly total: number;
+            readonly uncached: number;
+            readonly cacheRead: number;
+            readonly cacheWrite: number;
+          };
+          readonly outputTokens: {
+            readonly total: number;
+            readonly text: number;
+            readonly reasoning: number;
+          };
+          readonly webSearchCalls?: number | undefined;
+          readonly costMicrousd: number;
+          readonly byModel: readonly {
+            readonly provider: string;
+            readonly model: string;
+            readonly responseModel?: string | undefined;
+            readonly serviceTier?: string | undefined;
+            readonly pricingVersion?: string | undefined;
+            readonly modelCalls: number;
+            readonly inputTokens: {
+              readonly total: number;
+              readonly uncached: number;
+              readonly cacheRead: number;
+              readonly cacheWrite: number;
+            };
+            readonly outputTokens: {
+              readonly total: number;
+              readonly text: number;
+              readonly reasoning: number;
+            };
+            readonly webSearchCalls?: number | undefined;
+            readonly costMicrousd: number;
+          }[];
+          readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly pricingStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly unobservedModelCalls?: number | undefined;
+        } | undefined;
+        readonly uncommittedModelUsage?: readonly {
+          readonly provider: string;
+          readonly model: string;
+          readonly serviceTier?: string | undefined;
+          readonly pricingVersion?: string | undefined;
+          readonly response?: {
+            readonly id?: string | undefined;
+            readonly model?: string | undefined;
+          } | undefined;
+          readonly purpose?: "summary" | "turn" | undefined;
+          readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly pricingStatus?: "estimated" | "unknown" | undefined;
+          readonly inputTokens: {
+            readonly total: number;
+            readonly uncached: number;
+            readonly cacheRead: number;
+            readonly cacheWrite: number;
+          };
+          readonly outputTokens: {
+            readonly total: number;
+            readonly text: number;
+            readonly reasoning: number;
+          };
+          readonly webSearchCalls?: number | undefined;
+          readonly costMicrousd: number;
+        }[] | undefined;
+      } | {
+        readonly _tag: "SubagentRequested";
+        readonly runId: string;
+        readonly turnId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly delegationId: string;
+        readonly targetAgentId: string;
+        readonly targetDigests: {
+          readonly agent: string;
+          readonly model: string;
+          readonly tools: string;
+          readonly replay?: {
+            readonly agent: string;
+            readonly agentBehavior?: string | undefined;
+            readonly tools: {
+              readonly [x: string]: string;
+            };
+          } | undefined;
+        };
+        readonly childInput: Schema.Json;
+        readonly childInputDigest: string;
+        readonly grantDigest: string;
+        readonly reservationId: string;
+        readonly reservationDigest: string;
+        readonly childThreadId: string;
+        readonly childPrincipal: string;
+        readonly childIdempotencyKey: string;
+        readonly toolCallAllowance?: number | undefined;
+        readonly policy?: Schema.Json | undefined;
+        readonly budget?: {
+          readonly caps: {
+            readonly maxTotalChildInvocations?: number | undefined;
+            readonly maxConcurrentChildren?: number | undefined;
+            readonly maxTurns?: number | undefined;
+            readonly maxToolCalls?: number | undefined;
+            readonly maxDurationMillis?: number | undefined;
+            readonly maxInputTokens?: number | undefined;
+            readonly maxOutputTokens?: number | undefined;
+            readonly maxCostMicrousd?: number | undefined;
+            readonly maxResultBytes?: number | undefined;
+          };
+          readonly allocation: {
+            readonly turns: number;
+            readonly toolCalls: number;
+            readonly durationMillis: number;
+            readonly inputTokens: number;
+            readonly outputTokens: number;
+            readonly costMicrousd: number;
+            readonly resultBytes: number;
+          };
+          readonly descendantInvocations?: number | undefined;
+        } | undefined;
+        readonly grant?: {
+          readonly allowedToolNames: readonly string[];
+          readonly maxDepth: number;
+          readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+        } | undefined;
+        readonly depth?: number | undefined;
+      } | {
+        readonly _tag: "SubagentStarted";
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly childThreadId: string;
+        readonly childSubmissionId: string;
+        readonly childReceiptId: string;
+        readonly childRunId: string;
+      } | {
+        readonly _tag: "SubagentJoined";
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+        readonly childSettlementId: string;
+        readonly childOutcome: "aborted" | "completed" | "failed";
+        readonly usageSummary: Schema.Json;
+        readonly usage?: {
+          readonly modelCalls: number;
+          readonly inputTokens: number;
+          readonly outputTokens: number;
+          readonly webSearchCalls?: number | undefined;
+          readonly costMicrousd: number;
+          readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly pricingStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly unobservedModelCalls?: number | undefined;
+        } | undefined;
+        readonly delegatedUsage?: {
+          readonly modelCalls: number;
+          readonly inputTokens: number;
+          readonly outputTokens: number;
+          readonly webSearchCalls?: number | undefined;
+          readonly costMicrousd: number;
+          readonly usageStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly pricingStatus?: "complete" | "partial" | "unknown" | undefined;
+          readonly unobservedModelCalls?: number | undefined;
+        } | undefined;
+        readonly reservationId: string;
+        readonly finalAccounting: Schema.Json;
+      } | {
+        readonly _tag: "SubagentLineageRecorded";
+        readonly parentLink: {
+          readonly delegationId: string;
+          readonly parentAgentId: string;
+          readonly parentThreadId: string;
+          readonly parentRunId: string;
+          readonly parentToolCallId: string;
+          readonly depth: number;
+        };
+        readonly parentSubmissionId: string;
+        readonly childDefinitionDigests: {
+          readonly agent: string;
+          readonly model: string;
+          readonly tools: string;
+          readonly replay?: {
+            readonly agent: string;
+            readonly agentBehavior?: string | undefined;
+            readonly tools: {
+              readonly [x: string]: string;
+            };
+          } | undefined;
+        };
+        readonly childInputDigest: string;
+        readonly grantDigest: string;
+        readonly toolCallAllowance?: number | undefined;
+        readonly policy?: Schema.Json | undefined;
+        readonly budget?: {
+          readonly caps: {
+            readonly maxTotalChildInvocations?: number | undefined;
+            readonly maxConcurrentChildren?: number | undefined;
+            readonly maxTurns?: number | undefined;
+            readonly maxToolCalls?: number | undefined;
+            readonly maxDurationMillis?: number | undefined;
+            readonly maxInputTokens?: number | undefined;
+            readonly maxOutputTokens?: number | undefined;
+            readonly maxCostMicrousd?: number | undefined;
+            readonly maxResultBytes?: number | undefined;
+          };
+          readonly allocation: {
+            readonly turns: number;
+            readonly toolCalls: number;
+            readonly durationMillis: number;
+            readonly inputTokens: number;
+            readonly outputTokens: number;
+            readonly costMicrousd: number;
+            readonly resultBytes: number;
+          };
+          readonly descendantInvocations?: number | undefined;
+        } | undefined;
+        readonly grant?: {
+          readonly allowedToolNames: readonly string[];
+          readonly maxDepth: number;
+          readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+        } | undefined;
+      } | {
+        readonly _tag: "WorkerInputRequested";
+        readonly admission: {
+          readonly origin: {
+            readonly worker: {
+              readonly schemaVersion: 1;
+              readonly delegationId: string;
+              readonly targetAgentId: string;
+              readonly threadId: string;
+            };
+            readonly source: {
+              readonly _tag: "tool";
+              readonly agentId: string;
+              readonly threadId: string;
+              readonly runId: string;
+              readonly toolCallId: string;
+            } | {
+              readonly _tag: "programmatic";
+              readonly agentId: string;
+              readonly threadId: string;
+            };
+            readonly continuationOf?: {
+              readonly worker: {
+                readonly schemaVersion: 1;
+                readonly delegationId: string;
+                readonly targetAgentId: string;
+                readonly threadId: string;
+              };
+              readonly receipt: {
+                readonly receiptId: string;
+                readonly submissionId: string;
+                readonly threadId: string;
+                readonly queueSequence: number;
+              };
+              readonly settlementId: string;
+            } | undefined;
+            readonly budgetScope: "source-subtree" | "worker-run";
+            readonly lifecycle?: "assignment" | undefined;
+            readonly targetDigests: {
+              readonly agent: string;
+              readonly model: string;
+              readonly tools: string;
+              readonly replay?: {
+                readonly agent: string;
+                readonly agentBehavior?: string | undefined;
+                readonly tools: {
+                  readonly [x: string]: string;
+                };
+              } | undefined;
+            };
+            readonly policy: Schema.Json;
+            readonly budget: {
+              readonly caps: {
+                readonly maxTotalChildInvocations?: number | undefined;
+                readonly maxConcurrentChildren?: number | undefined;
+                readonly maxTurns?: number | undefined;
+                readonly maxToolCalls?: number | undefined;
+                readonly maxDurationMillis?: number | undefined;
+                readonly maxInputTokens?: number | undefined;
+                readonly maxOutputTokens?: number | undefined;
+                readonly maxCostMicrousd?: number | undefined;
+                readonly maxResultBytes?: number | undefined;
+              };
+              readonly allocation: {
+                readonly turns: number;
+                readonly toolCalls: number;
+                readonly durationMillis: number;
+                readonly inputTokens: number;
+                readonly outputTokens: number;
+                readonly costMicrousd: number;
+                readonly resultBytes: number;
+              };
+              readonly descendantInvocations?: number | undefined;
+            };
+            readonly grant: {
+              readonly allowedToolNames: readonly string[];
+              readonly maxDepth: number;
+              readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+            };
+            readonly depth: number;
+            readonly toolCallAllowance?: number | undefined;
+            readonly firstMessageId: string;
+            readonly createdAtMillis: number;
+            readonly expiresAtMillis: number;
+            readonly reporting?: {
+              readonly mode?: "standard" | undefined;
+              readonly sourceDigests: {
+                readonly agent: string;
+                readonly model: string;
+                readonly tools: string;
+                readonly replay?: {
+                  readonly agent: string;
+                  readonly agentBehavior?: string | undefined;
+                  readonly tools: {
+                    readonly [x: string]: string;
+                  };
+                } | undefined;
+              };
+              readonly destinationDelegationId?: string | undefined;
+              readonly returnAddress?: {
+                readonly input: Schema.Json;
+                readonly principal: string;
+                readonly policy: Schema.Json;
+                readonly depth: number;
+                readonly grant?: {
+                  readonly allowedToolNames: readonly string[];
+                  readonly maxDepth: number;
+                  readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+                } | undefined;
+                readonly workerAdmission?: Schema.Json | undefined;
+              } | undefined;
+            } | undefined;
+          };
+          readonly executionRunId: string | null;
+          readonly messageId: string;
+          readonly parameters: Schema.Json;
+          readonly createdAtMillis: number;
+          readonly sourceSubmissionId?: string | undefined;
+          readonly deliveryPrincipal?: string | undefined;
+          readonly reportKind?: "update" | undefined;
+        };
+        readonly inputDigest: string;
+      } | {
+        readonly _tag: "WorkerStopRequested";
+        readonly command: {
+          readonly worker: {
+            readonly schemaVersion: 1;
+            readonly delegationId: string;
+            readonly targetAgentId: string;
+            readonly threadId: string;
+          };
+          readonly idempotencyKey: string;
+        };
+        readonly principal: string;
+        readonly sourceSubmissionId?: string | undefined;
+      } | {
+        readonly _tag: "WorkHandoffCompleted";
+        readonly preparationId: string;
+        readonly ownerId: string;
+      } | {
+        readonly _tag: "WorkerOriginRecorded";
+        readonly origin: {
+          readonly worker: {
+            readonly schemaVersion: 1;
+            readonly delegationId: string;
+            readonly targetAgentId: string;
+            readonly threadId: string;
+          };
+          readonly source: {
+            readonly _tag: "tool";
+            readonly agentId: string;
+            readonly threadId: string;
+            readonly runId: string;
+            readonly toolCallId: string;
+          } | {
+            readonly _tag: "programmatic";
+            readonly agentId: string;
+            readonly threadId: string;
+          };
+          readonly continuationOf?: {
+            readonly worker: {
+              readonly schemaVersion: 1;
+              readonly delegationId: string;
+              readonly targetAgentId: string;
+              readonly threadId: string;
+            };
+            readonly receipt: {
+              readonly receiptId: string;
+              readonly submissionId: string;
+              readonly threadId: string;
+              readonly queueSequence: number;
+            };
+            readonly settlementId: string;
+          } | undefined;
+          readonly budgetScope: "source-subtree" | "worker-run";
+          readonly lifecycle?: "assignment" | undefined;
+          readonly targetDigests: {
+            readonly agent: string;
+            readonly model: string;
+            readonly tools: string;
+            readonly replay?: {
+              readonly agent: string;
+              readonly agentBehavior?: string | undefined;
+              readonly tools: {
+                readonly [x: string]: string;
+              };
+            } | undefined;
+          };
+          readonly policy: Schema.Json;
+          readonly budget: {
+            readonly caps: {
+              readonly maxTotalChildInvocations?: number | undefined;
+              readonly maxConcurrentChildren?: number | undefined;
+              readonly maxTurns?: number | undefined;
+              readonly maxToolCalls?: number | undefined;
+              readonly maxDurationMillis?: number | undefined;
+              readonly maxInputTokens?: number | undefined;
+              readonly maxOutputTokens?: number | undefined;
+              readonly maxCostMicrousd?: number | undefined;
+              readonly maxResultBytes?: number | undefined;
+            };
+            readonly allocation: {
+              readonly turns: number;
+              readonly toolCalls: number;
+              readonly durationMillis: number;
+              readonly inputTokens: number;
+              readonly outputTokens: number;
+              readonly costMicrousd: number;
+              readonly resultBytes: number;
+            };
+            readonly descendantInvocations?: number | undefined;
+          };
+          readonly grant: {
+            readonly allowedToolNames: readonly string[];
+            readonly maxDepth: number;
+            readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+          };
+          readonly depth: number;
+          readonly toolCallAllowance?: number | undefined;
+          readonly firstMessageId: string;
+          readonly createdAtMillis: number;
+          readonly expiresAtMillis: number;
+          readonly reporting?: {
+            readonly mode?: "standard" | undefined;
+            readonly sourceDigests: {
+              readonly agent: string;
+              readonly model: string;
+              readonly tools: string;
+              readonly replay?: {
+                readonly agent: string;
+                readonly agentBehavior?: string | undefined;
+                readonly tools: {
+                  readonly [x: string]: string;
+                };
+              } | undefined;
+            };
+            readonly destinationDelegationId?: string | undefined;
+            readonly returnAddress?: {
+              readonly input: Schema.Json;
+              readonly principal: string;
+              readonly policy: Schema.Json;
+              readonly depth: number;
+              readonly grant?: {
+                readonly allowedToolNames: readonly string[];
+                readonly maxDepth: number;
+                readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+              } | undefined;
+              readonly workerAdmission?: Schema.Json | undefined;
+            } | undefined;
+          } | undefined;
+        };
+      } | {
+        readonly _tag: "WorkerInputCompleted";
+        readonly messageId: string;
+        readonly workerThreadId: string;
+        readonly submissionId: string;
+        readonly receiptId: string;
+        readonly settlementId: string;
+        readonly completedAtMillis: number;
+        readonly effectsResolved?: true | undefined;
+      } | {
+        readonly _tag: "WorkerInputRefused";
+        readonly messageId: string;
+        readonly workerThreadId: string;
+        readonly reservation: {
+          readonly recordId: string;
+        };
+        readonly stop: {
+          readonly recordId: string;
+        };
+        readonly deliveryVersion: number;
+        readonly envelopeDigest: string;
+        readonly receiver: {
+          readonly threadId: string;
+          readonly principal: string;
+          readonly idempotencyKey: string;
+          readonly inputDigest: string;
+          readonly stopped: true;
+          readonly resolution: "NotAdmitted";
+        };
+      } | {
+        readonly _tag: "WorkerReportPrepared";
+        readonly runId: string;
+        readonly messageId: string;
+        readonly envelope: Schema.Json;
+        readonly createdAtMillis: number;
+        readonly deadlineAtMillis: number;
+        readonly predecessor?: string | undefined;
+      } | {
+        readonly _tag: "AgentUpdateEmitted";
+        readonly update: {
+          readonly schemaVersion: 1;
+          readonly agentId: string;
+          readonly threadId: string;
+          readonly runId: string;
+          readonly updateId: string;
+          readonly sequence: number;
+          readonly value: Schema.Json;
+        };
+        readonly definitions: {
+          readonly agent: string;
+          readonly model: string;
+          readonly tools: string;
+          readonly replay?: {
+            readonly agent: string;
+            readonly agentBehavior?: string | undefined;
+            readonly tools: {
+              readonly [x: string]: string;
+            };
+          } | undefined;
+        };
+        readonly delivery?: {
+          readonly messageId: string;
+          readonly envelope: Schema.Json;
+          readonly createdAtMillis: number;
+          readonly deadlineAtMillis: number;
+          readonly predecessor?: string | undefined;
+        } | undefined;
+      } | {
+        readonly _tag: "WorkerReportRefused";
+        readonly runId: string;
+        readonly messageId: string;
+        readonly reason: "capacity" | "declaration-unavailable" | "defect" | "denied" | "destination" | "expired" | "filtered" | "input" | "preparation" | "projection" | "timeout";
+      } | {
+        readonly _tag: "PeerMessagePrepared";
+        readonly messageId: string;
+        readonly source: {
+          readonly _tag: "tool";
+          readonly agentId: string;
+          readonly threadId: string;
+          readonly runId: string;
+          readonly toolCallId: string;
+        } | {
+          readonly _tag: "programmatic";
+          readonly agentId: string;
+          readonly threadId: string;
+        };
+        readonly sourcePrincipal: string;
+        readonly operation: "reply" | "send";
+        readonly deadlineAtMillis: number;
+        readonly encodedEnvelope: Schema.Json;
+      } | {
+        readonly _tag: "SubtreeBudgetReserved";
+        readonly reservationId: string;
+        readonly executionRunId: string | null;
+        readonly sourceSubmissionId?: string | undefined;
+        readonly childThreadId: string;
+        readonly lifetime: "attached" | "background";
+        readonly depth: number;
+        readonly policy: Schema.Json;
+        readonly grant: {
+          readonly allowedToolNames: readonly string[];
+          readonly maxDepth: number;
+          readonly childLifetimes?: readonly ("attached" | "background")[] | undefined;
+        };
+        readonly budget: {
+          readonly caps: {
+            readonly maxTotalChildInvocations?: number | undefined;
+            readonly maxConcurrentChildren?: number | undefined;
+            readonly maxTurns?: number | undefined;
+            readonly maxToolCalls?: number | undefined;
+            readonly maxDurationMillis?: number | undefined;
+            readonly maxInputTokens?: number | undefined;
+            readonly maxOutputTokens?: number | undefined;
+            readonly maxCostMicrousd?: number | undefined;
+            readonly maxResultBytes?: number | undefined;
+          };
+          readonly allocation: {
+            readonly turns: number;
+            readonly toolCalls: number;
+            readonly durationMillis: number;
+            readonly inputTokens: number;
+            readonly outputTokens: number;
+            readonly costMicrousd: number;
+            readonly resultBytes: number;
+          };
+          readonly descendantInvocations?: number | undefined;
+        };
+      } | {
+        readonly _tag: "RepairAnnotated";
+        readonly reason: string;
+        readonly details: Schema.Json;
+      } | {
+        readonly _tag: "RunContextRecorded";
+        readonly version: 1;
+        readonly runId: string;
+        readonly runScopedInput: Schema.Json;
+        readonly historyFrom: number;
+        readonly historyThrough: number;
+        readonly retained: readonly {
+          readonly recordId: string;
+          readonly sequence: number;
+        }[];
+        readonly historyDigest: string;
+        readonly priorHistoryLength: number;
+        readonly contextWindowId?: string | undefined;
+      } | {
+        readonly _tag: "RunContinuation";
+        readonly version: 1;
+        readonly runId: string;
+        readonly submissionId: string;
+        readonly revision: number;
+        readonly recordCount: number;
+        readonly recordBytes: number;
+        readonly turn: number;
+        readonly turnBytes: number;
+        readonly terminalBytes: number;
+        readonly terminalRecords: number;
+        readonly terminalUsageBytes: number;
+        readonly originalInput: {
+          readonly recordId: string;
+        };
+        readonly savedContext?: {
+          readonly recordId: string;
+        } | undefined;
+        readonly latestResponse?: {
+          readonly recordId: string;
+        } | undefined;
+        readonly terminal?: {
+          readonly recordId: string;
+        } | undefined;
+        readonly lastFact: {
+          readonly recordId: string;
+        };
+        readonly position: "awaiting-model" | "processing-operations" | "settled" | "settling" | "starting" | "unknown" | "waiting-approval" | "waiting-dependency";
+        readonly accounting: {
+          readonly committedTurns: number;
+          readonly toolCalls: number;
+          readonly programmaticToolCalls: number;
+          readonly consecutiveToolFailures: number;
+          readonly finalizationUsed: boolean;
+          readonly modelRestarts: number;
+          readonly modelCalls: number;
+          readonly unobservedModelCalls: number;
+          readonly inputTokens: number;
+          readonly outputTokens: number;
+          readonly lastInputTokens: number;
+          readonly lastOutputTokens: number;
+          readonly costMicrousd: number;
+          readonly accountedToolTurn: number;
+        };
+      };
+    };
+  }[];
+} | {
+  readonly _tag: "ProgressObserved";
+} | {
+  readonly _tag: "ProgressCancelled";
+} | {
+  readonly _tag: "AbortRecorded";
+  readonly intent: {
+    readonly submissionId: string;
+    readonly author: string;
+    readonly reason: string;
+    readonly requestedAt: string;
+    readonly canonicalRecordId?: string | undefined;
+  };
+} | {
+  readonly _tag: "ApprovalRecorded";
+  readonly intent: {
+    readonly submissionId: string;
+    readonly toolCallId: string;
+    readonly decision: "approved" | "denied";
+    readonly resolver: string;
+    readonly reason: string;
+    readonly decidedAt: string;
+    readonly canonicalRecordId?: string | undefined;
+  };
+} | {
+  readonly _tag: "UnknownResolutionRecorded";
+  readonly intent: {
+    readonly submissionId: string;
+    readonly toolCallId: string;
+    readonly author: string;
+    readonly reason: string;
+    readonly resolution: {
+      readonly _tag: "SafeToRetry";
+    } | {
+      readonly _tag: "CompletedWithResult";
+      readonly result: Schema.Json;
+      readonly isFailure: boolean;
+    } | {
+      readonly _tag: "NeverHappened";
+    } | {
+      readonly _tag: "AbortSubmission";
+    };
+    readonly resolvedAt: string;
+    readonly canonicalRecordId?: string | undefined;
+  };
+} | {
+  readonly _tag: "HostFailed";
+  readonly failure: {
+    readonly _tag: "LedgerError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: import("@yielded/agent/failure-diagnostic").Diagnostic | undefined;
+  } | {
+    readonly _tag: "ThreadStoreError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+    readonly diagnostic?: {
+      readonly causeTag: string;
+      readonly operation: string;
+      readonly decoder?: string | undefined;
+      readonly issueTag?: string | undefined;
+      readonly sequence?: number | undefined;
+    } | undefined;
+  } | {
+    readonly _tag: "ThreadNotMaterialized";
+    readonly threadId: string;
+  } | {
+    readonly _tag: "AppendConflict";
+    readonly threadId: string;
+    readonly batchId: string;
+    readonly reason: "batch-content" | "record-identity" | "stale-command" | "tail";
+    readonly actualTailSequence?: number | undefined;
+  } | {
+    readonly _tag: "OwnershipLost";
+    readonly submissionId: string;
+  } | {
+    readonly _tag: "OperationDenied";
+    readonly operation: "abort" | "awaitSettlement" | "explain" | "observe" | "resolveApproval" | "resolveUnknown" | "retry" | "scanObligations" | "verify" | "wake";
+    readonly reason: string;
+    readonly threadId?: string | undefined;
+    readonly submissionId?: string | undefined;
+  } | {
+    readonly _tag: "SettlementConflict";
+    readonly submissionId: string;
+    readonly existingOutcome: "aborted" | "completed" | "failed";
+  } | {
+    readonly _tag: "AdmissionPolicyError";
+    readonly reason: "occupied" | "refused" | "unavailable";
+    readonly code: string;
+    readonly cause?: import("@yielded/agent/failure-diagnostic").Diagnostic | undefined;
+    readonly stack?: string | undefined;
+  } | {
+    readonly _tag: "DigestError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "DurableRuntimeFailpointError";
+    readonly location: "abort:after-intent" | "approval:after-request-append" | "approval:after-suspend" | "claim:after-claim" | "compaction:after-canonical-append" | "compaction:before-canonical-append" | "input:after-canonical-append" | "join:after-canonical-append" | "join:after-claim" | "policy:after-reservation-append" | "policy:before-reservation-append" | "resolve:after-intent" | "run:after-duration-append" | "run:after-start-append" | "run:before-duration-append" | "run:before-start-append" | "step:after-step-append" | "subagent:after-admit" | "subagent:after-child-abort-intent" | "subagent:after-child-ready" | "subagent:after-join-append" | "subagent:after-release" | "subagent:after-release-pending" | "subagent:after-request-append" | "subagent:after-reserve" | "subagent:after-sibling-settle" | "subagent:after-start-append" | "subagent:after-suspend" | "subagent:before-join-append" | "submit:after-admit" | "submit:after-materialize" | "terminalize:after-canonical-append" | "terminalize:before-publication" | "tools:after-dispatch-fence" | "tools:after-unavailable-append" | "tools:before-dispatch-fence" | "tools:before-unavailable-append" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append" | "update:after-canonical-append" | "update:after-delivery-insert" | "update:before-canonical-append" | "update:before-delivery-insert" | "worker:after-completion-append" | "worker:after-origin-append" | "worker:after-report-append" | "worker:after-report-delivery" | "worker:after-source-append" | "worker:after-stop-append" | "worker:after-stop-seal" | "worker:after-subtree-append" | "worker:before-completion-append" | "worker:before-origin-append" | "worker:before-report-append" | "worker:before-report-delivery" | "worker:before-source-append" | "worker:before-stop-append" | "worker:before-stop-seal" | "worker:before-subtree-append";
+  } | {
+    readonly _tag: "AdmissionConflict";
+    readonly threadId: string;
+    readonly principal: string;
+    readonly idempotencyKey: string;
+    readonly existingInputDigest: string;
+    readonly attemptedInputDigest: string;
+  } | {
+    readonly _tag: "AgentInputError";
+    readonly message: string;
+  } | {
+    readonly _tag: "AdmissionLimitExceeded";
+    readonly limit: "database-bytes" | "input-bytes" | "queue-depth";
+    readonly actual: number;
+    readonly maximum: number;
+  } | {
+    readonly _tag: "DurableAlarmError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "HostProtocolError";
+    readonly message: string;
+  } | {
+    readonly _tag: "JoinedToHost";
+    readonly submissionId: string;
+    readonly hostSubmissionId: string;
+  } | {
+    readonly _tag: "ApprovalConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+    readonly existingDecision: "approved" | "denied";
+  } | {
+    readonly _tag: "UnknownResolutionConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+  };
+}, Schema.SchemaError, never>;
+declare const decodeHostResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | SettlementRecordReached | SubmissionStatusResponse | SubmitSucceeded | UnknownResolutionRecorded, Schema.SchemaError, never>;
+/** Failure surface of `CloudflareThreadClient.submit`. */
+declare const ClientSubmitHostFailure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, typeof AdmissionPolicyError, typeof LedgerError, typeof OwnershipLost, typeof ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof HostProtocolError]>;
+declare const ClientAwaitHostFailure: Schema.Union<readonly [typeof LedgerError, typeof OwnershipLost, typeof SettlementConflict, typeof OperationDenied, typeof HostProtocolError]>;
+declare const ClientObserveHostFailure: Schema.Union<readonly [typeof ThreadStoreError, typeof ThreadNotMaterialized, typeof OperationDenied, typeof HostProtocolError]>;
+declare const ClientAbortHostFailure: Schema.Union<readonly [typeof OperationDenied, typeof LedgerError, typeof OwnershipLost, typeof SettlementConflict, typeof JoinedToHost, typeof DurableRuntimeFailpointError, typeof DurableAlarmError, typeof HostProtocolError]>;
+declare const ClientApprovalHostFailure: Schema.Union<readonly [typeof LedgerError, typeof OwnershipLost, typeof SettlementConflict, typeof ApprovalConflict, typeof OperationDenied, typeof DurableAlarmError, typeof HostProtocolError]>;
+declare const ClientUnknownHostFailure: Schema.Union<readonly [typeof LedgerError, typeof OwnershipLost, typeof SettlementConflict, typeof UnknownResolutionConflict, typeof JoinedToHost, typeof DurableRuntimeFailpointError, typeof OperationDenied, typeof DurableAlarmError, typeof HostProtocolError]>;
+type ClientSubmitFailure = typeof ClientSubmitHostFailure.Type | ThreadClientError;
+type ClientAwaitFailure = typeof ClientAwaitHostFailure.Type | ThreadClientError;
+type ClientObserveFailure = typeof ClientObserveHostFailure.Type | ThreadClientError;
+type ClientProgressFailure = ClientObserveFailure;
+type ClientAbortFailure = typeof ClientAbortHostFailure.Type | ThreadClientError;
+type ClientApprovalFailure = typeof ClientApprovalHostFailure.Type | ThreadClientError;
+type ClientUnknownFailure = typeof ClientUnknownHostFailure.Type | ThreadClientError;
+declare const CloudflareThreadClient_base: Context.ServiceClass<CloudflareThreadClient, "@effect-agent/platform-cloudflare/CloudflareThreadClient", {
+  /** Encode the input client-side, then durably submit to the owning Object. */
+  readonly submit: <InputSchema extends Schema.Top>(agent: DurableSubmitAgent<InputSchema>, input: InputSchema["Type"], options: DurableSubmitOptions) => Effect.Effect<Receipt, ClientSubmitFailure, InputSchema["EncodingServices"]>;
+  /** Wake-hinted, poll-guaranteed settlement wait executed inside the owning Object. */
+  readonly submissionStatus: (receipt: Receipt) => Effect.Effect<SubmissionStatus, ClientAwaitFailure>;
+  readonly awaitSettlement: (receipt: Receipt) => Effect.Effect<Settlement, ClientAwaitFailure>;
+  /**
+   * Wait for finalization and return this Receipt's canonical terminal record in one RPC.
+   * Requires both settlement and observation authority. Decode an ordinary completed
+   * record's result through the Agent output Schema; joined completion may have no result.
+   */
+  readonly awaitSettlementRecord: (receipt: Receipt) => Effect.Effect<SubmissionSettledRecord, ClientAwaitFailure>;
+  /**
+   * Wait without polling until progress after `afterSequence` is already durable or hinted.
+   * The result is deliberately void: canonical records remain authoritative and must be read.
+   * Interruption waits at most one second for best-effort remote cancellation.
+   */
+  readonly awaitProgress: (threadId: ThreadId, afterSequence: CanonicalSequence) => Effect.Effect<void, ClientProgressFailure>;
+  /**
+   * Current provisional text followed by native deltas. Reset starts a replacement snapshot,
+   * including when a slow consumer exceeds the fixed backlog. Reconcile by
+   * Run/Turn identity to canonical records; discard drafts on Discard, AttemptEnded,
+   * Reset or stream failure. Snapshots exist only in the Object incarnation's memory.
+   * Scope the stream: interruption cancels its remote subscription.
+   */
+  readonly watchText: (threadId: ThreadId) => Stream.Stream<Frame, ClientObserveFailure>;
+  /** One bounded page of canonical records. */
+  readonly readPage: (threadId: ThreadId, options?: {
+    readonly afterSequence?: CanonicalSequence | undefined;
+    readonly limit?: number | undefined;
+  }) => Effect.Effect<ReadonlyArray<CanonicalRecordEnvelope>, ClientObserveFailure>;
+  /**
+   * Every canonical record up to the CURRENT committed tail, via repeated pages. A
+   * snapshot read, not a live observation — callers wanting liveness re-read after
+   * `awaitSettlement`.
+   */
+  readonly readAll: (threadId: ThreadId) => Effect.Effect<ReadonlyArray<CanonicalRecordEnvelope>, ClientObserveFailure>;
+  /**
+   * Submission-addressed operations take the owning Thread explicitly (from the
+   * Receipt): minted Submission identities stay OPAQUE outside the storage adapter that
+   * minted them (D-P6-5), so the client never parses one to find the lane.
+   */
+  readonly abort: (threadId: ThreadId, command: AbortCommand) => Effect.Effect<AbortIntent, ClientAbortFailure>;
+  readonly resolveApproval: (threadId: ThreadId, command: ApprovalDecisionCommand) => Effect.Effect<ApprovalDecisionIntent, ClientApprovalFailure>;
+  readonly resolveUnknown: (threadId: ThreadId, command: UnknownResolutionCommand) => Effect.Effect<UnknownResolutionIntent, ClientUnknownFailure>;
+}>;
+/** Worker-side client over the Thread Object namespace (DEPLOY-010). */
+declare class CloudflareThreadClient extends CloudflareThreadClient_base {
+  /**
+   * Assemble the client from a resolved namespace and the platform Crypto implementation.
+   * rpcTracing is the binding name and remains opt-in. Caller authentication, principals,
+   * idempotency keys, and definition digests are still explicit submission inputs.
+   */
+  static layerFromBinding(options: {
+    readonly namespace: DurableObjectNamespace<ThreadObjectRpc>;
+    readonly rpcTracing?: string;
+  }): Layer.Layer<CloudflareThreadClient>;
+  static readonly layer: Layer.Layer<CloudflareThreadClient, never, ThreadObjectNamespace | Crypto.Crypto>;
+}
+//#endregion
+export { decodeAbortCommand as A, encodeApprovalDecisionCommand as B, SettlementRecordReached as C, ThreadClientError as D, SubmitSucceeded as E, decodeObservePageRequest as F, encodeReceipt as G, encodeCancelProgressRequest as H, decodeReceipt as I, Frame as J, encodeSubmitRequest as K, decodeSubmitRequest as L, decodeAwaitProgressRequest as M, decodeCancelProgressRequest as N, UnknownResolutionRecorded as O, decodeHostResponse as P, decodeUnknownResolutionCommand as R, SettlementReached as S, SubmitRequest as T, encodeHostResponse as U, encodeAwaitProgressRequest as V, encodeObservePageRequest as W, HostResponse as _, ClientAbortFailure as a, ProgressCancelled as b, ClientObserveFailure as c, ClientUnknownFailure as d, CloudflareThreadClient as f, HostProtocolError as g, HostFailure as h, CancelProgressRequest as i, decodeApprovalDecisionCommand as j, boundHostDiagnostic as k, ClientProgressFailure as l, HostFailed as m, ApprovalRecorded as n, ClientApprovalFailure as o, CloudflareThreadClient_d_exports as p, encodeUnknownResolutionCommand as q, AwaitProgressRequest as r, ClientAwaitFailure as s, AbortRecorded as t, ClientSubmitFailure as u, ObservePageRequest as v, SubmissionStatusResponse as w, ProgressObserved as x, ObservedPage as y, encodeAbortCommand as z };
+//# sourceMappingURL=CloudflareThreadClient-QsVzLGGZ.d.mts.map