@effect-agent/platform-cloudflare 0.1.0-beta.45 → 0.1.0-beta.47

package/dist/CloudflareThreadClient.d.mts

@@ -0,0 +1,715 @@
+import { ThreadObjectNamespace, ThreadObjectRpc } from "./CloudflareBindings.mjs";
+import { t as AdmissionLimitExceeded } from "./CloudflareConfig-f3CqTel1.mjs";
+import { DurableAlarmError } from "./Alarm.mjs";
+import { DurableSubmitAgent, DurableSubmitOptions, Receipt } from "@effect-agent/thread/DurableAgentRuntime";
+import { AbortCommand, AbortIntent, AdmissionConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, JoinedToHost, LedgerError, Settlement, SettlementConflict, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent } from "@effect-agent/thread/SubmissionLedger";
+import { Context, Crypto, Effect, Layer, Schema } from "effect";
+import { ThreadId } from "@effect-agent/core/Identifiers";
+import { CanonicalRecordEnvelope, CanonicalSequence, DefinitionDigests } from "@effect-agent/thread/Records";
+import { AgentInputError } from "@effect-agent/core/AgentError";
+import { DigestError } from "@effect-agent/thread/Digest";
+import { DurableRuntimeFailpointError } from "@effect-agent/thread/DurableFailpoint";
+import { OperationDenied } from "@effect-agent/thread/OperationAuthorizer";
+import { AppendConflict, FenceRejected, ThreadNotMaterialized, ThreadStoreError } from "@effect-agent/thread/ThreadStore";
+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, 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 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 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 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 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 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 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 | 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: "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 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;
+      }[];
+    } | 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 _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 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 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 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" | "ordinary" | undefined;
+      } | {
+        readonly _tag: "ToolCallSettled";
+        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" | "summarize";
+        readonly coversThrough: number;
+        readonly summary?: 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 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;
+          }[];
+        } | 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;
+          };
+        } | 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 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 _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: "HostProtocolError";
+    readonly message: string;
+  } | {
+    readonly _tag: "AgentInputError";
+    readonly message: string;
+  } | {
+    readonly _tag: "DigestError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "AdmissionConflict";
+    readonly threadId: string;
+    readonly principal: string;
+    readonly idempotencyKey: string;
+    readonly existingInputDigest: string;
+    readonly attemptedInputDigest: string;
+  } | {
+    readonly _tag: "SettlementConflict";
+    readonly submissionId: string;
+    readonly existingOutcome: "aborted" | "completed" | "failed";
+  } | {
+    readonly _tag: "ApprovalConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+    readonly existingDecision: "approved" | "denied";
+  } | {
+    readonly _tag: "UnknownResolutionConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+  } | {
+    readonly _tag: "JoinedToHost";
+    readonly submissionId: string;
+    readonly hostSubmissionId: string;
+  } | {
+    readonly _tag: "LedgerError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "ThreadStoreError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "ThreadNotMaterialized";
+    readonly threadId: string;
+  } | {
+    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: "DurableRuntimeFailpointError";
+    readonly location: "abort:after-intent" | "approval:after-request-append" | "approval:after-suspend" | "claim:after-claim" | "compaction:after-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" | "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";
+  } | {
+    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: "OperationDenied";
+    readonly operation: "abort" | "awaitSettlement" | "explain" | "observe" | "resolveApproval" | "resolveUnknown" | "retry" | "scanObligations" | "verify" | "wake";
+    readonly reason: string;
+    readonly threadId?: string | undefined;
+    readonly submissionId?: string | undefined;
+  };
+}, Schema.SchemaError, never>;
+declare const decodeHostResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | SubmitSucceeded | UnknownResolutionRecorded, Schema.SchemaError, never>;
+/** Failure surface of `CloudflareThreadClient.submit`. */
+declare const ClientSubmitHostFailure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, 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 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.
+   */
+  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, 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