@abot-ai/runtime 1.2.0 → 1.3.1

package/plugins/web/source/aggregate-gate.ts

@@ -1,141 +1,19 @@
-import { remainingTime, withinDeadline } from "./deadline.js";
-import { WebPluginError } from "./errors.js";
-
-type Release = () => void;
-
-type Waiter = {
-  resolve: (release: Release) => void;
-  reject: (error: WebPluginError) => void;
-  deadline: number;
-  abortSignal?: AbortSignal;
-  timeout?: NodeJS.Timeout;
-  onAbort?: () => void;
-};
+import { createAggregateGate as createSharedGate } from "../../../src/shared/public-http/aggregate-gate.js";
+import { rethrowWebPluginError } from "./errors.js";
 
 export function createAggregateGate(maxActive: number, maxQueued: number) {
-  let active = 0;
-  const queue: Waiter[] = [];
-
-  const startQueued = () => {
-    while (active < maxActive && queue.length > 0) {
-      const waiter = queue.shift()!;
-      clearTimeout(waiter.timeout);
-      if (waiter.onAbort) {
-        waiter.abortSignal?.removeEventListener("abort", waiter.onAbort);
-      }
-      if (waiter.abortSignal?.aborted) {
-        waiter.reject(
-          new WebPluginError(
-            "web_request_aborted",
-            "The web request was aborted.",
-          ),
-        );
-        continue;
-      }
-      if (waiter.deadline <= Date.now()) {
-        waiter.reject(
-          new WebPluginError(
-            "web_request_timed_out",
-            "The upstream web request timed out.",
-          ),
-        );
-        continue;
-      }
-      active += 1;
-      let released = false;
-      waiter.resolve(() => {
-        if (released) return;
-        released = true;
-        active -= 1;
-        startQueued();
-      });
-    }
-  };
-
-  const acquire = (
-    deadline: number,
-    abortSignal?: AbortSignal,
-  ): Promise<Release> => {
-    if (abortSignal?.aborted) {
-      return Promise.reject(
-        new WebPluginError(
-          "web_request_aborted",
-          "The web request was aborted.",
-        ),
-      );
-    }
-    if (active < maxActive) {
-      active += 1;
-      let released = false;
-      return Promise.resolve(() => {
-        if (released) return;
-        released = true;
-        active -= 1;
-        startQueued();
-      });
-    }
-    if (queue.length >= maxQueued) {
-      return Promise.reject(
-        new WebPluginError(
-          "web_request_capacity_exceeded",
-          "The web client is at its bounded request capacity.",
-        ),
-      );
-    }
-    return new Promise((resolve, reject) => {
-      const waiter: Waiter = {
-        resolve,
-        reject,
-        deadline,
-        ...(abortSignal ? { abortSignal } : {}),
-      };
-      const remove = () => {
-        const index = queue.indexOf(waiter);
-        if (index >= 0) queue.splice(index, 1);
-      };
-      const fail = (error: WebPluginError) => {
-        remove();
-        clearTimeout(waiter.timeout);
-        if (waiter.onAbort) {
-          abortSignal?.removeEventListener("abort", waiter.onAbort);
-        }
-        reject(error);
-      };
-      waiter.onAbort = () =>
-        fail(
-          new WebPluginError(
-            "web_request_aborted",
-            "The web request was aborted.",
-          ),
-        );
-      waiter.timeout = setTimeout(
-        () =>
-          fail(
-            new WebPluginError(
-              "web_request_timed_out",
-              "The upstream web request timed out.",
-            ),
-          ),
-        remainingTime(deadline),
-      );
-      waiter.timeout.unref?.();
-      abortSignal?.addEventListener("abort", waiter.onAbort, { once: true });
-      queue.push(waiter);
-    });
-  };
-
+  const gate = createSharedGate(maxActive, maxQueued);
   return Object.freeze({
     async run<T>(
       operation: () => Promise<T>,
       deadline: number,
       abortSignal?: AbortSignal,
     ): Promise<T> {
-      const release = await acquire(deadline, abortSignal);
-      const rawWork = Promise.resolve().then(operation);
-      // A deadline rejects the visible operation promptly, but the capacity slot
-      // remains held until non-cancellable DNS or transport work actually settles.
-      void rawWork.then(release, release);
-      return await withinDeadline(rawWork, deadline, abortSignal);
+      try {
+        return await gate.run(operation, deadline, abortSignal);
+      } catch (error) {
+        return rethrowWebPluginError(error);
+      }
     },
   });
 }

package/plugins/web/source/deadline.ts

@@ -1,61 +1,25 @@
-import { WebPluginError } from "./errors.js";
+import {
+  remainingTime as sharedRemainingTime,
+  withinDeadline as sharedWithinDeadline,
+} from "../../../src/shared/public-http/deadline.js";
+import { rethrowWebPluginError } from "./errors.js";
 
 export function remainingTime(deadline: number): number {
-  const remaining = deadline - Date.now();
-  if (remaining <= 0) {
-    throw new WebPluginError(
-      "web_request_timed_out",
-      "The upstream web request timed out.",
-    );
+  try {
+    return sharedRemainingTime(deadline);
+  } catch (error) {
+    return rethrowWebPluginError(error);
   }
-  return remaining;
 }
 
-export function withinDeadline<T>(
+export async function withinDeadline<T>(
   promise: Promise<T>,
   deadline: number,
   abortSignal?: AbortSignal,
 ): Promise<T> {
-  if (abortSignal?.aborted) {
-    return Promise.reject(
-      new WebPluginError("web_request_aborted", "The web request was aborted."),
-    );
+  try {
+    return await sharedWithinDeadline(promise, deadline, abortSignal);
+  } catch (error) {
+    return rethrowWebPluginError(error);
   }
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const finish = (operation: () => void) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      abortSignal?.removeEventListener("abort", onAbort);
-      operation();
-    };
-    const onAbort = () =>
-      finish(() =>
-        reject(
-          new WebPluginError(
-            "web_request_aborted",
-            "The web request was aborted.",
-          ),
-        ),
-      );
-    const timeout = setTimeout(
-      () =>
-        finish(() =>
-          reject(
-            new WebPluginError(
-              "web_request_timed_out",
-              "The upstream web request timed out.",
-            ),
-          ),
-        ),
-      remainingTime(deadline),
-    );
-    timeout.unref?.();
-    abortSignal?.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => finish(() => resolve(value)),
-      (error) => finish(() => reject(error)),
-    );
-  });
 }

package/plugins/web/source/errors.ts

@@ -1,14 +1,12 @@
+import {
+  PublicHttpError,
+  isPublicHttpError,
+  type PublicHttpErrorCode,
+} from "../../../src/shared/public-http/errors.js";
+
 export type WebPluginErrorCode =
-  | "web_request_aborted"
-  | "web_request_timed_out"
-  | "web_request_capacity_exceeded"
-  | "web_target_invalid"
-  | "web_target_not_public"
-  | "web_target_unresolvable"
-  | "web_redirect_invalid"
-  | "web_redirect_limit_exceeded"
+  | PublicHttpErrorCode
   | "web_response_unsupported"
-  | "web_response_invalid"
   | "web_fetch_http_error"
   | "web_search_api_key_missing"
   | "web_search_authentication_failed"
@@ -20,11 +18,11 @@ export type WebPluginErrorCode =
   | "web_search_sources_unavailable"
   | "web_search_configuration_invalid";
 
-export class WebPluginError extends Error {
+export class WebPluginError extends PublicHttpError<WebPluginErrorCode> {
   readonly code: WebPluginErrorCode;
 
   constructor(code: WebPluginErrorCode, message: string) {
-    super(message);
+    super(code, message);
     this.name = "WebPluginError";
     this.code = code;
   }
@@ -33,3 +31,11 @@ export class WebPluginError extends Error {
 export function isWebPluginError(error: unknown): error is WebPluginError {
   return error instanceof WebPluginError;
 }
+
+export function rethrowWebPluginError(error: unknown): never {
+  if (error instanceof WebPluginError) throw error;
+  if (isPublicHttpError(error)) {
+    throw new WebPluginError(error.code, error.message);
+  }
+  throw error;
+}

package/plugins/web/source/limits.ts

@@ -1,4 +1,7 @@
+import { PUBLIC_HTTP_LIMITS } from "../../../src/shared/public-http/limits.js";
+
 export const WEB_LIMITS = Object.freeze({
+  ...PUBLIC_HTTP_LIMITS,
   queryMaxChars: 400,
   queryMaxWords: 50,
   searchQueries: 5,
@@ -9,14 +12,9 @@ export const WEB_LIMITS = Object.freeze({
   targetReadableSources: 3,
   fetchUrls: 3,
   fetchConcurrency: 3,
-  httpConcurrency: 6,
-  httpQueueLimit: 64,
-  redirects: 3,
-  responseBytes: 512 * 1024,
   outputChars: 16_000,
   pageOutputChars: 12_000,
   sourceOutputChars: 3_000,
-  requestTimeoutMs: 10_000,
   searchTotalTimeoutMs: 30_000,
   outputBytes: 48 * 1024,
   upstreamUrlChars: 4_096,
@@ -25,5 +23,4 @@ export const WEB_LIMITS = Object.freeze({
   upstreamSnippetChars: 800,
   retryAttempts: 2,
   retryBaseMs: 750,
-  responseHeaderBytes: 32 * 1024,
 } as const);

package/plugins/web/source/network-policy.ts

@@ -1,242 +1,44 @@
-import { lookup } from "node:dns/promises";
-import { isIP } from "node:net";
-
-import { WebPluginError } from "./errors.js";
-
-export type PublicAddress = Readonly<{
-  address: string;
-  family: 4 | 6;
-}>;
-
-export type HostResolver = (
-  hostname: string,
-) => Promise<readonly PublicAddress[]>;
-
-function ipv4Value(address: string): number | undefined {
-  if (isIP(address) !== 4) return undefined;
-  const octets = address.split(".").map(Number);
-  return (
-    ((octets[0]! << 24) >>> 0) +
-    (octets[1]! << 16) +
-    (octets[2]! << 8) +
-    octets[3]!
-  );
-}
-
-function ipv4InCidr(value: number, base: number, bits: number): boolean {
-  const shift = 32 - bits;
-  return value >>> shift === base >>> shift;
-}
-
-export function isPublicIpv4(address: string): boolean {
-  const value = ipv4Value(address);
-  if (value === undefined) return false;
-  const blocked = [
-    ["0.0.0.0", 8],
-    ["10.0.0.0", 8],
-    ["100.64.0.0", 10],
-    ["127.0.0.0", 8],
-    ["169.254.0.0", 16],
-    ["172.16.0.0", 12],
-    ["192.0.0.0", 24],
-    ["192.0.2.0", 24],
-    ["192.88.99.0", 24],
-    ["192.168.0.0", 16],
-    ["198.18.0.0", 15],
-    ["198.51.100.0", 24],
-    ["203.0.113.0", 24],
-    ["224.0.0.0", 4],
-    ["240.0.0.0", 4],
-  ] as const;
-  return !blocked.some(([base, bits]) =>
-    ipv4InCidr(value, ipv4Value(base)!, bits),
-  );
-}
-
-function parseIpv6(address: string): bigint | undefined {
-  const normalized = address.toLowerCase().replace(/^\[|\]$/gu, "");
-  if (normalized.includes("%") || isIP(normalized) !== 6) return undefined;
-  let candidate = normalized;
-  const ipv4Tail = candidate.match(/(?:^|:)(\d+\.\d+\.\d+\.\d+)$/u)?.[1];
-  if (ipv4Tail) {
-    const value = ipv4Value(ipv4Tail);
-    if (value === undefined) return undefined;
-    candidate = candidate.slice(0, -ipv4Tail.length);
-    candidate += `${((value >>> 16) & 0xffff).toString(16)}:${(
-      value & 0xffff
-    ).toString(16)}`;
-  }
-  const doubleColon = candidate.indexOf("::");
-  if (doubleColon !== candidate.lastIndexOf("::")) return undefined;
-  const head = (doubleColon >= 0 ? candidate.slice(0, doubleColon) : candidate)
-    .split(":")
-    .filter(Boolean);
-  const tail = (doubleColon >= 0 ? candidate.slice(doubleColon + 2) : "")
-    .split(":")
-    .filter(Boolean);
-  const missing = 8 - head.length - tail.length;
-  if ((doubleColon < 0 && missing !== 0) || (doubleColon >= 0 && missing < 1)) {
-    return undefined;
-  }
-  const groups = [...head, ...Array(missing).fill("0"), ...tail];
-  if (
-    groups.length !== 8 ||
-    groups.some((group) => !/^[0-9a-f]{1,4}$/u.test(group))
-  ) {
-    return undefined;
-  }
-  return groups.reduce(
-    (value, group) => (value << 16n) | BigInt(Number.parseInt(group, 16)),
-    0n,
-  );
-}
-
-function ipv6InCidr(value: bigint, baseAddress: string, bits: number): boolean {
-  const base = parseIpv6(baseAddress)!;
-  const shift = BigInt(128 - bits);
-  return value >> shift === base >> shift;
-}
-
-export function isPublicIpv6(address: string): boolean {
-  const value = parseIpv6(address);
-  if (value === undefined) return false;
-  if (ipv6InCidr(value, "::ffff:0:0", 96)) {
-    const mapped = Number(value & 0xffff_ffffn) >>> 0;
-    const dotted = [24, 16, 8, 0]
-      .map((shift) => (mapped >>> shift) & 0xff)
-      .join(".");
-    return isPublicIpv4(dotted);
-  }
-  if (
-    ipv6InCidr(value, "64:ff9b::", 96) ||
-    ipv6InCidr(value, "64:ff9b:1::", 48)
-  ) {
-    return false;
-  }
-  if (!ipv6InCidr(value, "2000::", 3)) return false;
-  const blocked = [
-    ["2001::", 23],
-    ["2001:db8::", 32],
-    ["2002::", 16],
-    ["3fff::", 20],
-  ] as const;
-  return !blocked.some(([base, bits]) => ipv6InCidr(value, base, bits));
-}
-
-export function isPublicAddress(address: PublicAddress): boolean {
-  return address.family === 4
-    ? isPublicIpv4(address.address)
-    : isPublicIpv6(address.address);
-}
-
-function normalizeHostname(hostname: string): string {
-  return hostname
-    .toLowerCase()
-    .replace(/^\[|\]$/gu, "")
-    .replace(/\.$/u, "");
-}
-
-function isBlockedHostname(hostname: string): boolean {
-  return (
-    hostname === "localhost" ||
-    hostname.endsWith(".localhost") ||
-    hostname.endsWith(".local") ||
-    hostname.endsWith(".internal") ||
-    hostname.endsWith(".home") ||
-    hostname.endsWith(".lan")
-  );
-}
+import {
+  parsePublicHttpUrl as parseSharedUrl,
+  resolvePublicTarget as resolveSharedTarget,
+  resolveHostAddresses as resolveSharedAddresses,
+  type HostResolver,
+} from "../../../src/shared/public-http/network-policy.js";
+import { rethrowWebPluginError } from "./errors.js";
+
+export {
+  isPublicAddress,
+  isPublicIpv4,
+  isPublicIpv6,
+} from "../../../src/shared/public-http/network-policy.js";
+export type {
+  PublicAddress,
+  HostResolver,
+} from "../../../src/shared/public-http/network-policy.js";
 
 export function parsePublicHttpUrl(rawUrl: string): URL {
-  let parsed: URL;
   try {
-    parsed = new URL(rawUrl);
-  } catch {
-    throw new WebPluginError(
-      "web_target_invalid",
-      "A valid absolute URL is required.",
-    );
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new WebPluginError(
-      "web_target_invalid",
-      "Only http and https URLs are supported.",
-    );
-  }
-  if (parsed.username || parsed.password) {
-    throw new WebPluginError(
-      "web_target_invalid",
-      "URLs containing credentials are not supported.",
-    );
-  }
-  const hostname = normalizeHostname(parsed.hostname);
-  if (!hostname || isBlockedHostname(hostname)) {
-    throw new WebPluginError(
-      "web_target_not_public",
-      "Only public Internet targets are allowed.",
-    );
+    return parseSharedUrl(rawUrl);
+  } catch (error) {
+    return rethrowWebPluginError(error);
   }
-  const family = isIP(hostname);
-  if (
-    (family === 4 && !isPublicIpv4(hostname)) ||
-    (family === 6 && !isPublicIpv6(hostname))
-  ) {
-    throw new WebPluginError(
-      "web_target_not_public",
-      "Only public Internet targets are allowed.",
-    );
-  }
-  return parsed;
 }
 
 export const resolveHostAddresses: HostResolver = async (hostname) => {
-  const normalized = normalizeHostname(hostname);
-  const literalFamily = isIP(normalized);
-  if (literalFamily === 4 || literalFamily === 6) {
-    return Object.freeze([
-      Object.freeze({ address: normalized, family: literalFamily }),
-    ]);
-  }
-  let resolved: readonly { address: string; family: number }[];
   try {
-    resolved = await lookup(normalized, { all: true, verbatim: true });
-  } catch {
-    throw new WebPluginError(
-      "web_target_unresolvable",
-      "The public target hostname could not be resolved.",
-    );
+    return await resolveSharedAddresses(hostname);
+  } catch (error) {
+    return rethrowWebPluginError(error);
   }
-  const addresses = resolved
-    .filter(
-      (entry): entry is { address: string; family: 4 | 6 } =>
-        entry.family === 4 || entry.family === 6,
-    )
-    .map((entry) =>
-      Object.freeze({ address: entry.address, family: entry.family }),
-    );
-  if (addresses.length === 0) {
-    throw new WebPluginError(
-      "web_target_unresolvable",
-      "The public target hostname could not be resolved.",
-    );
-  }
-  return Object.freeze(addresses);
 };
 
 export async function resolvePublicTarget(
   url: URL,
   resolver: HostResolver = resolveHostAddresses,
-): Promise<PublicAddress> {
-  const hostname = normalizeHostname(url.hostname);
-  const addresses = await resolver(hostname);
-  if (
-    addresses.length === 0 ||
-    addresses.some((entry) => !isPublicAddress(entry))
-  ) {
-    throw new WebPluginError(
-      "web_target_not_public",
-      "Only public Internet targets are allowed.",
-    );
+) {
+  try {
+    return await resolveSharedTarget(url, resolver);
+  } catch (error) {
+    return rethrowWebPluginError(error);
   }
-  return addresses[0]!;
 }