@effect-agent/platform-cloudflare 0.1.0-beta.33 → 0.1.0-beta.34

package/dist/index.d.mts

@@ -6,10 +6,9 @@ import { Context, Crypto, Effect, Layer, Option, Schema, Scope } from "effect";
 import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationStore, ConversationStoreError, DefinitionDigests, DigestError, DurableAgentRuntime, DurableBindingFailure, DurableRuntimeConfig, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableSubmitAgent, DurableSubmitOptions, DurableWorkerFailure, FenceRejected, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizerService, OperationDenied, OwnershipLost, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, ResolvedBinding, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler } from "@effect-agent/session";
 import { ConversationPortTransport, DoStorageFailpointHandler, DoStorageInitializationError, PortRequest, PortResponse } from "@effect-agent/storage-cloudflare";
 import { AgentInputError, ConversationId } from "@effect-agent/core";
-import { RunContextPreparation, RunCostEstimator } from "@effect-agent/engine";
-import { DurableObjectState as DurableObjectState$1, WorkerEnvironment } from "effect-cf";
+import { RunContextPreparation, RunCostEstimator, RunToolFailureObserver } from "@effect-agent/engine";
+import { DurableObject, DurableObjectState as DurableObjectState$1, WorkerEnvironment } from "effect-cf";
 import { CodeExecutor, SandboxImplementation } from "@effect-agent/sandbox";
-import { DurableObject as DurableObject$1 } from "cloudflare:workers";
 //#region src/bindings.d.ts
 declare const CloudflareBindingError_base: Schema.Class<CloudflareBindingError, Schema.TaggedStruct<"CloudflareBindingError", {
   readonly binding: Schema.String;
@@ -29,25 +28,27 @@ declare class CloudflareBindingError extends CloudflareBindingError_base {}
  * and the cross-Object transport call it through `DurableObjectNamespace` stubs. Every
  * `encoded` value is a Schema-encoded envelope (`client.ts` wire schemas for host entry
  * points, `@effect-agent/storage-cloudflare` port envelopes for `portCall`), so the RPC
- * boundary carries only structured-cloneable JSON.
+ * boundary carries only structured-cloneable JSON. The optional trailing trace context is
+ * transient native RPC metadata, stripped by an opted-in effect-cf receiver before decoding
+ * the host envelope. It never enters durable state.
  */
 interface ConversationObjectRpc extends Rpc.DurableObjectBranded {
   /** Admission-limits gate + `DurableAgentRuntime.submit`; answers a `SubmitResponse`. */
-  submitEncoded(encoded: unknown): Promise<unknown>;
+  submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** Wake-hinted, poll-guaranteed settlement wait; answers an `AwaitSettlementResponse`. */
-  awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
+  awaitSettlementEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** Event-driven durable progress wait; answers a `ProgressObserved` host response. */
-  awaitProgressEncoded(encoded: unknown): Promise<unknown>;
+  awaitProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** Best-effort cancellation for one in-flight progress wait. */
-  cancelProgressEncoded(encoded: unknown): Promise<unknown>;
+  cancelProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** One bounded page of canonical records; answers an `ObservePageResponse`. */
-  observePage(encoded: unknown): Promise<unknown>;
+  observePage(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** Durable abort intent; answers an `AbortResponse`. */
-  abortEncoded(encoded: unknown): Promise<unknown>;
+  abortEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** Durable approval decision (plan §2.6); answers a `ResolveApprovalResponse`. */
-  resolveApprovalEncoded(encoded: unknown): Promise<unknown>;
+  resolveApprovalEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** Authorized DUR-017 Unknown-Outcome resolution; answers a `ResolveUnknownResponse`. */
-  resolveUnknownEncoded(encoded: unknown): Promise<unknown>;
+  resolveUnknownEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   /** Owner-side cross-Object port endpoint (WP2 envelopes, executed on LOCAL facets). */
   portCall(encoded: unknown): Promise<unknown>;
   /** Droppable liveness hint from another Object: arms an immediate alarm. */
@@ -55,6 +56,8 @@ interface ConversationObjectRpc extends Rpc.DurableObjectBranded {
 }
 declare const ConversationObjectNamespace_base: Context.ServiceClass<ConversationObjectNamespace, "@effect-agent/platform-cloudflare/ConversationObjectNamespace", {
   readonly namespace: DurableObjectNamespace<ConversationObjectRpc>;
+  /** Stable binding name for opted-in native RPC tracing; absent by default. */
+  readonly rpcTracing?: string;
 }>;
 /**
  * The `DurableObjectNamespace` binding that addresses Conversation Objects. The Object
@@ -71,8 +74,13 @@ declare class ConversationObjectNamespace extends ConversationObjectNamespace_ba
  * a missing or misshaped binding fails typed before any Layer is built.
  */
 declare const conversationNamespaceFromEnv: (env: unknown, binding: string) => Effect.Effect<DurableObjectNamespace<ConversationObjectRpc>, CloudflareBindingError, never>;
-/** `ConversationObjectNamespace` built from the untyped Worker `env` (fails typed). */
-declare const conversationNamespaceLayer: (env: unknown, binding: string) => Layer.Layer<ConversationObjectNamespace, CloudflareBindingError>;
+/**
+ * Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the
+ * receiver also opts into the effect-cf native RPC trace-context contract.
+ */
+declare const conversationNamespaceLayer: (env: unknown, binding: string, options?: {
+  readonly rpcTracing?: boolean;
+}) => Layer.Layer<ConversationObjectNamespace, CloudflareBindingError>;
 declare const DurableObjectContext_base: Context.ServiceClass<DurableObjectContext, "@effect-agent/platform-cloudflare/DurableObjectContext", {
   readonly ctx: DurableObjectState;
   readonly env: unknown;
@@ -375,6 +383,8 @@ interface CloudflareDurableRuntimeOptions {
   readonly abortPollInterval?: number | undefined;
   /** Deployment-owned pricing authority used by durable cost budgets and settlements. */
   readonly estimateCostMicrousd?: RunCostEstimator | undefined;
+  /** Closed trusted Tool failure reporting. Omission masks ambient observers at construction. */
+  readonly toolFailureObserver?: RunToolFailureObserver | undefined;
   /** Milliseconds; default 25. */
   readonly observationPollInterval?: number | undefined;
   /** Bytes; default just under the 2 MB platform value limit. */
@@ -717,6 +727,10 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly kind: "follow-up" | "steering" | "user";
         readonly runId?: string | undefined;
         readonly input: Schema.Json;
+      } | {
+        readonly _tag: "RunStarted";
+        readonly runId: string;
+        readonly maxDurationMillis: number;
       } | {
         readonly _tag: "ModelCompleted";
         readonly runId: string;
@@ -1052,7 +1066,7 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
     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" | "resolve:after-intent" | "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" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
+    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" | "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" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
   } | {
     readonly _tag: "AdmissionLimitExceeded";
     readonly limit: "database-bytes" | "input-bytes" | "queue-depth";
@@ -1141,6 +1155,8 @@ declare class CloudflareConversationClient extends CloudflareConversationClient_
  */
 /** Construction options for one deployed Conversation Object class. */
 interface ConversationObjectOptions extends CloudflareDurableRuntimeOptions {
+  /** Accept transient native RPC tracing through effect-cf; disabled by default. */
+  readonly rpcTracing?: boolean;
   /**
    * Name of the Worker `env` binding carrying THIS class's `DurableObjectNamespace` — the
    * Object's route back to sibling Conversation Objects for the WP2 cross-Object port calls
@@ -1148,6 +1164,8 @@ interface ConversationObjectOptions extends CloudflareDurableRuntimeOptions {
    */
   readonly namespaceBinding: string;
 }
+type EndpointServices = CloudflareDurableRuntimeServices | DurableObjectContext;
+type RuntimeServices = EndpointServices | ConversationObjectNamespace;
 declare const AdminExplainRequest_base: Schema.Class<AdminExplainRequest, Schema.Struct<{
   readonly submissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
 }>, {}>;
@@ -1597,20 +1615,43 @@ declare const encodeAdminResponse: (input: AdminFailed | ExplainedRecovery | Obl
 } | {
   readonly _tag: "AdminFailed";
   readonly failure: {
+    readonly _tag: "DurableAlarmError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
     readonly _tag: "OperationDenied";
     readonly operation: "explain" | "observe" | "resolveApproval" | "resolveUnknown" | "retry" | "scanObligations" | "verify" | "wake";
     readonly reason: string;
     readonly conversationId?: string | undefined;
     readonly submissionId?: string | undefined;
   } | {
-    readonly _tag: "DigestError";
+    readonly _tag: "RetryRefused";
+    readonly submissionId: string;
+    readonly refusal: "await-approval-decision" | "await-unknown-resolution" | "settled";
+    readonly decisionTag: string;
     readonly message: string;
-    readonly cause?: Schema.Json | undefined;
   } | {
     readonly _tag: "LedgerError";
     readonly operation: string;
     readonly message: string;
     readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "RunJournalError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "DigestError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "OwnershipLost";
+    readonly submissionId: string;
+    readonly actualEpoch: number;
+  } | {
+    readonly _tag: "SettlementConflict";
+    readonly submissionId: string;
+    readonly existingOutcome: "aborted" | "completed" | "failed";
   } | {
     readonly _tag: "ConversationStoreError";
     readonly operation: string;
@@ -1633,46 +1674,23 @@ declare const encodeAdminResponse: (input: AdminFailed | ExplainedRecovery | Obl
     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" | "resolve:after-intent" | "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" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
-  } | {
-    readonly _tag: "DurableAlarmError";
-    readonly operation: string;
-    readonly message: string;
-    readonly cause?: Schema.Json | undefined;
+    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" | "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" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
   } | {
     readonly _tag: "HostProtocolError";
     readonly message: string;
-  } | {
-    readonly _tag: "SettlementConflict";
-    readonly submissionId: string;
-    readonly existingOutcome: "aborted" | "completed" | "failed";
-  } | {
-    readonly _tag: "RetryRefused";
-    readonly submissionId: string;
-    readonly refusal: "await-approval-decision" | "await-unknown-resolution" | "settled";
-    readonly decisionTag: string;
-    readonly message: string;
-  } | {
-    readonly _tag: "RunJournalError";
-    readonly message: string;
-    readonly cause?: Schema.Json | undefined;
-  } | {
-    readonly _tag: "OwnershipLost";
-    readonly submissionId: string;
-    readonly actualEpoch: number;
   };
 }, Schema.SchemaError, never>;
 declare const decodeAdminResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AdminFailed | ExplainedRecovery | ObligationsScanned | RetryExecuted | VerifiedIntegrity, Schema.SchemaError, never>;
-/** The public endpoint surface of one Conversation Object instance. */
-interface ConversationObjectInstance extends DurableObject$1 {
-  submitEncoded(encoded: unknown): Promise<unknown>;
-  awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
-  awaitProgressEncoded(encoded: unknown): Promise<unknown>;
-  cancelProgressEncoded(encoded: unknown): Promise<unknown>;
-  observePage(encoded: unknown): Promise<unknown>;
-  abortEncoded(encoded: unknown): Promise<unknown>;
-  resolveApprovalEncoded(encoded: unknown): Promise<unknown>;
-  resolveUnknownEncoded(encoded: unknown): Promise<unknown>;
+/** The public endpoints and effect-cf invocation hook of one Conversation Object instance. */
+interface ConversationObjectInstance<EventServices = never> extends InstanceType<DurableObject.DurableObjectClass<Record<never, never>, RuntimeServices | EventServices>> {
+  submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  awaitSettlementEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  awaitProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  cancelProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  observePage(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  abortEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  resolveApprovalEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  resolveUnknownEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
   explainEncoded(encoded: unknown): Promise<unknown>;
   verifyEncoded(encoded: unknown): Promise<unknown>;
   retryEncoded(encoded: unknown): Promise<unknown>;
@@ -1682,8 +1700,8 @@ interface ConversationObjectInstance extends DurableObject$1 {
   alarm(alarmInfo?: AlarmInvocationInfo): Promise<void> | void;
 }
 /** The constructor shape workerd instantiates for each Conversation Object. */
-interface ConversationObjectClass {
-  new (ctx: DurableObjectState, env: Cloudflare.Env): ConversationObjectInstance;
+interface ConversationObjectClass<EventServices = never> {
+  new (ctx: DurableObjectState, env: Cloudflare.Env): ConversationObjectInstance<EventServices>;
 }
 /**
  * Build the application's Conversation Object class (export it from the Worker entry).
@@ -1692,7 +1710,7 @@ interface ConversationObjectClass {
  * event, so a host can install Tracer/Logger/Metric services and `OtlpExporter.Flusher` without
  * Effect Agent owning exporter lifecycle machinery.
  */
-declare const makeConversationObjectClass: <EventLayerError = never, EventServices = never>(options: ConversationObjectOptions, observability?: Layer.Layer<EventServices, EventLayerError, DurableObjectContext | ConversationObjectNamespace | DurableObjectState$1.DurableObjectState | WorkerEnvironment>) => ConversationObjectClass;
+declare const makeConversationObjectClass: <EventLayerError = never, EventServices = never>(options: ConversationObjectOptions, observability?: Layer.Layer<EventServices, EventLayerError, DurableObjectContext | ConversationObjectNamespace | DurableObjectState$1.DurableObjectState | WorkerEnvironment>) => ConversationObjectClass<EventServices>;
 //#endregion
 //#region src/code-mode-executor.d.ts
 /**

package/dist/index.mjs

@@ -6,10 +6,10 @@ import { Clock, Context, Crypto, Deferred, Duration, Effect, Exit, Fiber, Layer,
 import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationRead, ConversationStore, ConversationStoreError, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IdempotencyKey, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, Principal, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler, makeWakeSubscriptionHub, operationAuthorizerLayer } from "@effect-agent/session";
 import { ConversationPortTransport, DEFAULT_MAX_STORED_VALUE_BYTES, conversationStoreLayer, decodePortRequest, encodePortResponse, executePortRequest, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer } from "@effect-agent/storage-cloudflare";
 import { AgentId, AgentInputError, ConversationId, SubmissionId } from "@effect-agent/core";
-import { RunContextPreparationPassthrough } from "@effect-agent/engine";
+import { CurrentToolFailureObserver, RunContextPreparationPassthrough, toolFailureObserverLayer } from "@effect-agent/engine";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-import { DurableObject, DurableObjectState, WorkerEnvironment } from "effect-cf";
+import { DurableObject, DurableObjectState, RpcTracing, WorkerEnvironment } from "effect-cf";
 import { CodeExecutionHost, CodeExecutionProtocolError, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallLimitError, CodeHostCallResult, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, SandboxImplementation } from "@effect-agent/sandbox";
 import { RpcTarget } from "cloudflare:workers";
 //#region src/bindings.ts
@@ -64,8 +64,14 @@ const conversationNamespaceFromEnv = Effect.fn("conversationNamespaceFromEnv")(f
 		message: `env.${binding} is not a DurableObjectNamespace binding; declare the Conversation Object class under this binding in the Worker configuration.`
 	});
 });
-/** `ConversationObjectNamespace` built from the untyped Worker `env` (fails typed). */
-const conversationNamespaceLayer = (env, binding) => Layer.effect(ConversationObjectNamespace)(Effect.map(conversationNamespaceFromEnv(env, binding), (namespace) => ({ namespace })));
+/**
+* Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the
+* receiver also opts into the effect-cf native RPC trace-context contract.
+*/
+const conversationNamespaceLayer = (env, binding, options = {}) => Layer.effect(ConversationObjectNamespace)(Effect.map(conversationNamespaceFromEnv(env, binding), (namespace) => ({
+	namespace,
+	...options.rpcTracing === true ? { rpcTracing: binding } : {}
+})));
 /**
 * The live Durable Object execution context of THIS incarnation. Only Layer construction and
 * the alarm service consume it; important state never lives on it (`ctx.storage` is truth,
@@ -765,6 +771,7 @@ var CloudflareDurableRuntime = class {
 			const maintenanceFailpointLayer = options.maintenanceFailpoint === void 0 ? ConversationMaintenanceFailpoint.layer : Layer.succeed(ConversationMaintenanceFailpoint)({ hit: options.maintenanceFailpoint(ctx) });
 			const reconcilerLayer = options.toolReconciler ?? ToolReconciler.uncertain;
 			const authorizerLayer = options.operationAuthorizer === void 0 ? Layer.empty : operationAuthorizerLayer(options.operationAuthorizer);
+			const observerLayer = options.toolFailureObserver === void 0 ? Layer.succeed(CurrentToolFailureObserver)(void 0) : toolFailureObserverLayer(options.toolFailureObserver);
 			const bindingResolverLayer = Layer.effect(AgentBindingResolver)(Effect.map(resolveBindings(options.bindings, {
 				ctx,
 				env,
@@ -778,7 +785,7 @@ var CloudflareDurableRuntime = class {
 				producerId
 			}).pipe(Layer.provide(BrowserCrypto.layer));
 			const base = Layer.mergeAll(identityLayer, cloudflareConfigLayer, DurableAlarmService.layer, maintenanceFailpointLayer, ProgressWaitRegistry.layer);
-			const runtimeStack = DurableAgentRuntime.layerWithContext.pipe(Layer.provideMerge(routedPorts), Layer.provideMerge(cloudflareWakeSchedulerLayer), Layer.provideMerge(runtimeConfigLayer), Layer.provideMerge(bindingResolverLayer), Layer.provide(Layer.mergeAll(runtimeFailpointLayer, reconcilerLayer, authorizerLayer, runContextLayer, BrowserCrypto.layer)), Layer.provideMerge(base));
+			const runtimeStack = DurableAgentRuntime.layerWithContext.pipe(Layer.provideMerge(routedPorts), Layer.provideMerge(cloudflareWakeSchedulerLayer), Layer.provideMerge(runtimeConfigLayer), Layer.provideMerge(bindingResolverLayer), Layer.provide(Layer.mergeAll(runtimeFailpointLayer, reconcilerLayer, authorizerLayer, observerLayer, runContextLayer, BrowserCrypto.layer)), Layer.provideMerge(base));
 			return Layer.mergeAll(runtimeStack, ConversationMaintenance.layer.pipe(Layer.provide(runtimeStack)), portsEndpointLayer);
 		}));
 	}
@@ -960,23 +967,39 @@ const outOfContract = (conversationId, operation, observed) => ConversationClien
 	conversationId,
 	message: boundHostDiagnostic(`The Conversation Object answered ${operation} with the out-of-contract ${observed}.`)
 });
+const hostRpcMethods = {
+	submit: "submitEncoded",
+	awaitSettlement: "awaitSettlementEncoded",
+	awaitProgress: "awaitProgressEncoded",
+	cancelProgress: "cancelProgressEncoded",
+	observePage: "observePage",
+	abort: "abortEncoded",
+	resolveApproval: "resolveApprovalEncoded",
+	resolveUnknown: "resolveUnknownEncoded"
+};
 /** Worker-side client over the Conversation Object namespace (DEPLOY-010). */
 var CloudflareConversationClient = class CloudflareConversationClient extends Context.Service()("@effect-agent/platform-cloudflare/CloudflareConversationClient") {
 	static layer = Layer.effect(CloudflareConversationClient)(Effect.gen(function* () {
-		const { namespace } = yield* ConversationObjectNamespace;
+		const { namespace, rpcTracing } = yield* ConversationObjectNamespace;
 		const crypto = yield* Crypto.Crypto;
-		const call = (conversationId, operation, invoke) => Effect.tryPromise({
-			try: () => invoke(namespace.get(namespace.idFromName(conversationId))),
-			catch: (cause) => ConversationClientError.make({
-				conversationId,
-				message: boundHostDiagnostic(`${operation} did not reach the Conversation Object: ${safeCauseMessage(cause, "the RPC failed without a diagnostic")}`),
-				cause,
-				...cloudflareFailureSignals(cause)
-			})
-		}).pipe(Effect.flatMap((raw) => decodeHostResponse(raw).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`The ${operation} answer could not be decoded: ${error.message}`) })))), Effect.withSpan("CloudflareConversationClient.call", { attributes: {
+		const call = Effect.fn(function* (conversationId, operation, encoded) {
+			const traceArgs = rpcTracing === void 0 ? [] : yield* RpcTracing.withRpcTraceContext([]);
+			const raw = yield* Effect.tryPromise({
+				try: () => {
+					return namespace.get(namespace.idFromName(conversationId))[hostRpcMethods[operation]](encoded, ...traceArgs);
+				},
+				catch: (cause) => ConversationClientError.make({
+					conversationId,
+					message: boundHostDiagnostic(`${operation} did not reach the Conversation Object: ${safeCauseMessage(cause, "the RPC failed without a diagnostic")}`),
+					cause,
+					...cloudflareFailureSignals(cause)
+				})
+			});
+			return yield* decodeHostResponse(raw).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`The ${operation} answer could not be decoded: ${error.message}`) })));
+		}, (effect, conversationId, operation) => rpcTracing === void 0 ? Effect.withSpan(effect, "CloudflareConversationClient.call", { attributes: {
 			conversationId,
 			operation
-		} }));
+		} }) : RpcTracing.withRpcClientSpan(effect, rpcTracing, hostRpcMethods[operation]));
 		const expect = (conversationId, operation, resultSchema, failureSchema) => {
 			const isExpectedResult = Schema.is(resultSchema);
 			const isExpectedFailure = Schema.is(failureSchema);
@@ -995,10 +1018,10 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 				limit: options?.limit ?? 256
 			});
 			const encoded = yield* encodeObservePageRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`observePage request encode failed: ${error.message}`) })));
-			const response = yield* call(conversationId, "observePage", (stub) => stub.observePage(encoded));
+			const response = yield* call(conversationId, "observePage", encoded);
 			return (yield* expect(conversationId, "observePage", ObservedPage, ClientObserveHostFailure)(response)).records;
 		});
-		const cancelProgress = (conversationId, waiterId) => encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(Effect.mapError(() => void 0), Effect.flatMap((encoded) => call(conversationId, "cancelProgress", (stub) => stub.cancelProgressEncoded(encoded))), Effect.asVoid, Effect.ignore);
+		const cancelProgress = (conversationId, waiterId) => encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(Effect.mapError(() => void 0), Effect.flatMap((encoded) => call(conversationId, "cancelProgress", encoded)), Effect.asVoid, Effect.ignore);
 		return CloudflareConversationClient.of({
 			submit: (agent, input, options) => Effect.gen(function* () {
 				const encodedInput = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError((cause) => AgentInputError.make({ message: `Unable to encode Agent input: ${cause.message}` })));
@@ -1011,12 +1034,12 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 					inputPayload
 				});
 				const encoded = yield* encodeSubmitRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`submit request encode failed: ${error.message}`) })));
-				const response = yield* call(options.conversationId, "submit", (stub) => stub.submitEncoded(encoded));
+				const response = yield* call(options.conversationId, "submit", encoded);
 				return (yield* expect(options.conversationId, "submit", SubmitSucceeded, ClientSubmitHostFailure)(response)).receipt;
 			}),
 			awaitSettlement: (receipt) => Effect.gen(function* () {
 				const encoded = yield* encodeReceipt(receipt).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`receipt encode failed: ${error.message}`) })));
-				const response = yield* call(receipt.conversationId, "awaitSettlement", (stub) => stub.awaitSettlementEncoded(encoded));
+				const response = yield* call(receipt.conversationId, "awaitSettlement", encoded);
 				return (yield* expect(receipt.conversationId, "awaitSettlement", SettlementReached, ClientAwaitHostFailure)(response)).settlement;
 			}),
 			awaitProgress: (conversationId, afterSequence) => Effect.gen(function* () {
@@ -1026,7 +1049,7 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 					waiterId
 				});
 				const encoded = yield* encodeAwaitProgressRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress request encode failed: ${error.message}`) })));
-				const attempt = (retry) => call(conversationId, "awaitProgress", (stub) => stub.awaitProgressEncoded(encoded)).pipe(Effect.flatMap(expect(conversationId, "awaitProgress", ProgressObserved, ClientObserveHostFailure)), Effect.asVoid, Effect.catchTag("ConversationClientError", (error) => error.retryable === true && error.overloaded !== true && retry < 5 ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(Effect.andThen(attempt(retry + 1))) : Effect.fail(error)));
+				const attempt = (retry) => call(conversationId, "awaitProgress", encoded).pipe(Effect.flatMap(expect(conversationId, "awaitProgress", ProgressObserved, ClientObserveHostFailure)), Effect.asVoid, Effect.catchTag("ConversationClientError", (error) => error.retryable === true && error.overloaded !== true && retry < 5 ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(Effect.andThen(attempt(retry + 1))) : Effect.fail(error)));
 				yield* attempt(0).pipe(Effect.onInterrupt(() => cancelProgress(conversationId, waiterId)));
 			}),
 			readPage,
@@ -1046,17 +1069,17 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 			}),
 			abort: (conversationId, command) => Effect.gen(function* () {
 				const encoded = yield* encodeAbortCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`abort command encode failed: ${error.message}`) })));
-				const response = yield* call(conversationId, "abort", (stub) => stub.abortEncoded(encoded));
+				const response = yield* call(conversationId, "abort", encoded);
 				return (yield* expect(conversationId, "abort", AbortRecorded, ClientAbortHostFailure)(response)).intent;
 			}),
 			resolveApproval: (conversationId, command) => Effect.gen(function* () {
 				const encoded = yield* encodeApprovalDecisionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`approval command encode failed: ${error.message}`) })));
-				const response = yield* call(conversationId, "resolveApproval", (stub) => stub.resolveApprovalEncoded(encoded));
+				const response = yield* call(conversationId, "resolveApproval", encoded);
 				return (yield* expect(conversationId, "resolveApproval", ApprovalRecorded, ClientApprovalHostFailure)(response)).intent;
 			}),
 			resolveUnknown: (conversationId, command) => Effect.gen(function* () {
 				const encoded = yield* encodeUnknownResolutionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`resolution command encode failed: ${error.message}`) })));
-				const response = yield* call(conversationId, "resolveUnknown", (stub) => stub.resolveUnknownEncoded(encoded));
+				const response = yield* call(conversationId, "resolveUnknown", encoded);
 				return (yield* expect(conversationId, "resolveUnknown", UnknownResolutionRecorded, ClientUnknownHostFailure)(response)).intent;
 			})
 		});
@@ -1323,7 +1346,7 @@ const gateEndpoint = Effect.gen(function* () {
 * ports. effect-cf owns the cached ManagedRuntime and supplies these values once per Object
 * incarnation; the durable runtime continues to depend only on the narrow services below.
 */
-const effectCfPlatformLayer = (namespaceBinding) => {
+const effectCfPlatformLayer = (namespaceBinding, rpcTracing = false) => {
 	const context = Layer.effect(DurableObjectContext)(Effect.gen(function* () {
 		const state = yield* DurableObjectState.DurableObjectState;
 		const env = yield* WorkerEnvironment;
@@ -1334,7 +1357,10 @@ const effectCfPlatformLayer = (namespaceBinding) => {
 	}));
 	const namespace = Layer.effect(ConversationObjectNamespace)(Effect.gen(function* () {
 		const binding = yield* conversationNamespaceFromEnv(yield* WorkerEnvironment, namespaceBinding);
-		return ConversationObjectNamespace.of({ namespace: binding });
+		return ConversationObjectNamespace.of({
+			namespace: binding,
+			...rpcTracing === true ? { rpcTracing: namespaceBinding } : {}
+		});
 	}));
 	return Layer.merge(context, namespace);
 };
@@ -1346,7 +1372,7 @@ const effectCfPlatformLayer = (namespaceBinding) => {
 * Effect Agent owning exporter lifecycle machinery.
 */
 const makeConversationObjectClass = (options, observability) => {
-	const application = CloudflareDurableRuntime.layer(options).pipe(Layer.provideMerge(effectCfPlatformLayer(options.namespaceBinding)));
+	const application = CloudflareDurableRuntime.layer(options).pipe(Layer.provideMerge(effectCfPlatformLayer(options.namespaceBinding, options.rpcTracing)));
 	const runtime = Layer.effectContext(Effect.gen(function* () {
 		const state = yield* DurableObjectState.DurableObjectState;
 		const scope = yield* Effect.scope;
@@ -1373,6 +1399,7 @@ const makeConversationObjectClass = (options, observability) => {
 		wake: () => wakeEndpoint
 	};
 	const EffectCfConversationObject = DurableObject.make(runtime, {
+		...options.rpcTracing === true ? { rpcTracing: { service: options.namespaceBinding } } : {},
 		...observability === void 0 ? {} : { eventLayer: observability },
 		initialize: Effect.void,
 		rpc,