@buyong/pi-devin 0.1.4 → 0.1.6

package/src/core/protocol/http/node-client.ts

@@ -0,0 +1,130 @@
+import { Agent as HTTPAgent, request as httpRequest, type IncomingMessage } from "node:http";
+import { Agent as HTTPSAgent, request as httpsRequest } from "node:https";
+import { pipeline, Readable } from "node:stream";
+import type { ConnectionOptions } from "node:tls";
+import { createGunzip } from "node:zlib";
+import { Effect, type Scope } from "effect";
+import { HttpClient, HttpClientError, type HttpClientRequest, type HttpClientResponse } from "effect/http";
+import { DevinHttpResponse } from "./response.ts";
+
+export interface HTTPTransportOptions {
+  /** Trusts a user-supplied CA without disabling certificate or host verification. */
+  ca?: ConnectionOptions["ca"];
+}
+
+export function transportError(request: HttpClientRequest.HttpClientRequest, cause: unknown): HttpClientError.HttpClientError {
+  return new HttpClientError.HttpClientError({ reason: new HttpClientError.TransportError({ request, cause }) });
+}
+
+/** The request body as the transports send it: bytes or text, never a stream. */
+export function requestBody(request: HttpClientRequest.HttpClientRequest): Uint8Array | string | undefined {
+  const body = request.body;
+  if (body._tag === "Uint8Array") return body.body;
+  if (body._tag === "Raw" && (typeof body.body === "string" || body.body instanceof Uint8Array)) return body.body;
+  return undefined;
+}
+
+function nodeResponse(incoming: IncomingMessage): Response | Error {
+  const responseHeaders = new Headers();
+  for (const [name, value] of Object.entries(incoming.headers)) {
+    for (const entry of Array.isArray(value) ? value : value === undefined ? [] : [value]) responseHeaders.append(name, entry);
+  }
+  const status = incoming.statusCode ?? 502;
+  const hasNoBody = [204, 205, 304].includes(status);
+  const encoding = responseHeaders.get("content-encoding")?.trim().toLowerCase();
+  let stream: Readable = incoming;
+  if (hasNoBody) incoming.resume();
+  else if (encoding && encoding !== "identity") {
+    if (encoding !== "gzip") {
+      // An encoding problem in an error body must not hide an already received 401/403/429 status.
+      if (status >= 200 && status < 300) return new Error("Unsupported HTTP response compression.");
+    } else {
+      const decoded = createGunzip();
+      // Propagates consumer cancellation and compression errors to the original socket and keeps backpressure.
+      pipeline(incoming, decoded, () => {});
+      stream = decoded;
+      responseHeaders.delete("content-encoding");
+      responseHeaders.delete("content-length");
+    }
+  }
+  try {
+    return new Response(hasNoBody ? null : Readable.toWeb(stream) as ReadableStream<Uint8Array>, { status, headers: responseHeaders });
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}
+
+/**
+ * HTTP/1.1-only `HttpClient` over `node:http`. Owns a pool for the scope's lifetime and verifies TLS certificates and hosts.
+ * The 5000ms socket timeout spells out the previous Node global agent setting as a PoC policy;
+ * it is not the overall RPC deadline. It does not claim to match the CLI's TLS or pool policy.
+ */
+export function makeNodeHttpClient(options: HTTPTransportOptions = {}): Effect.Effect<HttpClient.HttpClient, never, Scope.Scope> {
+  return Effect.gen(function* () {
+    const pool = yield* Effect.acquireRelease(Effect.sync(() => ({
+      isClosed: false,
+      http: new HTTPAgent({ keepAlive: true, timeout: 5000 }),
+      https: new HTTPSAgent({
+        keepAlive: true, timeout: 5000, rejectUnauthorized: true, minVersion: "TLSv1.2",
+        ALPNProtocols: ["http/1.1"], ...(options.ca === undefined ? {} : { ca: options.ca }),
+      }),
+    })), (pool) => Effect.sync(() => {
+      pool.isClosed = true;
+      pool.http.destroy();
+      pool.https.destroy();
+    }));
+
+    const send = (request: HttpClientRequest.HttpClientRequest): Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError> => Effect.suspend(() => {
+      if (pool.isClosed) return Effect.fail(transportError(request, new Error("The HTTP transport is closed.")));
+      if (request.method !== "POST" && request.method !== "GET") return Effect.fail(transportError(request, new Error("This transport supports only URL GET/POST without redirects.")));
+      let url: URL;
+      try { url = new URL(request.url); } catch (error) { return Effect.fail(transportError(request, error)); }
+      if (!["https:", "http:"].includes(url.protocol)) return Effect.fail(transportError(request, new Error("Unsupported HTTP protocol.")));
+      const raw = requestBody(request);
+      const body = raw === undefined ? undefined : Buffer.from(raw);
+      if (request.method === "POST" && !body) return Effect.fail(transportError(request, new Error("A POST body must be a string or a byte array.")));
+      if (request.method === "GET" && body) return Effect.fail(transportError(request, new Error("A GET body is not supported.")));
+      let headers: Record<string, string>;
+      try {
+        // Validates names and values the same way fetch does before anything is sent.
+        const validated = new Headers(Object.entries(request.headers));
+        headers = {};
+        for (const [name, value] of validated) if (name !== "host" && name !== "content-length") headers[name] = value;
+      } catch (error) { return Effect.fail(transportError(request, error)); }
+      headers.host = url.host;
+      if (body) headers["content-length"] = String(body.byteLength);
+      const isHTTPS = url.protocol === "https:";
+      return Effect.callback<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError>((resume) => {
+        let isSettled = false;
+        const fail = (cause: unknown) => {
+          if (isSettled) return;
+          isSettled = true;
+          resume(Effect.fail(transportError(request, cause)));
+        };
+        const outgoing = (isHTTPS ? httpsRequest : httpRequest)(url, {
+          method: request.method, headers, agent: isHTTPS ? pool.https : pool.http,
+        }, (incoming) => {
+          if (isSettled) { incoming.destroy(); return; }
+          const response = nodeResponse(incoming);
+          if (response instanceof Error) { incoming.destroy(); fail(response); return; }
+          isSettled = true;
+          resume(Effect.succeed(new DevinHttpResponse(request, response, () => { incoming.destroy(); outgoing.destroy(); })));
+        });
+        outgoing.on("error", fail);
+        outgoing.once("upgrade", (_response, socket) => {
+          socket.destroy();
+          fail(new Error("HTTP upgrade is not supported."));
+        });
+        outgoing.removeHeader("connection");
+        outgoing.end(body);
+        return Effect.sync(() => {
+          if (isSettled) return;
+          isSettled = true;
+          outgoing.destroy();
+        });
+      });
+    });
+
+    return HttpClient.makeWith<HttpClientError.HttpClientError, never, HttpClientError.HttpClientError, never>((request) => Effect.flatMap(request, send), Effect.succeed);
+  });
+}

package/src/core/protocol/http/response.ts

@@ -0,0 +1,99 @@
+import { Effect, Inspectable, Option, Stream } from "effect";
+import { pipeArguments } from "effect/Pipeable";
+import { HttpClientError, HttpClientResponse, HttpIncomingMessage, type HttpClientRequest } from "effect/http";
+
+const ignore = () => {};
+
+/**
+ * A web `Response` seen through Effect's `HttpClientResponse`. Unlike `HttpClientResponse.fromWeb`, ending its body early
+ * never waits for an uncooperative `cancel()`, and the transport is stopped only while the body is still in flight,
+ * so a fully read keep-alive connection stays reusable.
+ */
+export class DevinHttpResponse extends Inspectable.Class implements HttpClientResponse.HttpClientResponse {
+  readonly [HttpClientResponse.TypeId] = HttpClientResponse.TypeId;
+  readonly [HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId;
+  readonly request: HttpClientRequest.HttpClientRequest;
+  readonly source: Response;
+  private readonly web: HttpClientResponse.HttpClientResponse;
+  private readonly abortTransport: () => void;
+  private isBodySettled = false;
+
+  constructor(request: HttpClientRequest.HttpClientRequest, source: Response, abortTransport: () => void) {
+    super();
+    this.request = request;
+    this.source = source;
+    this.abortTransport = abortTransport;
+    this.web = HttpClientResponse.fromWeb(request, source);
+  }
+
+  get url() { return this.web.url; }
+  get status() { return this.source.status; }
+  get headers() { return this.web.headers; }
+  get cookies() { return this.web.cookies; }
+  get remoteAddress() { return Option.none<string>(); }
+  get formData() { return this.web.formData; }
+  get json() { return this.web.json; }
+  get text() { return this.web.text; }
+  get urlParamsBody() { return this.web.urlParamsBody; }
+  get arrayBuffer() { return this.web.arrayBuffer; }
+
+  /** Stops an unread or partly read body. Responses that arrive after their request ended are discarded the same way. */
+  get discard(): Effect.Effect<void> {
+    return Effect.sync(() => this.abandon(undefined));
+  }
+
+  private abandon(reader: ReadableStreamDefaultReader<Uint8Array> | undefined): void {
+    if (this.isBodySettled) return;
+    this.isBodySettled = true;
+    try {
+      if (reader) { void reader.cancel().catch(ignore); reader.releaseLock(); }
+      else if (this.source.body && !this.source.body.locked) void this.source.body.cancel().catch(ignore);
+    } finally { this.abortTransport(); }
+  }
+
+  get stream(): Stream.Stream<Uint8Array, HttpClientError.HttpClientError> {
+    return Stream.suspend(() => {
+      const body = this.source.body;
+      if (!body || this.isBodySettled) {
+        return Stream.fail(new HttpClientError.HttpClientError({
+          reason: new HttpClientError.EmptyBodyError({ request: this.request, response: this, description: "The response has no body." }),
+        }));
+      }
+      const reader = body.getReader();
+      const iterator: AsyncIterator<Uint8Array> = {
+        next: async () => {
+          try {
+            const item = await reader.read();
+            if (item.done && !this.isBodySettled) { this.isBodySettled = true; reader.releaseLock(); }
+            return item.done ? { done: true, value: undefined } : item;
+          } catch (error) {
+            this.abandon(reader);
+            throw error;
+          }
+        },
+        // Called when the consumer stops early. Cancellation is started but never awaited.
+        return: async () => {
+          this.abandon(reader);
+          return { done: true, value: undefined };
+        },
+      };
+      return Stream.fromAsyncIterable({ [Symbol.asyncIterator]: () => iterator }, (cause) => new HttpClientError.HttpClientError({
+        reason: new HttpClientError.DecodeError({ request: this.request, response: this, cause }),
+      }));
+    });
+  }
+
+  toJSON(): unknown {
+    return HttpIncomingMessage.inspect(this, { _id: "HttpClientResponse", request: this.request.toJSON(), status: this.status });
+  }
+
+  pipe() {
+    // biome-ignore lint/complexity/noArguments: Pipeable forwards the call's arguments.
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** Discards the body of a response this package's transports produced. */
+export function discardResponse(response: HttpClientResponse.HttpClientResponse): Effect.Effect<void> {
+  return response instanceof DevinHttpResponse ? response.discard : Effect.void;
+}

package/src/core/protocol/http.ts

@@ -1,109 +1,49 @@
-import { Agent as HTTPAgent, request as httpRequest } from "node:http";
-import { Agent as HTTPSAgent, request as httpsRequest } from "node:https";
-import { Readable, pipeline } from "node:stream";
-import type { ConnectionOptions } from "node:tls";
-import { createGunzip } from "node:zlib";
+import { Effect, Stream } from "effect";
+import type { HttpClientError, HttpClientResponse } from "effect/http";
+import { DevinError, toDevinFailure, type DevinFailure } from "../errors.ts";
+import { failWith } from "../validation.ts";
 
-export interface HTTPTransportOptions {
-  /** Trusts a user-supplied CA without disabling certificate or host verification. */
-  ca?: ConnectionOptions["ca"];
+export { discardResponse } from "./http/response.ts";
+export { makeFetchHttpClient } from "./http/fetch-client.ts";
+export { makeNodeHttpClient, type HTTPTransportOptions } from "./http/node-client.ts";
+
+/** Keeps the transport cause (message and Node error code) so callers can tell network failures apart. */
+export function fromHttpClientError(error: HttpClientError.HttpClientError): DevinFailure {
+  const reason = error.reason;
+  switch (reason._tag) {
+    case "TransportError":
+    case "DecodeError":
+    case "EncodeError":
+    case "InvalidUrlError": return toDevinFailure(reason.cause ?? reason.description ?? error.message);
+    case "EmptyBodyError": return new DevinError({ message: reason.description ?? "The response has no body." });
+    case "StatusCodeError": return new DevinError({ message: reason.description ?? error.message });
+  }
 }
 
-export interface HTTPTransport {
-  fetch: typeof fetch;
-  close(): void;
+/** The response body as chunks, failing as Devin failures. */
+export function responseChunks(response: HttpClientResponse.HttpClientResponse): Stream.Stream<Uint8Array, DevinFailure> {
+  return Stream.mapError(response.stream, fromHttpClientError);
 }
 
-/**
- * HTTP/1.1-only transport. Owns a per-client pool and verifies TLS certificates and hosts.
- * The 5000ms socket timeout spells out the previous Node global agent setting as a PoC policy;
- * it is not the overall RPC deadline. It does not claim to match the CLI's TLS or pool policy.
- */
-export function createHTTPTransport(options: HTTPTransportOptions = {}): HTTPTransport {
-  const httpAgent = new HTTPAgent({ keepAlive: true, timeout: 5000 });
-  const httpsAgent = new HTTPSAgent({
-    keepAlive: true, timeout: 5000, rejectUnauthorized: true, minVersion: "TLSv1.2",
-    ALPNProtocols: ["http/1.1"], ...(options.ca === undefined ? {} : { ca: options.ca }),
+export function readBoundedBytes(response: HttpClientResponse.HttpClientResponse, maxBytes: number): Effect.Effect<Buffer, DevinFailure> {
+  return Effect.suspend(() => {
+    let bytes = 0;
+    const chunks: Uint8Array[] = [];
+    return responseChunks(response).pipe(
+      Stream.runForEach((chunk) => {
+        bytes += chunk.byteLength;
+        if (bytes > maxBytes) return failWith("The response size limit was exceeded.");
+        chunks.push(chunk);
+        return Effect.void;
+      }),
+      Effect.map(() => Buffer.concat(chunks)),
+    );
   });
-  let isClosed = false;
-  const fetchHTTP: typeof fetch = async (input, init) => {
-    if (isClosed) throw new Error("The HTTP transport is closed.");
-    if (!(typeof input === "string" || input instanceof URL) || !["POST", "GET"].includes(init?.method ?? "") || init?.redirect !== "error") {
-      throw new Error("This transport supports only URL GET/POST without redirects.");
-    }
-    const url = new URL(input);
-    if (!["https:", "http:"].includes(url.protocol)) throw new Error("Unsupported HTTP protocol.");
-    const body = typeof init.body === "string" ? Buffer.from(init.body)
-      : init.body instanceof Uint8Array ? Buffer.from(init.body) : undefined;
-    if (init.method === "POST" && !body) throw new Error("A POST body must be a string or a byte array.");
-    if (init.method === "GET" && init.body != null) throw new Error("A GET body is not supported.");
-    const validated = new Headers(init.headers);
-    const entries = init.headers instanceof Headers ? [...init.headers.entries()]
-      : Array.isArray(init.headers) ? init.headers : Object.entries(init.headers ?? {});
-    const headers: Record<string, string> = {};
-    for (const [name] of entries) {
-      const key = name.toLowerCase();
-      if (key !== "host" && key !== "content-length") headers[key] = validated.get(name)!;
-    }
-    headers.host = url.host;
-    if (body) headers["content-length"] = String(body.byteLength);
-    return new Promise<Response>((resolve, reject) => {
-      const isHTTPS = url.protocol === "https:";
-      const send = isHTTPS ? httpsRequest : httpRequest;
-      const request = send(url, {
-        method: init.method, headers, signal: init.signal ?? undefined,
-        agent: isHTTPS ? httpsAgent : httpAgent,
-      }, (incoming) => {
-        try {
-          const responseHeaders = new Headers();
-          for (const [name, value] of Object.entries(incoming.headers)) {
-            for (const entry of Array.isArray(value) ? value : value === undefined ? [] : [value]) responseHeaders.append(name, entry);
-          }
-          const status = incoming.statusCode ?? 502;
-          const hasNoBody = [204, 205, 304].includes(status);
-          const encoding = responseHeaders.get("content-encoding")?.trim().toLowerCase();
-          let stream: Readable = incoming;
-          if (hasNoBody) incoming.resume();
-          else if (encoding && encoding !== "identity") {
-            if (encoding !== "gzip") {
-              // An encoding problem in an error body must not hide an already received 401/403/429 status.
-              if (status >= 200 && status < 300) throw new Error("Unsupported HTTP response compression.");
-            } else {
-              const decoded = createGunzip();
-              // Propagates consumer cancellation and compression errors to the original socket and keeps backpressure.
-              pipeline(incoming, decoded, () => {});
-              stream = decoded;
-              responseHeaders.delete("content-encoding");
-              responseHeaders.delete("content-length");
-            }
-          }
-          resolve(new Response(hasNoBody ? null : Readable.toWeb(stream) as ReadableStream<Uint8Array>, {
-            status, headers: responseHeaders,
-          }));
-        } catch (error) {
-          incoming.destroy();
-          reject(error);
-        }
-      });
-      request.once("error", reject);
-      request.once("upgrade", (_response, socket) => {
-        socket.destroy();
-        reject(new Error("HTTP upgrade is not supported."));
-      });
-      request.removeHeader("connection");
-      request.end(body);
-    });
-  };
-  return {
-    fetch: fetchHTTP,
-    close() {
-      if (isClosed) return;
-      isClosed = true;
-      httpAgent.destroy();
-      httpsAgent.destroy();
-    },
-  };
 }
 
-/** Default transport for existing direct callers. ConnectClient owns its own pool. */
-export const requestHTTP: typeof fetch = createHTTPTransport().fetch;
+export function readBoundedJSON(response: HttpClientResponse.HttpClientResponse, maxBytes: number): Effect.Effect<unknown, DevinFailure> {
+  return Effect.flatMap(readBoundedBytes(response, maxBytes), (bytes) => Effect.try({
+    try: () => JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)) as unknown,
+    catch: () => new DevinError({ message: "The server did not return valid JSON." }),
+  }));
+}

package/src/core/protocol/protobuf.ts

@@ -1,20 +1,21 @@
 import { readdirSync, statSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { Effect } from "effect";
 import protobuf from "protobufjs";
-import { object, type JsonObject } from "../types.ts";
+import { DevinError, toDevinError } from "../errors.ts";
+import type { JsonObject } from "../types.ts";
+import { failWith, object } from "../validation.ts";
 
 export const CHAT_METHOD = "exa.api_server_pb.ApiServerService/GetChatMessage";
 
 export interface MessageCodec {
-  encode(value: JsonObject): Uint8Array;
-  decode(bytes: Uint8Array): JsonObject;
+  encode(value: JsonObject): Effect.Effect<Uint8Array, DevinError>;
+  decode(bytes: Uint8Array): Effect.Effect<JsonObject, DevinError>;
 }
 
-let root: protobuf.Root | undefined;
-const camelCase = (name: string) => name.replace(/_([a-z])/g, (_, letter: string) => letter.toUpperCase());
-
 const PROTO_ROOT = fileURLToPath(new URL("../../../proto/", import.meta.url));
+const camelCase = (name: string) => name.replace(/_([a-z])/g, (_, letter: string) => letter.toUpperCase());
 
 function protoSources(directory: string, out: string[] = []): string[] {
   for (const entry of readdirSync(directory)) {
@@ -25,87 +26,105 @@ function protoSources(directory: string, out: string[] = []): string[] {
   return out;
 }
 
-function getRoot(): protobuf.Root {
-  if (!root) {
-    // The schema is the shipped `proto/` source tree, parsed directly. The four definitions this
-    // package added from its own protocol analysis are marked in the sources, so nothing is
-    // patched in at runtime. keepCase keeps the declared snake_case names the DTO boundary uses.
-    root = new protobuf.Root();
+let loadedRoot: protobuf.Root | undefined;
+
+/**
+ * The schema is the shipped `proto/` source tree, parsed once per process. The four definitions this
+ * package added from its own protocol analysis are marked in the sources, so nothing is patched in at
+ * runtime. keepCase keeps the declared snake_case names the DTO boundary uses.
+ */
+const schemaRoot: Effect.Effect<protobuf.Root, DevinError> = Effect.suspend(() => loadedRoot ? Effect.succeed(loadedRoot) : Effect.try({
+  try: () => {
+    const root = new protobuf.Root();
     root.resolvePath = (_origin: string, target: string) => isAbsolute(target) ? target : join(PROTO_ROOT, target);
     root.loadSync(protoSources(PROTO_ROOT), { keepCase: true });
     root.resolveAll();
-  }
-  return root;
-}
+    loadedRoot = root;
+    return root;
+  },
+  catch: toDevinError,
+}));
 
 /** Converts between camelCase DTOs and the original snake_case at the boundary; user keys inside maps stay unchanged. */
-function convertFields(type: protobuf.Type, value: JsonObject, isEncoding: boolean, path: string): JsonObject {
-  const result: [string, unknown][] = [];
-  for (const [name, entry] of Object.entries(value)) {
-    if (entry === undefined || entry === null) continue;
-    const field = isEncoding ? type.fieldsArray.find((candidate) => camelCase(candidate.name) === name)
-      : Object.hasOwn(type.fields, name) ? type.fields[name] : undefined;
-    if (!field) throw new Error(`Field not in the protobuf schema: ${path}.${name}`);
-    const convert = (item: unknown): unknown => {
-      if (field.resolvedType instanceof protobuf.Type) {
-        return convertFields(field.resolvedType, object(item, `${path}.${name}`), isEncoding, `${path}.${name}`);
-      }
-      // Prevents fromObject from silently turning an invalid enum into 0.
-      if (isEncoding && field.resolvedType instanceof protobuf.Enum) {
-        const isValid = typeof item === "string" ? Object.hasOwn(field.resolvedType.values, item)
-          : typeof item === "number" && Object.hasOwn(field.resolvedType.valuesById, item);
-        if (!isValid) throw new Error(`Unknown protobuf enum: ${path}.${name}`);
-      }
-      return item;
-    };
-    let converted: unknown;
-    if (field.map) converted = Object.fromEntries(Object.entries(object(entry, `${path}.${name}`)).map(([key, item]) => [key, convert(item)]));
-    else if (field.repeated) {
-      if (!Array.isArray(entry)) throw new Error(`Field requires an array: ${path}.${name}`);
-      converted = entry.map(convert);
-    } else converted = convert(entry);
-    result.push([isEncoding ? field.name : camelCase(field.name), converted]);
-  }
-  return Object.fromEntries(result);
+function convertFields(type: protobuf.Type, value: JsonObject, isEncoding: boolean, path: string): Effect.Effect<JsonObject, DevinError> {
+  return Effect.gen(function* () {
+    const result: [string, unknown][] = [];
+    for (const [name, entry] of Object.entries(value)) {
+      if (entry === undefined || entry === null) continue;
+      const field = isEncoding ? type.fieldsArray.find((candidate) => camelCase(candidate.name) === name)
+        : Object.hasOwn(type.fields, name) ? type.fields[name] : undefined;
+      if (!field) return yield* failWith(`Field not in the protobuf schema: ${path}.${name}`);
+      const label = `${path}.${name}`;
+      const convert = (item: unknown): Effect.Effect<unknown, DevinError> => {
+        if (field.resolvedType instanceof protobuf.Type) {
+          const nested = field.resolvedType;
+          return object(item, label).pipe(Effect.flatMap((fields) => convertFields(nested, fields, isEncoding, label)));
+        }
+        // Prevents fromObject from silently turning an invalid enum into 0.
+        if (isEncoding && field.resolvedType instanceof protobuf.Enum) {
+          const values = field.resolvedType;
+          const isValid = typeof item === "string" ? Object.hasOwn(values.values, item)
+            : typeof item === "number" && Object.hasOwn(values.valuesById, item);
+          if (!isValid) return failWith(`Unknown protobuf enum: ${label}`);
+        }
+        return Effect.succeed(item);
+      };
+      let converted: unknown;
+      if (field.map) {
+        const entries = Object.entries(yield* object(entry, label));
+        converted = Object.fromEntries(yield* Effect.forEach(entries, ([key, item]) => Effect.map(convert(item), (mapped) => [key, mapped] as const)));
+      } else if (field.repeated) {
+        if (!Array.isArray(entry)) return yield* failWith(`Field requires an array: ${label}`);
+        converted = yield* Effect.forEach(entry, convert);
+      } else converted = yield* convert(entry);
+      result.push([isEncoding ? field.name : camelCase(field.name), converted]);
+    }
+    return Object.fromEntries(result);
+  });
 }
 
 function messageCodec(typeName: string): MessageCodec {
-  const getType = () => getRoot().lookupType(typeName);
+  const messageType = Effect.flatMap(schemaRoot, (root) => Effect.try({ try: () => root.lookupType(typeName), catch: toDevinError }));
   return {
-    encode(value) {
-      const type = getType();
-      const message = type.fromObject(convertFields(type, value, true, typeName));
+    encode: (value) => Effect.gen(function* () {
+      const type = yield* messageType;
+      const fields = yield* convertFields(type, value, true, typeName);
+      const message = yield* Effect.try({ try: () => type.fromObject(fields), catch: toDevinError });
       const error = type.verify(message);
-      if (error) throw new Error(`Invalid protobuf input: ${error}`);
-      return type.encode(message).finish();
-    },
-    decode(bytes) {
-      const type = getType();
-      try {
-        const decoded = object(type.toObject(type.decode(bytes), {
-          longs: String, enums: String, bytes: String, defaults: false,
-        }), typeName);
-        return convertFields(type, decoded, false, typeName);
-      } catch {
-        throw new Error(`Invalid protobuf response: ${typeName}`);
-      }
-    },
+      if (error) return yield* failWith(`Invalid protobuf input: ${error}`);
+      return yield* Effect.try({ try: () => type.encode(message).finish(), catch: toDevinError });
+    }),
+    decode: (bytes) => Effect.flatMap(messageType, (type) => Effect.gen(function* () {
+      const decoded = yield* Effect.try({
+        try: () => type.toObject(type.decode(bytes), { longs: String, enums: String, bytes: String, defaults: false }),
+        catch: toDevinError,
+      });
+      return yield* convertFields(type, yield* object(decoded, typeName), false, typeName);
+    }).pipe(Effect.mapError(() => new DevinError({ message: `Invalid protobuf response: ${typeName}` })))),
   };
 }
 
-export function unaryCodecs(method: string): { request: MessageCodec; response: MessageCodec } {
-  const split = method.lastIndexOf("/");
-  if (split <= 0) throw new Error("A valid RPC path is required.");
-  const service = getRoot().lookupService(method.slice(0, split));
-  const definition = service.methods[method.slice(split + 1)];
-  definition?.resolve();
-  if (!definition?.resolvedRequestType || !definition.resolvedResponseType || definition.responseStream || definition.requestStream) {
-    throw new Error(`Unsupported unary RPC: ${method}`);
-  }
-  return {
-    request: messageCodec(definition.resolvedRequestType.fullName),
-    response: messageCodec(definition.resolvedResponseType.fullName),
-  };
+export function unaryCodecs(method: string): Effect.Effect<{ request: MessageCodec; response: MessageCodec }, DevinError> {
+  return Effect.gen(function* () {
+    const split = method.lastIndexOf("/");
+    if (split <= 0) return yield* failWith("A valid RPC path is required.");
+    const root = yield* schemaRoot;
+    const definition = yield* Effect.try({
+      try: () => {
+        const found = root.lookupService(method.slice(0, split)).methods[method.slice(split + 1)];
+        found?.resolve();
+        return found;
+      },
+      catch: toDevinError,
+    });
+    if (!definition?.resolvedRequestType || !definition.resolvedResponseType || definition.responseStream || definition.requestStream) {
+      return yield* failWith(`Unsupported unary RPC: ${method}`);
+    }
+    return {
+      request: messageCodec(definition.resolvedRequestType.fullName),
+      response: messageCodec(definition.resolvedResponseType.fullName),
+    };
+  });
 }
 
 export const chatRequestCodec = messageCodec("exa.api_server_pb.GetChatMessageRequest");

package/src/core/redaction.ts

@@ -0,0 +1,33 @@
+import { Predicate } from "effect";
+import { Cancelled, DevinError, RequestTimeout, RPCError, type DevinFailure } from "./errors.ts";
+import type { JsonObject } from "./types.ts";
+
+export function safeError(error: unknown, secrets: readonly string[] = []): string {
+  let text = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) if (secret) text = text.split(secret).join("[REDACTED]");
+  return text.replace(/devin-session-token\$[^\s"'<>]+/g, "[REDACTED]")
+    .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "").slice(0, 800);
+}
+
+export function requestSecrets(body: JsonObject, token?: string): string[] {
+  const metadata = Predicate.isObject(body.metadata) ? body.metadata as JsonObject : {};
+  // f is ciphertext that contains the API token. Treat it as sensitive as the token itself.
+  const uppercaseFingerprint = Predicate.isString(metadata.f) ? metadata.f.toUpperCase() : undefined;
+  return [token, metadata.apiKey, metadata.f, uppercaseFingerprint, body.apiKey, body.modelAssignmentJwt, body.code, body.authorizationCode, body.codeVerifier]
+    .filter((value): value is string => Predicate.isString(value) && value.length > 0);
+}
+
+/** The same failure with tokens, codes and other secrets removed from its message. */
+export function redactFailure(failure: DevinFailure, secrets: readonly string[]): DevinFailure {
+  switch (failure._tag) {
+    case "RPCError": return new RPCError({
+      code: safeError(failure.code, secrets), message: safeError(failure, secrets),
+      httpStatus: failure.httpStatus, retryAfterMs: failure.retryAfterMs,
+    });
+    case "DevinError": return new DevinError({
+      message: safeError(failure, secrets), code: failure.code === undefined ? undefined : safeError(failure.code, secrets),
+    });
+    case "Cancelled": return new Cancelled({ message: safeError(failure, secrets) });
+    case "RequestTimeout": return new RequestTimeout({ message: safeError(failure, secrets) });
+  }
+}

package/src/core/services/device-identity.ts

@@ -0,0 +1,15 @@
+import { Context, Effect, Layer } from "effect";
+import { ChildProcessSpawner } from "effect/process";
+import { collectDeviceIdentity, nodeDeviceSystem, type DeviceIdentity } from "../protocol/device.ts";
+
+export interface DeviceIdentitySourceShape {
+  /** Reads the device values the request fingerprint is built from. Never fails: unreadable values become their documented empty value. */
+  readonly collect: Effect.Effect<DeviceIdentity>;
+}
+
+/** Where request fingerprints get their device values. Each fingerprint provider collects once and keeps the result. */
+export class DeviceIdentitySource extends Context.Service<DeviceIdentitySource, DeviceIdentitySourceShape>()("pi-devin/DeviceIdentitySource") {}
+
+/** Reads this machine through the process and network APIs. */
+export const NodeDeviceIdentitySource: Layer.Layer<DeviceIdentitySource, never, ChildProcessSpawner.ChildProcessSpawner> = Layer.effect(DeviceIdentitySource,
+  Effect.map(ChildProcessSpawner.ChildProcessSpawner, (spawner) => ({ collect: collectDeviceIdentity(nodeDeviceSystem(spawner)) })));