@gatebolt/agent-redroom 0.1.0 → 0.1.2

package/dist/sidecar/sidecar.d.ts

@@ -1,5 +1,6 @@
 import { type SidecarPorts } from "./config.js";
 import { type Ips } from "./dns.js";
+import { type RequestLimits } from "./http.js";
 import { SidecarState } from "./state.js";
 export type SidecarOptions = {
     controlSecret: string;
@@ -11,6 +12,8 @@ export type SidecarOptions = {
     fetch?: typeof fetch;
     checkTimeoutMs?: number;
     upstreamIdleTimeoutMs?: number;
+    requestLimits?: Partial<RequestLimits>;
+    requestTimeoutMs?: number;
     lease?: {
         ms: number;
         onExpired: () => void;

package/dist/sidecar/sidecar.js

@@ -5,6 +5,7 @@ import {} from "./config.js";
 import { createControl } from "./control.js";
 import { createDns } from "./dns.js";
 import { createFakeHttp, createFakeHttps, generateTls } from "./fake-web.js";
+import { REQUEST_TIMEOUT_MS } from "./http.js";
 import { createRelay, UPSTREAM_IDLE_TIMEOUT_MS } from "./relay.js";
 import { SidecarState } from "./state.js";
 import { CHECK_TIMEOUT_MS, createToolHook } from "./tool-hook.js";
@@ -34,7 +35,7 @@ const close = (server) => new Promise((resolve) => {
     server.closeAllConnections();
 });
 export async function startSidecar(options) {
-    const state = new SidecarState();
+    const state = new SidecarState(options.requestLimits);
     const host = options.host ?? "0.0.0.0";
     const trustTestSourceHeader = options.trustTestSourceHeader ?? false;
     const { domain } = options;
@@ -49,7 +50,8 @@ export async function startSidecar(options) {
         }, Math.max(1, Math.floor(lease.ms / 4)))
         : undefined;
     leaseTimer?.unref();
-    const web = { state, domain, trustTestSourceHeader };
+    const requestTimeoutMs = options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
+    const web = { state, domain, trustTestSourceHeader, requestTimeoutMs };
     const servers = {
         http: createFakeHttp(web),
         https: createFakeHttps(web, tls),
@@ -57,6 +59,7 @@ export async function startSidecar(options) {
             state,
             trustTestSourceHeader,
             idleTimeoutMs: options.upstreamIdleTimeoutMs ?? UPSTREAM_IDLE_TIMEOUT_MS,
+            requestTimeoutMs,
         }),
         hook: createToolHook({
             state,
@@ -64,6 +67,7 @@ export async function startSidecar(options) {
             signal: controller.signal,
             trustTestSourceHeader,
             timeoutMs: options.checkTimeoutMs ?? CHECK_TIMEOUT_MS,
+            requestTimeoutMs,
         }),
         control: createControl({
             state,

package/dist/sidecar/state.d.ts

@@ -1,4 +1,5 @@
 import { type IncomingMessage } from "node:http";
+import { RequestBudget, type RequestLimits } from "./http.js";
 import { type Hit, type ModelCall, type ModelProxy, type SecretMatch, type Secrets, type ToolCall, type ToolCallCheck } from "../types.js";
 export declare const MAX_ENTRIES = 10000;
 export declare const MAX_LOG_BYTES: number;
@@ -37,6 +38,8 @@ export declare function drain<T>(log: Log<T>): Log<T>;
 export declare class SidecarState {
     readonly runs: Map<string, RunState>;
     readonly unattributed: Log<Hit>;
+    readonly requests: RequestBudget;
+    constructor(limits?: Partial<RequestLimits>);
     register(id: string, run: Pick<RunState, "ip" | "pages" | "secrets" | "modelProxy" | "toolCallCheck">): "ok" | "run" | "ip";
     runEntryForIp(ip: string): [string, RunState] | undefined;
     runForIp(ip: string): RunState | undefined;

package/dist/sidecar/state.js

@@ -1,5 +1,6 @@
 import {} from "node:http";
 import { findSecrets } from "../secrets.js";
+import { RequestBudget } from "./http.js";
 import {} from "../types.js";
 export const MAX_ENTRIES = 10_000;
 export const MAX_LOG_BYTES = 4 * 1024 * 1024;
@@ -61,6 +62,10 @@ export function drain(log) {
 export class SidecarState {
     runs = new Map();
     unattributed = emptyLog();
+    requests;
+    constructor(limits) {
+        this.requests = new RequestBudget(limits);
+    }
     register(id, run) {
         if (this.runs.has(id))
             return "run";

package/dist/sidecar/tool-hook.d.ts

@@ -9,5 +9,6 @@ export type ToolHookContext = {
     signal: AbortSignal;
     trustTestSourceHeader: boolean;
     timeoutMs: number;
+    requestTimeoutMs: number;
 };
 export declare function createToolHook(context: ToolHookContext): Server;

package/dist/sidecar/tool-hook.js

@@ -2,7 +2,7 @@ import {} from "node:http";
 import { z } from "zod";
 import { findSecrets } from "../secrets.js";
 import { DETAIL_LIMIT, isRecord, messageOf, } from "../types.js";
-import { BodyTooLargeError, jsonServer, readBody, readJson, sendJson, } from "./http.js";
+import { BodyTooLargeError, BODY_LIMIT_BYTES, jsonServer, readBody, readJson, sendJson, } from "./http.js";
 import { push, sourceIp } from "./state.js";
 export const CHECK_TIMEOUT_MS = 25_000;
 const hookSchema = z.object({
@@ -111,37 +111,86 @@ export function createToolHook(context) {
                 at: new Date(started).toISOString(),
                 error: { by: "sidecar", code, detail: detail.slice(0, DETAIL_LIMIT) },
             });
-            sendJson(res, status, {});
+            if (!res.destroyed)
+                sendJson(res, status, {}, { Connection: "close" });
         };
-        let payload;
+        const lease = context.state.requests.take(source);
+        if (!lease)
+            return refuse(429, "request_limit", "too many in-flight requests");
+        const controller = new AbortController();
+        let handlerDone = false;
+        let responseDone = false;
+        let timedOut = false;
+        const release = () => {
+            if (handlerDone && responseDone)
+                lease.release();
+        };
+        res.once("finish", () => {
+            responseDone = true;
+            release();
+        });
+        res.once("close", () => {
+            responseDone = true;
+            controller.abort();
+            release();
+        });
+        req.once("aborted", () => {
+            controller.abort();
+        });
+        req.once("error", () => {
+            controller.abort();
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            req.destroy(new Error("request body timed out"));
+        }, context.requestTimeoutMs);
+        timer.unref();
+        req.once("end", () => clearTimeout(timer));
         try {
-            payload = await readJson(req);
-        }
-        catch (error) {
-            return error instanceof BodyTooLargeError
-                ? refuse(413, "payload_too_large", messageOf(error))
-                : refuse(400, "invalid_payload", messageOf(error));
+            if (!lease.reserve(2 * BODY_LIMIT_BYTES)) {
+                return refuse(429, "buffer_limit", "too many buffered request bytes");
+            }
+            let payload;
+            try {
+                payload = await readJson(req);
+            }
+            catch (error) {
+                if (timedOut)
+                    return refuse(408, "request_timeout", "request body timed out");
+                return error instanceof BodyTooLargeError
+                    ? refuse(413, "payload_too_large", messageOf(error))
+                    : refuse(400, "invalid_payload", messageOf(error));
+            }
+            const hook = hookSchema.safeParse(payload);
+            if (!hook.success) {
+                return refuse(400, "invalid_payload", hook.error.message, payload);
+            }
+            const check = owned.toolCallCheck;
+            const checked = check
+                ? await askCheck({
+                    ...context,
+                    signal: AbortSignal.any([context.signal, controller.signal]),
+                }, check, runId, payload)
+                : { response: {} };
+            push(owned.toolCalls, {
+                toolUseId: hook.data.tool_use_id,
+                tool: hook.data.tool_name,
+                input: hook.data.tool_input,
+                hookPayload: payload,
+                response: checked.response,
+                action: actionOf(checked.response),
+                checked: check !== undefined,
+                latencyMs: Date.now() - started,
+                at: new Date(started).toISOString(),
+                ...(checked.error ? { error: checked.error } : {}),
+            }, findSecrets(String(JSON.stringify(hook.data.tool_input)), owned.secrets));
+            if (!res.destroyed)
+                sendJson(res, 200, checked.response);
         }
-        const hook = hookSchema.safeParse(payload);
-        if (!hook.success) {
-            return refuse(400, "invalid_payload", hook.error.message, payload);
+        finally {
+            clearTimeout(timer);
+            handlerDone = true;
+            release();
         }
-        const check = owned.toolCallCheck;
-        const checked = check
-            ? await askCheck(context, check, runId, payload)
-            : { response: {} };
-        push(owned.toolCalls, {
-            toolUseId: hook.data.tool_use_id,
-            tool: hook.data.tool_name,
-            input: hook.data.tool_input,
-            hookPayload: payload,
-            response: checked.response,
-            action: actionOf(checked.response),
-            checked: check !== undefined,
-            latencyMs: Date.now() - started,
-            at: new Date(started).toISOString(),
-            ...(checked.error ? { error: checked.error } : {}),
-        }, findSecrets(String(JSON.stringify(hook.data.tool_input)), owned.secrets));
-        sendJson(res, 200, checked.response);
     });
 }