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

package/src/browser-rest-crawl.ts

@@ -47,6 +47,7 @@ const BoundedJobId = Schema.NonEmptyString.check(Schema.isMaxLength(256));
 const BoundedCursorString = Schema.NonEmptyString.check(Schema.isMaxLength(MAX_CURSOR_LENGTH));
 // The generated API response Schema says string; the current product example returns a number.
 const ProviderCursor = Schema.Union([BoundedCursorString, Schema.Natural]);
+
 const ProviderJobStatus = Schema.Literals([
   "running",
   "completed",
@@ -55,6 +56,7 @@ const ProviderJobStatus = Schema.Literals([
   "cancelled_due_to_timeout",
   "cancelled_due_to_limits",
 ]);
+
 const ProviderResult = Schema.Struct({
   id: BoundedJobId,
   status: ProviderJobStatus,
@@ -65,14 +67,17 @@ const ProviderResult = Schema.Struct({
   records: Schema.Array(PageCrawlRecord).check(Schema.isMaxLength(MAX_RECORDS_PER_RESPONSE)),
   cursor: Schema.optionalKey(ProviderCursor),
 });
+
 const CreateEnvelope = Schema.Struct({
   success: Schema.Literal(true),
   result: BoundedJobId,
 });
+
 const ResultEnvelope = Schema.Struct({
   success: Schema.Literal(true),
   result: ProviderResult,
 });
+
 const DeleteEnvelope = Schema.Struct({
   success: Schema.Literal(true),
   result: Schema.Struct({
@@ -91,8 +96,10 @@ const boundedDiagnostic = (message: string): string => message.slice(0, MAX_DIAG
 
 const privateCause = (value: unknown, apiToken: Redacted.Redacted<string>): Error | undefined => {
   const raw = boundedDiagnostic(String(value));
+
   if (raw.length === 0) return undefined;
   const token = Redacted.value(apiToken);
+
   return new Error(token.length === 0 ? raw : raw.replaceAll(token, "[REDACTED]"));
 };
 
@@ -116,6 +123,7 @@ const limitError = (
         : limit === "total-bytes"
           ? request.limits.maxTotalBytes
           : request.limits.deadlineMillis;
+
   return PageCrawlLimitError.make({
     implementation: browserRestCrawlImplementation,
     limit,
@@ -129,15 +137,19 @@ const retryAfterMillis = (
   headers: Readonly<Record<string, string | undefined>>,
 ): number | undefined => {
   const seconds = Number(headers["retry-after"]);
+
   if (!Number.isSafeInteger(seconds) || seconds < 0) return undefined;
   const millis = seconds * 1_000;
+
   return Number.isSafeInteger(millis) ? millis : undefined;
 };
 
 const isJsonResponse = (headers: Readonly<Record<string, string | undefined>>): boolean => {
   const contentType = headers["content-type"];
+
   if (contentType === undefined) return false;
   const mediaType = contentType.split(";", 1)[0]?.trim().toLowerCase();
+
   return mediaType === "application/json" || mediaType?.endsWith("+json") === true;
 };
 
@@ -153,6 +165,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCrawl.readBoundedResponse")(fu
   maximum: number,
 ): Effect.fn.Return<string, PageCrawlProtocolError> {
   const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+
   const state = yield* Stream.runFoldEffect<
     Uint8Array,
     HttpClientError.HttpClientError,
@@ -165,6 +178,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCrawl.readBoundedResponse")(fu
     () => ({ observed: 0, text: "" }),
     (current, chunk) => {
       const observed = current.observed + chunk.byteLength;
+
       if (observed > maximum) {
         return Effect.fail(
           protocolError(
@@ -172,6 +186,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCrawl.readBoundedResponse")(fu
           ),
         );
       }
+
       return Effect.try({
         try: () => ({ observed, text: current.text + decoder.decode(chunk, { stream: true }) }),
         catch: (cause) => protocolError("Decoding the Browser Run crawl response failed", cause),
@@ -184,6 +199,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCrawl.readBoundedResponse")(fu
         : protocolError("Reading the Browser Run crawl response failed", cause),
     ),
   );
+
   return yield* Effect.try({
     try: () => state.text + decoder.decode(),
     catch: (cause) => protocolError("Decoding the Browser Run crawl response failed", cause),
@@ -195,6 +211,7 @@ const deadlineFailure = Effect.fn("BrowserRestCrawl.deadlineFailure")(function*
   startedAt: number,
 ) {
   const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+
   return yield* limitError(request, "deadline", Math.max(0, now - startedAt));
 });
 
@@ -206,7 +223,9 @@ const withinDeadline = Effect.fn("BrowserRestCrawl.withinDeadline")(function* <A
   const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
   const elapsed = Math.max(0, now - startedAt);
   const remaining = request.limits.deadlineMillis - elapsed;
+
   if (remaining <= 0) return yield* limitError(request, "deadline", elapsed);
+
   return yield* effect.pipe(
     Effect.timeoutOrElse({
       duration: Duration.millis(remaining),
@@ -221,6 +240,7 @@ const checkDeadline = Effect.fn("BrowserRestCrawl.checkDeadline")(function* (
 ) {
   const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
   const elapsed = Math.max(0, now - startedAt);
+
   if (elapsed >= request.limits.deadlineMillis) {
     return yield* limitError(request, "deadline", elapsed);
   }
@@ -254,6 +274,7 @@ const makeCrawl =
           const authorized = HttpClientRequest.bearerToken(request, options.apiToken).pipe(
             HttpClientRequest.acceptJson,
           );
+
           const response = yield* client
             .execute(authorized)
             .pipe(
@@ -264,9 +285,12 @@ const makeCrawl =
                 ),
               ),
             );
+
           const bodyText = yield* readBoundedResponse(response, maximum);
+
           if (response.status === 429) {
             const reason = isQuotaMessage(bodyText) ? "quota" : "rate";
+
             return yield* PageCrawlRateLimitedError.make({
               implementation: browserRestCrawlImplementation,
               reason,
@@ -294,6 +318,7 @@ const makeCrawl =
               privateCause(bodyText, options.apiToken),
             );
           }
+
           return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(schema))(bodyText).pipe(
             Effect.mapError((cause) =>
               protocolError(
@@ -322,11 +347,13 @@ const makeCrawl =
               protocolError("Encoding the Browser Run crawl request failed", cause),
             ),
           );
+
           const created = yield* withinDeadline(
             executeJson(requestWithBody, CreateEnvelope, MAX_CONTROL_RESPONSE_BYTES),
             input,
             startedAt,
           );
+
           return created.result;
         });
 
@@ -344,6 +371,7 @@ const makeCrawl =
                 ).pipe(
                   Effect.flatMap((shouldCancel) => {
                     if (!shouldCancel) return Effect.void;
+
                     const cancellation = executeJson(
                       HttpClientRequest.delete(endpoint(options, id)),
                       DeleteEnvelope,
@@ -355,6 +383,7 @@ const makeCrawl =
                           : protocolError("Browser Run cancelled a different crawl job"),
                       ),
                     );
+
                     return cancellation.pipe(
                       Effect.timeoutOrElse({
                         duration: CANCEL_TIMEOUT,
@@ -373,6 +402,7 @@ const makeCrawl =
                     ),
                   ),
                 );
+
                 return { id, state } as const;
               }),
             ),
@@ -384,19 +414,23 @@ const makeCrawl =
           statusOnly: boolean,
         ) {
           let request = HttpClientRequest.get(endpoint(options, job.id));
+
           if (statusOnly) request = HttpClientRequest.setUrlParam(request, "limit", "1");
           if (Option.isSome(cursor)) {
             request = HttpClientRequest.setUrlParam(request, "cursor", cursor.value);
           }
+
           // `limit=1` still permits one complete record, so poll GETs use the bounded result cap.
           const envelope = yield* withinDeadline(
             executeJson(request, ResultEnvelope, MAX_RESULTS_RESPONSE_BYTES),
             input,
             startedAt,
           );
+
           if (envelope.result.id !== job.id) {
             return yield* protocolError("Browser Run returned a different crawl job identity");
           }
+
           return envelope.result;
         });
 
@@ -412,6 +446,7 @@ const makeCrawl =
             ),
           ).pipe(Effect.tap(() => Ref.set(job.state, "terminal"))),
         );
+
         if (terminal.status === "running") {
           return yield* protocolError("Browser Run polling stopped before a terminal status");
         }
@@ -428,6 +463,7 @@ const makeCrawl =
           (state) =>
             Effect.gen(function* () {
               const result = yield* fetchResult(state.cursor, false);
+
               if (result.status !== "completed") {
                 return yield* protocolError(
                   "Browser Run changed crawl status during result pagination",
@@ -437,12 +473,14 @@ const makeCrawl =
                 return [result.records, Option.none()] as const;
               }
               const cursor = normalizedCursor(result.cursor);
+
               if (state.seen.includes(cursor)) {
                 return yield* protocolError("Browser Run repeated a crawl result cursor");
               }
               if (state.seen.length >= input.limits.maxPages) {
                 return yield* protocolError("Browser Run returned too many crawl result cursors");
               }
+
               return [
                 result.records,
                 Option.some({ cursor: Option.some(cursor), seen: [...state.seen, cursor] }),
@@ -458,6 +496,7 @@ const makeCrawl =
               Effect.gen(function* () {
                 yield* checkDeadline(input, startedAt);
                 const pages = state.pages + 1;
+
                 if (pages > input.limits.maxPages) {
                   return yield* limitError(input, "pages", pages);
                 }
@@ -467,17 +506,21 @@ const makeCrawl =
                 if (record.metadata !== undefined && !sameHost(startHost, record.metadata.url)) {
                   return yield* protocolError("Browser Run returned off-host crawl metadata");
                 }
+
                 const pageBytes =
                   record.markdown === undefined
                     ? 0
                     : new TextEncoder().encode(record.markdown).byteLength;
+
                 if (pageBytes > input.limits.maxPageBytes) {
                   return yield* limitError(input, "page-bytes", pageBytes);
                 }
                 const totalBytes = state.totalBytes + pageBytes;
+
                 if (totalBytes > input.limits.maxTotalBytes) {
                   return yield* limitError(input, "total-bytes", totalBytes);
                 }
+
                 return [{ pages, totalBytes }, [record]] as const;
               }),
           ),

package/src/browser-session-lifecycle.ts

@@ -49,11 +49,13 @@ export class BrowserRunSessionLifecycle extends Context.Service<
           return yield* new BrowserRunCleanupError({ reason: "configuration" });
         }
         const client = yield* HttpClient.HttpClient;
+
         const request = Effect.fn("BrowserRunSessionLifecycle.request")(function* (
           method: "GET" | "DELETE",
           sessionId: string,
         ) {
           const path = method === "DELETE" ? "browser" : "session";
+
           const response = yield* client
             .execute(
               HttpClientRequest.make(method)(
@@ -65,6 +67,7 @@ export class BrowserRunSessionLifecycle extends Context.Service<
               Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }),
               Effect.mapError(() => new BrowserRunCleanupError({ reason: "provider" })),
             );
+
           if (response.status === 401 || response.status === 403)
             return yield* new BrowserRunCleanupError({
               reason: "authorization",
@@ -82,6 +85,7 @@ export class BrowserRunSessionLifecycle extends Context.Service<
             });
           if (response.headers["content-type"]?.split(";", 1)[0]?.trim() !== "application/json")
             return yield* new BrowserRunCleanupError({ reason: "malformed" });
+
           const bytes = yield* Stream.runFoldEffect(
             response.stream,
             () => new Uint8Array(),
@@ -89,44 +93,57 @@ export class BrowserRunSessionLifecycle extends Context.Service<
               if (body.byteLength + chunk.byteLength > 16_384)
                 return Effect.fail(new BrowserRunCleanupError({ reason: "malformed" }));
               const combined = new Uint8Array(body.byteLength + chunk.byteLength);
+
               combined.set(body);
               combined.set(chunk, body.byteLength);
+
               return Effect.succeed(combined);
             },
           ).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })));
+
           const body = yield* Effect.try({
             try: () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes),
             catch: () => new BrowserRunCleanupError({ reason: "malformed" }),
           });
+
           if (response.status === 404) {
             const absent = Schema.decodeUnknownOption(Schema.fromJsonString(Absent))(body, {
               onExcessProperty: "error",
             });
+
             if (Option.isSome(absent)) return true;
+
             return yield* new BrowserRunCleanupError({ reason: "malformed" });
           }
           if (method === "DELETE") {
             const result = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Closed))(
               body,
             ).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })));
+
             return result.status === "closed";
           }
+
           const result = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Metadata))(
             body,
           ).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "malformed" })));
+
           if (result.sessionId !== sessionId)
             return yield* new BrowserRunCleanupError({ reason: "malformed" });
+
           return result.endTime !== undefined && result.endTime > 0;
         });
+
         const close = Effect.fn("BrowserRunSessionLifecycle.close")(
           function* (sessionId: Redacted.Redacted<string>) {
             const id = yield* Schema.decodeUnknownEffect(Identity)(Redacted.value(sessionId)).pipe(
               Effect.mapError(() => new BrowserRunCleanupError({ reason: "configuration" })),
             );
+
             if (yield* request("DELETE", id)) return;
             for (let read = 0; read < 2; read++) {
               if (yield* request("GET", id)) return;
             }
+
             return yield* new BrowserRunCleanupError({ reason: "pending" });
           },
           Effect.timeoutOrElse({
@@ -135,6 +152,7 @@ export class BrowserRunSessionLifecycle extends Context.Service<
           }),
           Effect.withTracerEnabled(false),
         );
+
         return { close };
       }),
     );

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;
           }),
       });