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

package/src/browser-rest-capture.ts

@@ -51,6 +51,7 @@ const RestSuccessEnvelope = Schema.Struct({
   errors: Schema.optionalKey(Schema.Array(Schema.Unknown)),
   meta: Schema.optionalKey(Schema.Unknown),
 });
+
 const RestErrorEnvelope = Schema.Struct({
   success: Schema.Literal(false),
   errors: Schema.Array(
@@ -62,6 +63,7 @@ const RestErrorEnvelope = Schema.Struct({
   result: Schema.optionalKey(Schema.Json),
   meta: Schema.optionalKey(Schema.Unknown),
 });
+
 const RestEnvelope = Schema.Union([RestSuccessEnvelope, RestErrorEnvelope]);
 const decodeEnvelope = Schema.decodeUnknownOption(Schema.fromJsonString(RestEnvelope));
 
@@ -86,6 +88,7 @@ const privateResponseCause = (
   if (bodyText.length === 0) return undefined;
   const token = Redacted.value(apiToken);
   const diagnostic = boundedDiagnostic(bodyText);
+
   return new Error(token.length === 0 ? diagnostic : diagnostic.replaceAll(token, "[REDACTED]"));
 };
 
@@ -94,8 +97,10 @@ const requestBody = (request: PageCaptureRequest): Record<string, unknown> => {
     request.target._tag === "PageUrlTarget"
       ? { url: request.target.url }
       : { html: request.target.html };
+
   if (request.navigation !== undefined) {
     const goto: Record<string, unknown> = {};
+
     if (request.navigation.waitUntil !== undefined) goto.waitUntil = request.navigation.waitUntil;
     if (request.navigation.timeoutMillis !== undefined)
       goto.timeout = request.navigation.timeoutMillis;
@@ -116,6 +121,7 @@ const requestBody = (request: PageCaptureRequest): Record<string, unknown> => {
   if (request.resourcePolicy?.allowRequestPatterns !== undefined) {
     body.allowRequestPattern = [...request.resourcePolicy.allowRequestPatterns];
   }
+
   return body;
 };
 
@@ -138,6 +144,7 @@ const actionName = (
 
 const actionBody = (request: PageCaptureRequest): Record<string, unknown> => {
   const body = requestBody(request);
+
   switch (request.action._tag) {
     case "CapturePageContent":
     case "CapturePageMarkdown":
@@ -167,8 +174,10 @@ 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;
 };
 
@@ -176,14 +185,17 @@ const browserMillis = (
   headers: Readonly<Record<string, string | undefined>>,
 ): number | undefined => {
   const millis = Number(headers["x-browser-ms-used"]);
+
   return Number.isSafeInteger(millis) && millis >= 0 ? millis : undefined;
 };
 
 /** Response framing is provider metadata, never content controlled by the rendered page. */
 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;
 };
 
@@ -192,6 +204,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCapture.readResponse")(functio
   request: PageCaptureRequest,
 ): Effect.fn.Return<string, PageCaptureError> {
   const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+
   const chunks = yield* Stream.runFoldEffect<
     Uint8Array,
     HttpClientError.HttpClientError,
@@ -204,6 +217,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCapture.readResponse")(functio
     () => ({ observed: 0, text: "" }),
     (state, chunk) => {
       const observed = state.observed + chunk.byteLength;
+
       if (observed > request.limits.maxOutputBytes) {
         return Effect.fail(
           PageCaptureOutputLimitError.make({
@@ -213,6 +227,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCapture.readResponse")(functio
           }),
         );
       }
+
       return Effect.try({
         try: () => ({ observed, text: state.text + decoder.decode(chunk, { stream: true }) }),
         catch: (cause) => protocolError("Decoding the Browser Run response failed", cause),
@@ -225,6 +240,7 @@ const readBoundedResponse = Effect.fn("BrowserRestCapture.readResponse")(functio
         : protocolError("Reading the Browser Run response failed", error),
     ),
   );
+
   return yield* Effect.try({
     try: () => chunks.text + decoder.decode(),
     catch: (cause) => protocolError("Decoding the Browser Run response failed", cause),
@@ -237,6 +253,7 @@ const parseOutput = (
   apiToken: Redacted.Redacted<string>,
 ): PageCaptureOutput | PageCaptureNavigationError | PageCaptureProtocolError => {
   const envelope = decodeEnvelope(bodyText);
+
   if (Option.isNone(envelope)) {
     return protocolError(
       "The Browser Run response did not carry a valid response envelope",
@@ -255,6 +272,7 @@ const parseOutput = (
       if (typeof envelope.value.result !== "string") {
         return protocolError("The Browser Run response envelope carried a non-text result");
       }
+
       return action._tag === "CapturePageContent"
         ? PageContentCaptured.make({ html: envelope.value.result })
         : PageMarkdownCaptured.make({ markdown: envelope.value.result });
@@ -263,6 +281,7 @@ const parseOutput = (
         _tag: "PageLinksCaptured",
         links: envelope.value.result,
       });
+
       return Option.isSome(decoded)
         ? decoded.value
         : protocolError("Browser Run links did not return a bounded array of valid URLs");
@@ -272,6 +291,7 @@ const parseOutput = (
         _tag: "PageScrapeCaptured",
         groups: envelope.value.result,
       });
+
       return Option.isSome(decoded)
         ? decoded.value
         : protocolError("Browser Run scrape did not return bounded grouped element records");
@@ -292,6 +312,7 @@ const makeCapture = (
     request: PageCaptureRequest,
   ): Effect.fn.Return<PageCaptureResult, PageCaptureError> {
     const usesWorkersAi = request.action._tag === "CapturePageStructured";
+
     if (usesWorkersAi) {
       if (workersAi === undefined) {
         return yield* PageCaptureUnsupportedError.make({
@@ -318,6 +339,7 @@ const makeCapture = (
     }
     const action = actionName(request.action);
     const path = `${API_ORIGIN}/client/v4/accounts/${encodeURIComponent(options.accountId)}/browser-rendering/${action}`;
+
     const requestWithBody = yield* HttpClientRequest.post(path).pipe(
       request.engine === "kitesurf"
         ? HttpClientRequest.setUrlParam("browser", "kitesurf")
@@ -327,14 +349,18 @@ const makeCapture = (
       HttpClientRequest.bodyJson(actionBody(request)),
       Effect.mapError((cause) => protocolError("Encoding the Browser Run request failed", cause)),
     );
+
     const response = yield* client
       .execute(requestWithBody)
       .pipe(
         Effect.mapError((cause) => protocolError("Calling the Browser Run REST API failed", cause)),
       );
+
     const bodyText = yield* readBoundedResponse(response, request);
+
     if (response.status === 429) {
       const reason = isQuotaMessage(bodyText) ? "quota" : "rate";
+
       return yield* PageCaptureRateLimitedError.make({
         implementation: browserRestCaptureImplementation,
         reason,
@@ -361,6 +387,7 @@ const makeCapture = (
               `Browser Run answered HTTP ${String(response.status)}`,
               privateResponseCause(bodyText, options.apiToken),
             );
+
       return yield* error;
     }
     if (!isJsonResponse(response.headers)) {
@@ -370,12 +397,14 @@ const makeCapture = (
       );
     }
     const output = parseOutput(request.action, bodyText, options.apiToken);
+
     if (
       output._tag === "PageCaptureNavigationError" ||
       output._tag === "PageCaptureProtocolError"
     ) {
       return yield* output;
     }
+
     return PageCaptureResult.make({
       implementation: browserRestCaptureImplementation,
       output,
@@ -415,6 +444,7 @@ export const browserRestWorkersAiCaptureLayer = (
     Effect.gen(function* () {
       const client = yield* HttpClient.HttpClient;
       const workersAi = yield* BrowserQuickActionWorkersAi;
+
       return PageCapture.of({ capture: makeCapture(client, options, workersAi) });
     }),
   );

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