@effect-agent/platform-cloudflare 0.1.0-beta.42 → 0.1.0-beta.44

package/src/client.ts

@@ -156,6 +156,7 @@ export const HostFailure = Schema.Union([
   OperationDenied,
   HostProtocolError,
 ]);
+
 export type HostFailure = typeof HostFailure.Type;
 
 export class SubmitSucceeded extends Schema.TaggedClass<SubmitSucceeded>(
@@ -222,6 +223,7 @@ export const HostResponse = Schema.Union([
   UnknownResolutionRecorded,
   HostFailed,
 ]);
+
 export type HostResponse = typeof HostResponse.Type;
 
 // ---------------------------------------------------------------------------
@@ -266,18 +268,21 @@ const ClientSubmitHostFailure = Schema.Union([
   DurableAlarmError,
   HostProtocolError,
 ]);
+
 const ClientAwaitHostFailure = Schema.Union([
   LedgerError,
   SettlementConflict,
   OperationDenied,
   HostProtocolError,
 ]);
+
 const ClientObserveHostFailure = Schema.Union([
   ThreadStoreError,
   ThreadNotMaterialized,
   OperationDenied,
   HostProtocolError,
 ]);
+
 const ClientAbortHostFailure = Schema.Union([
   OperationDenied,
   LedgerError,
@@ -287,6 +292,7 @@ const ClientAbortHostFailure = Schema.Union([
   DurableAlarmError,
   HostProtocolError,
 ]);
+
 const ClientApprovalHostFailure = Schema.Union([
   LedgerError,
   SettlementConflict,
@@ -295,6 +301,7 @@ const ClientApprovalHostFailure = Schema.Union([
   DurableAlarmError,
   HostProtocolError,
 ]);
+
 const ClientUnknownHostFailure = Schema.Union([
   LedgerError,
   SettlementConflict,
@@ -420,9 +427,11 @@ export class CloudflareThreadClient extends Context.Service<
           // Empty arguments preserve native arity. Passing `undefined` still adds an argument.
           const traceArgs =
             rpcTracing === undefined ? [] : yield* RpcTracing.withRpcTraceContext([]);
+
           const raw = yield* Effect.tryPromise({
             try: () => {
               const stub = namespace.get(namespace.idFromName(threadId));
+
               return stub[hostRpcMethods[operation]](encoded, ...traceArgs);
             },
             catch: (cause) =>
@@ -438,6 +447,7 @@ export class CloudflareThreadClient extends Context.Service<
                 ...cloudflareFailureSignals(cause),
               }),
           });
+
           return yield* decodeHostResponse(raw).pipe(
             Effect.mapError((error): HostProtocolError =>
               HostProtocolError.make({
@@ -464,11 +474,13 @@ export class CloudflareThreadClient extends Context.Service<
       ) => {
         const isExpectedResult = Schema.is(resultSchema);
         const isExpectedFailure = Schema.is(failureSchema);
+
         return (
           response: HostResponse,
         ): Effect.Effect<ResultSchema["Type"], FailureSchema["Type"] | ThreadClientError> => {
           if (response._tag === "HostFailed") {
             const failure = response.failure;
+
             return isExpectedFailure(failure)
               ? Effect.fail(failure)
               : Effect.fail(outOfContract(threadId, operation, `failure ${failure._tag}`));
@@ -476,6 +488,7 @@ export class CloudflareThreadClient extends Context.Service<
           if (!isExpectedResult(response)) {
             return Effect.fail(outOfContract(threadId, operation, `result ${response._tag}`));
           }
+
           return Effect.succeed(response);
         };
       };
@@ -494,6 +507,7 @@ export class CloudflareThreadClient extends Context.Service<
               : { afterSequence: options.afterSequence }),
             limit: options?.limit ?? 256,
           });
+
           const encoded = yield* encodeObservePageRequest(request).pipe(
             Effect.mapError((error) =>
               HostProtocolError.make({
@@ -501,13 +515,16 @@ export class CloudflareThreadClient extends Context.Service<
               }),
             ),
           );
+
           const response = yield* call(threadId, "observePage", encoded);
+
           const page = yield* expect(
             threadId,
             "observePage",
             ObservedPage,
             ClientObserveHostFailure,
           )(response);
+
           return page.records;
         });
 
@@ -533,6 +550,7 @@ export class CloudflareThreadClient extends Context.Service<
                 AgentInputError.make({ message: `Unable to encode Agent input: ${cause.message}` }),
               ),
             );
+
             const inputPayload = yield* Schema.decodeUnknownEffect(PersistedJson)(
               encodedInput,
             ).pipe(
@@ -542,6 +560,7 @@ export class CloudflareThreadClient extends Context.Service<
                 }),
               ),
             );
+
             const request = SubmitRequest.make({
               agentId: agent.definition.id,
               principal: options.principal,
@@ -549,6 +568,7 @@ export class CloudflareThreadClient extends Context.Service<
               definitions: options.definitions,
               inputPayload,
             });
+
             const encoded = yield* encodeSubmitRequest(request).pipe(
               Effect.mapError((error) =>
                 HostProtocolError.make({
@@ -556,13 +576,16 @@ export class CloudflareThreadClient extends Context.Service<
                 }),
               ),
             );
+
             const response = yield* call(options.threadId, "submit", encoded);
+
             const succeeded = yield* expect(
               options.threadId,
               "submit",
               SubmitSucceeded,
               ClientSubmitHostFailure,
             )(response);
+
             return succeeded.receipt;
           }),
 
@@ -575,13 +598,16 @@ export class CloudflareThreadClient extends Context.Service<
                 }),
               ),
             );
+
             const response = yield* call(receipt.threadId, "awaitSettlement", encoded);
+
             const settled = yield* expect(
               receipt.threadId,
               "awaitSettlement",
               SettlementReached,
               ClientAwaitHostFailure,
             )(response);
+
             return settled.settlement;
           }),
 
@@ -596,7 +622,9 @@ export class CloudflareThreadClient extends Context.Service<
                 }),
               ),
             );
+
             const request = AwaitProgressRequest.make({ afterSequence, waiterId });
+
             const encoded = yield* encodeAwaitProgressRequest(request).pipe(
               Effect.mapError((error) =>
                 HostProtocolError.make({
@@ -631,10 +659,13 @@ export class CloudflareThreadClient extends Context.Service<
           Effect.gen(function* () {
             const all: Array<CanonicalRecordEnvelope> = [];
             let after: CanonicalSequence | undefined;
+
             for (;;) {
               const page = yield* readPage(threadId, { afterSequence: after, limit: 1_024 });
+
               all.push(...page);
               const last = page.at(-1);
+
               if (page.length < 1_024 || last === undefined) return all;
               after = last.sequence;
             }
@@ -649,13 +680,16 @@ export class CloudflareThreadClient extends Context.Service<
                 }),
               ),
             );
+
             const response = yield* call(threadId, "abort", encoded);
+
             const recorded = yield* expect(
               threadId,
               "abort",
               AbortRecorded,
               ClientAbortHostFailure,
             )(response);
+
             return recorded.intent;
           }),
 
@@ -668,13 +702,16 @@ export class CloudflareThreadClient extends Context.Service<
                 }),
               ),
             );
+
             const response = yield* call(threadId, "resolveApproval", encoded);
+
             const recorded = yield* expect(
               threadId,
               "resolveApproval",
               ApprovalRecorded,
               ClientApprovalHostFailure,
             )(response);
+
             return recorded.intent;
           }),
 
@@ -689,13 +726,16 @@ export class CloudflareThreadClient extends Context.Service<
                 }),
               ),
             );
+
             const response = yield* call(threadId, "resolveUnknown", encoded);
+
             const recorded = yield* expect(
               threadId,
               "resolveUnknown",
               UnknownResolutionRecorded,
               ClientUnknownHostFailure,
             )(response);
+
             return recorded.intent;
           }),
       });

package/src/code-mode-executor.ts

@@ -229,36 +229,45 @@ const HarnessCompleted = Schema.TaggedStruct("completed", {
   logBytes: Schema.Natural,
   resultBytes: Schema.Natural,
 });
+
 const HarnessSourceInvalid = Schema.TaggedStruct("source-invalid", {
   message: Schema.String,
 });
+
 const HarnessNotAFunction = Schema.TaggedStruct("source-not-a-function", {
   actual: Schema.String,
 });
+
 const HarnessProgramFailed = Schema.TaggedStruct("program-failed", {
   reason: Schema.Literals(["threw", "rejected", "non-json-result"]),
   thrown: Schema.Json,
   message: Schema.String,
   logs: BoundedLogs,
 });
+
 const HarnessLogLimit = Schema.TaggedStruct("log-limit", {
   observed: Schema.Natural,
   logs: BoundedLogs,
 });
+
 const HarnessArgumentLimit = Schema.TaggedStruct("argument-limit", {
   observed: Schema.Natural,
   logs: BoundedLogs,
 });
+
 const HarnessResultLimit = Schema.TaggedStruct("result-limit", {
   observed: Schema.Natural,
   logs: BoundedLogs,
 });
+
 const HarnessHostCallLimit = Schema.TaggedStruct("host-call-limit", {
   logs: BoundedLogs,
 });
+
 const HarnessProtocol = Schema.TaggedStruct("protocol", {
   message: Schema.String,
 });
+
 const HarnessOutcome = Schema.Union([
   HarnessCompleted,
   HarnessSourceInvalid,
@@ -321,6 +330,7 @@ export const disposeRpcHandle = (handle: unknown): Effect.Effect<void> =>
       if ((typeof handle !== "object" && typeof handle !== "function") || handle === null) return;
       if (!(Symbol.dispose in handle)) return;
       const dispose = Reflect.get(handle, Symbol.dispose);
+
       if (typeof dispose === "function") {
         Reflect.apply(dispose, handle, []);
       }
@@ -353,6 +363,7 @@ const encodeHostResultPayload = (
   try {
     const payload = outcome._tag === "CodeHostCallSuccess" ? outcome.value : outcome.error;
     const encodedPayload = encodeJsonPayload(payload);
+
     return {
       encodedPayload,
       resultBytes: utf8ByteLength(encodedPayload),
@@ -364,10 +375,13 @@ const encodeHostResultPayload = (
 
 const utf8ByteLength = (value: string): number => {
   let total = 0;
+
   for (const character of value) {
     const codePoint = character.codePointAt(0) ?? 0;
+
     total += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
   }
+
   return total;
 };
 
@@ -411,6 +425,7 @@ const makeExecute = (
       });
     }
     const sourceBytes = utf8ByteLength(request.source);
+
     if (sourceBytes > request.limits.maxSourceBytes) {
       return yield* CodeSourceError.make({
         implementation: dynamicWorkerImplementation,
@@ -433,22 +448,28 @@ const makeExecute = (
     // immediately. The Clock service remains the authority, so tests and hosts can replace it.
     const startedAt = clock.monotonicTimeNanosUnsafe();
     const passDeadline = startedAt + Duration.toNanosUnsafe(request.limits.maxWallTime);
+
     const remainingPassWallTime = (): Duration.Duration => {
       const now = clock.monotonicTimeNanosUnsafe();
+
       return Duration.nanos(passDeadline > now ? passDeadline - now : 0n);
     };
+
     let issuedHostCalls = 0;
     let passOpen = true;
     const queuedHostCalls: Array<QueuedHostCall> = [];
     let passFailure: HostDispatchError | undefined;
+
     const failPass = (error: HostDispatchError): void => {
       if (passFailure === undefined) passFailure = error;
     };
+
     const rejectQueuedHostCalls = (reason: Error): void => {
       for (const queued of queuedHostCalls.splice(0)) {
         queued.reject(reason);
       }
     };
+
     const queue = yield* Queue.unbounded<HostWork>();
 
     const deliverHostOutcome = (
@@ -457,15 +478,19 @@ const makeExecute = (
     ): Effect.Effect<void, CodeExecutionProtocolError | CodeOutputLimitError> =>
       Effect.gen(function* () {
         const decoded = decodeHostCallResult(outcome);
+
         if (Option.isNone(decoded)) {
           const error = CodeExecutionProtocolError.make({
             implementation: dynamicWorkerImplementation,
             message: "The execution host returned a value outside the CodeHostCallResult schema",
           });
+
           failPass(error);
+
           return yield* error;
         }
         const encoded = encodeHostResultPayload(decoded.value);
+
         if (encoded === undefined || encoded.resultBytes > request.limits.maxHostCallResultBytes) {
           const error = CodeOutputLimitError.make({
             implementation: dynamicWorkerImplementation,
@@ -474,16 +499,21 @@ const makeExecute = (
             observed: encoded?.resultBytes ?? 0,
             logs: [],
           });
+
           failPass(error);
+
           return yield* error;
         }
         const normalizedPayload = decodeJsonPayload(encoded.encodedPayload);
+
         if (Option.isNone(normalizedPayload)) {
           const error = CodeExecutionProtocolError.make({
             implementation: dynamicWorkerImplementation,
             message: "The execution host returned a result that could not cross the JSON boundary",
           });
+
           failPass(error);
+
           return yield* error;
         }
         queued.resolve(
@@ -499,16 +529,20 @@ const makeExecute = (
     const serveHostCalls = Effect.gen(function* () {
       while (true) {
         const work = yield* Queue.take(queue);
+
         if (work._tag === "limit") {
           const error = CodeHostCallLimitError.make({
             implementation: dynamicWorkerImplementation,
             limit: request.limits.maxHostCalls,
             logs: [],
           });
+
           failPass(error);
+
           return yield* error;
         }
         const queued = work.queued;
+
         yield* host.call(queued.call).pipe(
           Effect.timeoutOrElse({
             duration: remainingPassWallTime(),
@@ -519,7 +553,9 @@ const makeExecute = (
                 maxWallTime: request.limits.maxWallTime,
                 logs: [],
               });
+
               failPass(error);
+
               return error;
             },
           }),
@@ -533,6 +569,7 @@ const makeExecute = (
         );
       }
     });
+
     const server = yield* serveHostCalls.pipe(Effect.forkScoped);
 
     const dispatch = (hostCall: unknown): Promise<unknown> => {
@@ -546,16 +583,21 @@ const makeExecute = (
           limit: request.limits.maxHostCalls,
           logs: [],
         });
+
         failPass(error);
         Queue.offerUnsafe(queue, { _tag: "limit" });
+
         return Promise.reject(new Error("host-call limit exceeded"));
       }
       const decoded = decodeHostCall(hostCall);
+
       if (Option.isNone(decoded)) {
         return Promise.reject(new TypeError("host calls must match the CodeHostCall schema"));
       }
+
       return new Promise((resolve, reject) => {
         const queued = { call: decoded.value, resolve, reject };
+
         queuedHostCalls.push(queued);
         Queue.offerUnsafe(queue, { _tag: "call", queued });
       });
@@ -565,6 +607,7 @@ const makeExecute = (
       passOpen = false;
       rejectQueuedHostCalls(new Error("Code Mode pass is closing"));
     });
+
     yield* Effect.addFinalizer(() => closeAdmission.pipe(Effect.andThen(Fiber.interrupt(server))));
 
     // No `allowExperimental`: the runtime only accepts it when the CALLING
@@ -608,6 +651,7 @@ const makeExecute = (
         try: () => options.loader.load(workerCode),
         catch: (cause) => {
           const text = safeCauseMessage(cause, "The Worker Loader failed without a diagnostic");
+
           // Blame the program's source ONLY on a genuine compile diagnostic;
           // any other load rejection is an infrastructure start failure, not
           // the model's fault (see classifyWorkerFailure for the same split).
@@ -618,6 +662,7 @@ const makeExecute = (
               message: text.slice(0, 8_000),
             });
           }
+
           return CodeExecutorStartError.make({
             implementation: dynamicWorkerImplementation,
             message: `The Worker Loader rejected the pass: ${text}`.slice(0, 8_000),
@@ -656,6 +701,7 @@ const makeExecute = (
       ),
       Fiber.join(server),
     ).pipe(Effect.exit);
+
     yield* closeAdmission;
     yield* Fiber.interrupt(server);
     if (passFailure !== undefined) {
@@ -668,6 +714,7 @@ const makeExecute = (
     const finishedAt = clock.monotonicTimeNanosUnsafe();
 
     const outcome = decodeHarnessOutcome(raw);
+
     if (Option.isNone(outcome)) {
       return yield* CodeExecutionProtocolError.make({
         implementation: dynamicWorkerImplementation,
@@ -768,6 +815,7 @@ const classifyWorkerFailure = (
   | CodeExecutorStartError
   | CodeSourceError => {
   const text = safeCauseDiagnostic(cause, "[unserializable worker failure]");
+
   // `WorkerLoader.load()` is lazy, so a module-compile error in the generated
   // program surfaces here at first use. Blame the program's source ONLY on a
   // genuine compile diagnostic (a `SyntaxError` or an explicit compile
@@ -797,6 +845,7 @@ const classifyWorkerFailure = (
       cause,
     });
   }
+
   return CodeExecutorTerminatedError.make({
     implementation: dynamicWorkerImplementation,
     message: text.slice(0, 8_000),
@@ -811,6 +860,7 @@ export const dynamicWorkerCodeExecutorLayer = (
     CodeExecutor,
     Effect.gen(function* () {
       const clock = yield* Clock.Clock;
+
       return CodeExecutor.of({ execute: makeExecute(options, clock) });
     }),
   );