@effect-agent/platform-cloudflare 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/CloudflareThreadClient.d.mts

@@ -0,0 +1,1496 @@
+import { ThreadObjectNamespace, ThreadObjectRpc } from "./CloudflareBindings.mjs";
+import { t as AdmissionLimitExceeded } from "./CloudflareConfig-f3CqTel1.mjs";
+import { DurableAlarmError } from "./Alarm.mjs";
+import { Context, Crypto, Effect, Layer, Schema } from "effect";
+import { DurableSubmitAgent, DurableSubmitOptions, Receipt } from "effect-agent/durable-agent-runtime";
+import { ThreadId } from "effect-agent/identifiers";
+import { AbortCommand, AbortIntent, AdmissionConflict, AdmissionPolicyError, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, JoinedToHost, LedgerError, Settlement, SettlementConflict, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent } from "effect-agent/submission-ledger";
+import { CanonicalRecordEnvelope, CanonicalSequence, DefinitionDigests } from "effect-agent/records";
+import { AgentInputError } from "effect-agent/agent-error";
+import { DigestError } from "effect-agent/digest";
+import { DurableRuntimeFailpointError } from "effect-agent/durable-failpoint";
+import { OperationDenied } from "effect-agent/operation-authorizer";
+import { SubmissionStatus } from "effect-agent/submission-status";
+import { AppendConflict, FenceRejected, ThreadNotMaterialized, ThreadStoreError } from "effect-agent/thread-store";
+declare namespace CloudflareThreadClient_d_exports {
+  export { AbortRecorded, ApprovalRecorded, AwaitProgressRequest, CancelProgressRequest, ClientAbortFailure, ClientApprovalFailure, ClientAwaitFailure, ClientObserveFailure, ClientProgressFailure, ClientSubmitFailure, ClientUnknownFailure, CloudflareThreadClient, HostFailed, HostFailure, HostProtocolError, HostResponse, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, SettlementReached, 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 budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+      readonly targetDigests: typeof DefinitionDigests;
+      readonly policy: Schema.toCodecJson<typeof import("effect-agent/agent-policy").AgentPolicy>;
+      readonly budget: Schema.Struct<{
+        readonly caps: typeof import("effect-agent/subagent-contract").SubagentDelegationCaps;
+        readonly allocation: typeof import("effect-agent/subagent-contract").SubagentReservationAmounts;
+        readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+      }>;
+      readonly grant: typeof import("effect-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 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("effect-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("effect-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 ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof FenceRejected, 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("effect-agent/submission-status").PendingSubmission, typeof import("effect-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 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 ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof FenceRejected, 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 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 budgetScope?: "source-subtree" | "worker-run" | undefined;
+      readonly targetDigests: {
+        readonly agent: string;
+        readonly model: string;
+        readonly tools: string;
+      };
+      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 destinationDelegationId?: string | undefined;
+      } | undefined;
+    };
+    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 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: "CompletedWithResult";
+    readonly result: Schema.Json;
+    readonly isFailure: boolean;
+  } | {
+    readonly _tag: "NeverHappened";
+  } | {
+    readonly _tag: "SafeToRetry";
+  } | {
+    readonly _tag: "AbortSubmission";
+  };
+}, Schema.SchemaError, never>;
+declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | 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 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 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;
+      } | 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 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 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;
+    } | undefined;
+    readonly settledAt: string;
+  };
+} | {
+  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: "ThreadCreated";
+        readonly agentId: string;
+        readonly definitions: {
+          readonly agent: string;
+          readonly model: string;
+          readonly tools: string;
+        };
+      } | {
+        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: "RunStarted";
+        readonly runId: string;
+        readonly policyAccountingVersion: 1;
+        readonly maxDurationMillis: number;
+      } | {
+        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 _tag: "ModelResponseRecorded";
+        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 messagesDigest: string;
+        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 costMicrousd: number;
+        }[] | undefined;
+        readonly unobservedModelCalls?: number | undefined;
+        readonly inputTokens?: number | undefined;
+        readonly outputTokens?: number | undefined;
+        readonly costMicrousd?: number | undefined;
+      } | {
+        readonly _tag: "ToolCallPrepared";
+        readonly runId: string;
+        readonly turnId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly parameters: Schema.Json;
+        readonly parametersDigest: string;
+        readonly executionKind?: "delegation" | "orchestration" | "ordinary" | 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 _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 supersededEpoch: number;
+        readonly attemptId: string;
+        readonly reason: string;
+      } | {
+        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: "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 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 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 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 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 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 childResultDigest: string;
+        readonly projectedResultDigest: string;
+        readonly usageSummary: Schema.Json;
+        readonly usage?: {
+          readonly modelCalls: number;
+          readonly inputTokens: number;
+          readonly outputTokens: number;
+          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 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 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 budgetScope?: "source-subtree" | "worker-run" | undefined;
+            readonly targetDigests: {
+              readonly agent: string;
+              readonly model: string;
+              readonly tools: string;
+            };
+            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 destinationDelegationId?: string | undefined;
+            } | undefined;
+          };
+          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: "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 budgetScope?: "source-subtree" | "worker-run" | undefined;
+          readonly targetDigests: {
+            readonly agent: string;
+            readonly model: string;
+            readonly tools: string;
+          };
+          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 destinationDelegationId?: string | undefined;
+          } | undefined;
+        };
+      } | {
+        readonly _tag: "WorkerInputCompleted";
+        readonly messageId: string;
+        readonly workerThreadId: string;
+        readonly submissionId: string;
+        readonly receiptId: string;
+        readonly settlementId: string;
+        readonly completedAtMillis: number;
+      } | {
+        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 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" | "input" | "preparation" | "projection" | "timeout";
+      } | {
+        readonly _tag: "PeerMessagePrepared";
+        readonly messageId: string;
+        readonly sourcePrincipal: string;
+        readonly operation: "reply" | "send";
+        readonly deadlineAtMillis: number;
+        readonly encodedEnvelope: Schema.Json;
+      } | {
+        readonly _tag: "SubtreeBudgetReserved";
+        readonly reservationId: string;
+        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: "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: "CompletedWithResult";
+      readonly result: Schema.Json;
+      readonly isFailure: boolean;
+    } | {
+      readonly _tag: "NeverHappened";
+    } | {
+      readonly _tag: "SafeToRetry";
+    } | {
+      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?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "AppendConflict";
+    readonly threadId: string;
+    readonly batchId: string;
+    readonly reason: "batch-digest" | "record-identity" | "tail";
+    readonly actualTailSequence?: number | undefined;
+    readonly actualTailDigest?: string | undefined;
+  } | {
+    readonly _tag: "FenceRejected";
+    readonly threadId: string;
+    readonly actualEpoch: number;
+    readonly attemptedEpoch: number;
+  } | {
+    readonly _tag: "ThreadNotMaterialized";
+    readonly threadId: string;
+  } | {
+    readonly _tag: "ThreadStoreError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    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: "AdmissionConflict";
+    readonly threadId: string;
+    readonly principal: string;
+    readonly idempotencyKey: string;
+    readonly existingInputDigest: string;
+    readonly attemptedInputDigest: string;
+  } | {
+    readonly _tag: "AdmissionPolicyError";
+    readonly reason: "occupied" | "refused" | "unavailable";
+    readonly code: string;
+  } | {
+    readonly _tag: "AgentInputError";
+    readonly message: string;
+  } | {
+    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" | "checkpoint:after-save" | "checkpoint:before-save" | "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-start-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:after-reserve" | "tools:after-prepared-append" | "tools:before-prepared-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-subtree-append" | "worker:before-completion-append" | "worker:before-origin-append" | "worker:before-report-append" | "worker:before-report-delivery" | "worker:before-source-append" | "worker:before-subtree-append";
+  } | {
+    readonly _tag: "SettlementConflict";
+    readonly submissionId: string;
+    readonly existingOutcome: "aborted" | "completed" | "failed";
+  } | {
+    readonly _tag: "JoinedToHost";
+    readonly submissionId: string;
+    readonly hostSubmissionId: string;
+  } | {
+    readonly _tag: "DurableAlarmError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "HostProtocolError";
+    readonly message: string;
+  } | {
+    readonly _tag: "ApprovalConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+    readonly existingDecision: "approved" | "denied";
+  } | {
+    readonly _tag: "UnknownResolutionConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+  } | {
+    readonly _tag: "AdmissionLimitExceeded";
+    readonly limit: "database-bytes" | "input-bytes" | "queue-depth";
+    readonly actual: number;
+    readonly maximum: number;
+  };
+}, Schema.SchemaError, never>;
+declare const decodeHostResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | 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 ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof FenceRejected, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof HostProtocolError]>;
+declare const ClientAwaitHostFailure: Schema.Union<readonly [typeof LedgerError, 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 SettlementConflict, typeof JoinedToHost, typeof DurableRuntimeFailpointError, typeof DurableAlarmError, typeof HostProtocolError]>;
+declare const ClientApprovalHostFailure: Schema.Union<readonly [typeof LedgerError, typeof SettlementConflict, typeof ApprovalConflict, typeof OperationDenied, typeof DurableAlarmError, typeof HostProtocolError]>;
+declare const ClientUnknownHostFailure: Schema.Union<readonly [typeof LedgerError, 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 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>;
+  /** 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 { AbortRecorded, ApprovalRecorded, AwaitProgressRequest, CancelProgressRequest, ClientAbortFailure, ClientApprovalFailure, ClientAwaitFailure, ClientObserveFailure, ClientProgressFailure, ClientSubmitFailure, ClientUnknownFailure, CloudflareThreadClient, HostFailed, HostFailure, HostProtocolError, HostResponse, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, SettlementReached, SubmissionStatusResponse, SubmitRequest, SubmitSucceeded, ThreadClientError, UnknownResolutionRecorded, boundHostDiagnostic, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, CloudflareThreadClient_d_exports as t };
+//# sourceMappingURL=CloudflareThreadClient.d.mts.map